dumb-dev/TinyLlama-1.1B-Chat-rust-cpp-encodings
Text Generation
β’
Updated
β’
31
Datasets:
text
stringlengths 424
69.5k
|
|---|
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Takahashi has a tower which is divided into N layers. Initially, all the layers are uncolored. Takahashi is going to paint some of the layers in red, green or blue to make a beautiful tower. He defines the beauty of the tower as follows:
* The beauty of the tower is the sum of the scores of the N layers, where the score of a layer is A if the layer is painted red, A+B if the layer is painted green, B if the layer is painted blue, and 0 if the layer is uncolored.
Here, A and B are positive integer constants given beforehand. Also note that a layer may not be painted in two or more colors.
Takahashi is planning to paint the tower so that the beauty of the tower becomes exactly K. How many such ways are there to paint the tower? Find the count modulo 998244353. Two ways to paint the tower are considered different when there exists a layer that is painted in different colors, or a layer that is painted in some color in one of the ways and not in the other.
Constraints
* 1 β€ N β€ 3Γ10^5
* 1 β€ A,B β€ 3Γ10^5
* 0 β€ K β€ 18Γ10^{10}
* All values in the input are integers.
Input
Input is given from Standard Input in the following format:
N A B K
Output
Print the number of the ways to paint tiles, modulo 998244353.
Examples
Input
4 1 2 5
Output
40
Input
2 5 6 0
Output
1
Input
90081 33447 90629 6391049189
Output
577742975
### Response
```cpp
#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define ll long long
#define maxn 1000005
#define inf 1e9
#define pb push_back
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define per(i,a,b) for(int i=a;i>=b;i--)
using namespace std;
ll fac[maxn],inv[maxn],n,k,a,b,c,ans;
const ll mod=998244353;
inline ll pw(ll a,ll b)
{
ll ans=1,base=a;
while(b)
{
if(b&1) ans=(ans*base)%mod;
base=(base*base)%mod; b>>=1;
}
return ans;
}
inline ll C(ll N,ll M){return (fac[N]*inv[M]%mod)*inv[N-M]%mod;}
int main()
{
fac[0]=1; inv[0]=1;
rep(i,1,(maxn-5)) fac[i]=(fac[i-1]*i)%mod;
rep(i,1,(maxn-5)) inv[i]=pw(fac[i],mod-2);
cin>>n>>a>>b>>k;
for(ll i=0;i<=n;i++)
{
ll res=k-i*a; if(res<0) break;
if(res%b!=0||res/b>n) continue;
ll x=i,y=res/b; ans=(ans+C(n,x)*C(n,y))%mod;
}
cout<<ans<<endl;
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws n sticks in a row. After that the players take turns crossing out exactly k sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than k sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.
Input
The first line contains two integers n and k (1 β€ n, k β€ 1018, k β€ n) β the number of sticks drawn by Sasha and the number k β the number of sticks to be crossed out on each turn.
Output
If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print each letter in arbitrary case (upper of lower).
Examples
Input
1 1
Output
YES
Input
10 4
Output
NO
Note
In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins.
In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
long long int n, k, b, c, x, y, z;
long long int counter = 0, counter1 = 0, counter2 = 0;
long long int sum = 0, result = 0, ans = 0, flag = 0;
cin >> n >> k;
counter = n / k;
if (counter & 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
Adilbek's house is located on a street which can be represented as the OX axis. This street is really dark, so Adilbek wants to install some post lamps to illuminate it. Street has n positions to install lamps, they correspond to the integer numbers from 0 to n - 1 on the OX axis. However, some positions are blocked and no post lamp can be placed there.
There are post lamps of different types which differ only by their power. When placed in position x, post lamp of power l illuminates the segment [x; x + l]. The power of each post lamp is always a positive integer number.
The post lamp shop provides an infinite amount of lamps of each type from power 1 to power k. Though each customer is only allowed to order post lamps of exactly one type. Post lamps of power l cost a_l each.
What is the minimal total cost of the post lamps of exactly one type Adilbek can buy to illuminate the entire segment [0; n] of the street? If some lamps illuminate any other segment of the street, Adilbek does not care, so, for example, he may place a lamp of power 3 in position n - 1 (even though its illumination zone doesn't completely belong to segment [0; n]).
Input
The first line contains three integer numbers n, m and k (1 β€ k β€ n β€ 10^6, 0 β€ m β€ n) β the length of the segment of the street Adilbek wants to illuminate, the number of the blocked positions and the maximum power of the post lamp available.
The second line contains m integer numbers s_1, s_2, ..., s_m (0 β€ s_1 < s_2 < ... s_m < n) β the blocked positions.
The third line contains k integer numbers a_1, a_2, ..., a_k (1 β€ a_i β€ 10^6) β the costs of the post lamps.
Output
Print the minimal total cost of the post lamps of exactly one type Adilbek can buy to illuminate the entire segment [0; n] of the street.
If illumintaing the entire segment [0; n] is impossible, print -1.
Examples
Input
6 2 3
1 3
1 2 3
Output
6
Input
4 3 4
1 2 3
1 10 100 1000
Output
1000
Input
5 1 5
0
3 3 3 3 3
Output
-1
Input
7 4 3
2 4 5 6
3 14 15
Output
-1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, k;
cin >> n >> m >> k;
vector<bool> pos(n, false);
for (int i = 0; i < m; i++) {
long long x;
cin >> x;
pos[x] = true;
}
long long mx = 0;
long long cur = 0;
for (long long i = 0; i < n; i++) {
if (!pos[i])
cur = 0;
else {
cur++;
mx = max(mx, cur);
}
}
vector<long long> price(k + 1);
for (long long i = 1; i <= k; i++) {
long long x;
cin >> x;
price[i] = x;
}
if (pos[0] || mx >= k) {
cout << "-1";
return 0;
}
long long prev[n];
prev[0] = 0;
for (long long i = 1; i < n; i++) {
if (pos[i] == false)
prev[i] = i;
else
prev[i] = prev[i - 1];
}
long long ans = 1e15;
for (int i = mx + 1; i <= k; i++) {
long long s = 0;
long long cnt = 0;
while (s < n) {
cnt++;
s = prev[s] + i;
}
ans = min(ans, cnt * price[i]);
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Given a string s, find the number of ways to split s to substrings such that if there are k substrings (p1, p2, p3, ..., pk) in partition, then pi = pk - i + 1 for all i (1 β€ i β€ k) and k is even.
Since the number of ways can be large, print it modulo 109 + 7.
Input
The only line of input contains a string s (2 β€ |s| β€ 106) of even length consisting of lowercase Latin letters.
Output
Print one integer, the number of ways of partitioning the string modulo 109 + 7.
Examples
Input
abcdcdab
Output
1
Input
abbababababbab
Output
3
Note
In the first case, the only way to partition the string is ab|cd|cd|ab.
In the second case, the string can be partitioned as ab|b|ab|ab|ab|ab|b|ab or ab|b|abab|abab|b|ab or abbab|ab|ab|abbab.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010, mod = 1e9 + 7;
int ch[N][26], fa[N], g[N], f[N], tot, lst, nxt[N], l[N], s[N], dif[N], pos[N];
char t[N];
int read() {
int x = 0;
char c = getchar(), flag = '+';
while (!isdigit(c)) flag = c, c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
return flag == '-' ? -x : x;
}
int Insert(int x, int c) {
int p = lst;
while (s[x - l[p] - 1] ^ c) p = fa[p];
if (!ch[p][c]) {
int now = ++tot, q = fa[p];
l[now] = l[p] + 2;
while (s[x - l[q] - 1] ^ c) q = fa[q];
int t = ch[q][c];
dif[now] = l[now] - l[t];
fa[now] = t;
if (dif[now] == dif[t])
nxt[now] = nxt[t];
else
nxt[now] = t;
ch[p][c] = now;
}
return lst = ch[p][c];
}
int main() {
scanf("%s", t + 1);
int n = strlen(t + 1);
for (int i = 1; i <= n; i++) {
if (i & 1)
s[i] = t[i + 1 >> 1] - 'a';
else
s[i] = t[n - i / 2 + 1] - 'a';
}
s[0] = -1;
tot = 1, l[1] = -1, fa[0] = 1;
for (int i = 1; i <= n; i++) pos[i] = Insert(i, s[i]);
f[0] = 1;
for (int i = 1; i <= n; i++) {
for (int x = pos[i]; x; x = nxt[x]) {
g[x] = f[i - l[nxt[x]] - dif[x]];
if (dif[x] == dif[fa[x]])
g[x] = g[x] + g[fa[x]] >= mod ? g[x] + g[fa[x]] - mod : g[x] + g[fa[x]];
if (!(i & 1)) f[i] = f[i] + g[x] >= mod ? f[i] + g[x] - mod : f[i] + g[x];
}
}
cout << f[n];
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
There are two standard ways to represent a graph $G = (V, E)$, where $V$ is a set of vertices and $E$ is a set of edges; Adjacency list representation and Adjacency matrix representation.
An adjacency-list representation consists of an array $Adj[|V|]$ of $|V|$ lists, one for each vertex in $V$. For each $u \in V$, the adjacency list $Adj[u]$ contains all vertices $v$ such that there is an edge $(u, v) \in E$. That is, $Adj[u]$ consists of all vertices adjacent to $u$ in $G$.
An adjacency-matrix representation consists of $|V| \times |V|$ matrix $A = a_{ij}$ such that $a_{ij} = 1$ if $(i, j) \in E$, $a_{ij} = 0$ otherwise.
Write a program which reads a directed graph $G$ represented by the adjacency list, and prints its adjacency-matrix representation. $G$ consists of $n\; (=|V|)$ vertices identified by their IDs $1, 2,.., n$ respectively.
Constraints
* $1 \leq n \leq 100$
Input
In the first line, an integer $n$ is given. In the next $n$ lines, an adjacency list $Adj[u]$ for vertex $u$ are given in the following format:
$u$ $k$ $v_1$ $v_2$ ... $v_k$
$u$ is vertex ID and $k$ denotes its degree. $v_i$ are IDs of vertices adjacent to $u$.
Output
As shown in the following sample output, print the adjacent-matrix representation of $G$. Put a single space character between $a_{ij}$.
Example
Input
4
1 2 2 4
2 1 4
3 0
4 1 3
Output
0 1 0 1
0 0 0 1
0 0 0 0
0 0 1 0
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int M[101][101];
int main(){
int n,u,k,v;
cin>>n;
for(int i=0;i<n;i++){
cin>>u>>k;
u--;
for(int j=0;j<k;j++){
cin>>v;
v--;
M[u][v]=1;
}
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(j) cout<<" ";
cout<<M[i][j];
}
cout<<endl;
}
return 0;
}
``` |
### Prompt
Please formulate a cpp solution to the following problem:
You are given a rooted tree. Let's denote d(x) as depth of node x: depth of the root is 1, depth of any other node x is d(y) + 1, where y is a parent of x.
The tree has the following property: every node x with d(x) = i has exactly ai children. Maximum possible depth of a node is n, and an = 0.
We define fk as the number of unordered pairs of vertices in the tree such that the number of edges on the simple path between them is equal to k.
Calculate fk modulo 109 + 7 for every 1 β€ k β€ 2n - 2.
Input
The first line of input contains an integer n (2 β€ n β€ 5 000) β the maximum depth of a node.
The second line of input contains n - 1 integers a1, a2, ..., an - 1 (2 β€ ai β€ 109), where ai is the number of children of every node x such that d(x) = i. Since an = 0, it is not given in the input.
Output
Print 2n - 2 numbers. The k-th of these numbers must be equal to fk modulo 109 + 7.
Examples
Input
4
2 2 2
Output
14 19 20 20 16 16
Input
3
2 3
Output
8 13 6 9
Note
This the tree from the first sample:
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long N = 3e5 + 5;
const long long INF = 1e14;
long long bpow(long long a, long long b, long long m) {
long long x, y;
x = 1;
y = a;
while (b > 0) {
if (b % 2 == 1) x = (x * y) % MOD;
y = (y * y) % MOD;
b /= 2;
}
return x;
}
long long inv(long long i) { return bpow(i, MOD - 2, MOD); }
long long dp[3][10005][3];
long long a[5005];
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
long long a[5005];
for (long long i = 0; i < n - 1; i++) {
cin >> a[i + 1];
}
for (long long i = 0; i < 2 * n - 1; i++) {
for (long long j = 0; j < 3; j++) dp[1][i][j] = dp[2][i][j] = 0;
}
dp[2][0][0] = 1;
long long num = 1;
for (long long r = 2; r < n + 1; r++) {
for (long long j = 1; j < 2 * n - 1; j++)
for (long long p = 0; p < 3; p++) {
dp[0][j][p] = dp[1][j][p];
dp[1][j][p] = dp[2][j][p];
}
long long i = 2;
for (long long j = 1; j < 2 * n - 1; j++) {
dp[i][j][0] =
((dp[i - 1][j][0] + dp[i - 1][j][1]) % MOD + dp[i - 1][j][2]) % MOD;
if (j == 0) {
dp[i][j][1] = 0;
} else if (j == 1) {
dp[i][j][1] = (num * a[r - 1]) % MOD;
} else {
dp[i][j][1] = (((dp[i - 1][j - 1][2] * 2) % MOD * a[r - 1]) % MOD +
(dp[i - 1][j - 1][1] * a[r - 1]) % MOD) %
MOD;
}
if (j == 0 || j == 1) {
dp[i][j][2] = 0;
} else if (j == 2) {
dp[i][j][2] =
(((num * a[r - 1]) % MOD * (a[r - 1] - 1)) % MOD * inv(2)) % MOD;
} else {
dp[i][j][2] = ((dp[i - 1][j - 2][2] * a[r - 1]) % MOD * a[r - 1]) % MOD;
}
}
num = (num * a[r - 1]) % MOD;
}
for (long long j = 1; j < 2 * n - 1; j++) {
long long ans = ((dp[2][j][0] + dp[2][j][1]) % MOD + dp[2][j][2]) % MOD;
cout << ans << " ";
}
cout << "\n";
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Please notice the unusual memory limit of this problem.
Orac likes games. Recently he came up with the new game, "Game of Life".
You should play this game on a black and white grid with n rows and m columns. Each cell is either black or white.
For each iteration of the game (the initial iteration is 0), the color of each cell will change under the following rules:
* If there are no adjacent cells with the same color as this cell on the current iteration, the color of it on the next iteration will be the same.
* Otherwise, the color of the cell on the next iteration will be different.
Two cells are adjacent if they have a mutual edge.
Now Orac has set an initial situation, and he wants to know for the cell (i,j) (in i-th row and j-th column), what will be its color at the iteration p. He may ask you these questions several times.
Input
The first line contains three integers n,m,t\ (1β€ n,mβ€ 1000, 1β€ tβ€ 100 000), representing the number of rows, columns, and the number of Orac queries.
Each of the following n lines contains a binary string of length m, the j-th character in i-th line represents the initial color of cell (i,j). '0' stands for white, '1' stands for black.
Each of the following t lines contains three integers i,j,p\ (1β€ iβ€ n, 1β€ jβ€ m, 1β€ pβ€ 10^{18}), representing a query from Orac.
Output
Print t lines, in i-th line you should print the answer to the i-th query by Orac. If the color of this cell is black, you should print '1'; otherwise, you should write '0'.
Examples
Input
3 3 3
000
111
000
1 1 1
2 2 2
3 3 3
Output
1
1
1
Input
5 2 2
01
10
01
10
01
1 1 4
5 1 4
Output
0
0
Input
5 5 3
01011
10110
01101
11010
10101
1 1 4
1 2 3
5 5 3
Output
1
0
1
Input
1 1 3
0
1 1 1
1 1 2
1 1 3
Output
0
0
0
Note
<image>
For the first example, the picture above shows the initial situation and the color of cells at the iteration 1, 2, and 3. We can see that the color of (1,1) at the iteration 1 is black, the color of (2,2) at the iteration 2 is black, and the color of (3,3) at the iteration 3 is also black.
For the second example, you can prove that the cells will never change their colors.
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long INF = 2000000000000000000LL;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
struct ITEM {
int x, y;
} q[1010 * 1010];
int n, m, t, qh, qt;
long long f[1010][1010];
char a[1010][1010];
bool check(const int x, const int y) {
for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (nx > 0 && ny > 0 && nx <= n && ny <= m && a[nx][ny] == a[x][y])
return true;
}
return false;
}
void bfs() {
while (qh < qt) {
ITEM& u = q[qh++];
for (int i = 0; i < 4; i++) {
int nx = u.x + dx[i];
int ny = u.y + dy[i];
if (!(nx > 0 && ny > 0 && nx <= n && ny <= m)) continue;
if (f[nx][ny] != INF) continue;
f[nx][ny] = f[u.x][u.y] + 1;
q[qt++] = (ITEM){nx, ny};
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &t);
for (int i = 1; i <= n; i++) scanf("%s", a[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) f[i][j] = INF;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (check(i, j)) {
q[qt++] = (ITEM){i, j};
f[i][j] = 0;
}
}
bfs();
for (int i = 1, x, y; i <= t; i++) {
long long p;
scanf("%d %d %I64d", &x, &y, &p);
if (p <= f[x][y] || !((p - f[x][y]) & 1))
printf("%c\n", a[x][y]);
else
printf("%c\n", '0' + '1' - a[x][y]);
}
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
The cloth coasters produced and sold by Aizu Takada City are known for their symmetrical design and great beauty. As part of quality control, Aizu Takada City has installed cameras on the production line to automatically verify that the images obtained by shooting each coaster are symmetrical. Each coaster is represented as a square black and white image of N x N pixels. Each pixel has a value of 0 or 1 corresponding to a white or black image.
This time, the software of the image analysis system will be updated along with the equipment update of the production line. The new system has been devised to reduce the amount of communication data, and data is sent from the camera to the analysis system by the following method.
* The information of the first coaster flowing on the line is sent to the system as an N Γ N pixel image.
* For the coaster information on the second and subsequent images, only the difference from the previous image is sent. The difference is given as a set of pixel positions that change from "0 to 1" or "1 to 0".
For C coasters, enter the pixel information of the first image and the difference information of the following C-1 image, and create a program that reports the number of coasters that are vertically symmetrical and symmetrical.
Input
The input is given in the following format.
C N
p11p12 ... p1N
p21p22 ... p2N
::
pN1pN2 ... pNN
diff1
diff2
::
diffC-1
The first line gives the number of coasters C (1 β€ C β€ 10000) and the number of pixels N (2 β€ N β€ 1000 and N is even) in the vertical and horizontal directions of the image. Lines 2 to N + 1 are given the number pij (pij is 0 or 1) in rows N x columns N representing the pixels of the image of the first coaster.
After the N + 2nd line, the difference diffi representing the information of the 2nd and subsequent coasters is given in the following format.
D
r1 c1
r2 c2
::
rD cD
The number of changed pixels D (0 β€ D β€ 100) is given in the first line. The following D rows are given ri and ci (1 β€ ri, ci β€ N), which represent the row and column numbers of the changed pixels, respectively. The same position cannot be given more than once in diffi.
Output
The number of coasters that are vertically symmetrical and symmetrical is output on one line.
Examples
Input
7 8
00100000
00011000
10111101
01100110
01000110
10111101
00011000
00100100
2
5 3
1 6
1
6 8
3
6 8
3 3
3 6
2
6 3
6 6
0
2
3 8
6 8
Output
3
Input
1 6
000000
000000
010010
010010
000000
000000
Output
1
Input
2 2
00
00
4
1 1
1 2
2 1
2 2
Output
2
### Response
```cpp
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;++i)
#define rrep(i,n) for(int i=n-1;i>0;--i)
#define yesno(flg) if(flg){cout<<"Yes"<<endl;}else{cout<<"No"<<endl;}
#define Vi vector<int>
#define Vl vector<long long>
#define pb(a) push_back(a)
using namespace std;
typedef long long ll;
const int inf=1000000000;
const int np=1000000007;
struct edge{
int myc,to,c,cost;
};
struct pos{
int to,cost,color;
};
int dy[]={0, 0, 1, -1};
int dx[]={1, -1, 0, 0};
int main() {
int c,n;
string p[1000];
cin>>c>>n;
rep(i,n)cin>>p[i];
int t=0;
rep(i,n/2){
rep(j,n/2){
int s=0;
if(p[i][j]==p[i][n-1-j])s++;
if(p[i][j]==p[n-1-i][j])s++;
if(p[n-1-i][j]==p[n-1-i][n-1-j])s++;
if(s<3)t++;
}
}
int r=0;
if(t==0)r++;
rep(i,c-1){
int d;
cin>>d;
rep(j,d){
int x,y;
cin>>x>>y;
x--;
y--;
int s=0;
if(p[x][y]==p[x][n-y-1])s++;
if(p[x][y]==p[n-1-x][y])s++;
if(p[n-1-x][y]==p[n-1-x][n-1-y])s++;
if(s<3)t--;
s=0;
if(p[x][y]=='0'){
p[x][y]='1';
}else{
p[x][y]='0';
}
if(p[x][y]==p[x][n-y-1])s++;
if(p[x][y]==p[n-1-x][y])s++;
if(p[n-1-x][y]==p[n-1-x][n-1-y])s++;
if(s<3)t++;
}
if(t==0)r++;
}
cout<<r<<endl;
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
We'll call an array of n non-negative integers a[1], a[2], ..., a[n] interesting, if it meets m constraints. The i-th of the m constraints consists of three integers li, ri, qi (1 β€ li β€ ri β€ n) meaning that value <image> should be equal to qi.
Your task is to find any interesting array of n elements or state that such array doesn't exist.
Expression x&y means the bitwise AND of numbers x and y. In programming languages C++, Java and Python this operation is represented as "&", in Pascal β as "and".
Input
The first line contains two integers n, m (1 β€ n β€ 105, 1 β€ m β€ 105) β the number of elements in the array and the number of limits.
Each of the next m lines contains three integers li, ri, qi (1 β€ li β€ ri β€ n, 0 β€ qi < 230) describing the i-th limit.
Output
If the interesting array exists, in the first line print "YES" (without the quotes) and in the second line print n integers a[1], a[2], ..., a[n] (0 β€ a[i] < 230) decribing the interesting array. If there are multiple answers, print any of them.
If the interesting array doesn't exist, print "NO" (without the quotes) in the single line.
Examples
Input
3 1
1 3 3
Output
YES
3 3 3
Input
3 2
1 3 3
1 3 2
Output
NO
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct Tree {
int sz;
vector<int> t;
vector<int> d;
Tree(int sz) : sz(sz), t(sz * 4), d(sz * 4) {}
void push(int v) {
d[2 * v + 1] |= d[v];
t[2 * v + 1] |= d[v];
d[2 * v + 2] |= d[v];
t[2 * v + 2] |= d[v];
d[v] = 0;
}
int get(int v) { return t[v] & d[v]; }
void OrImpl(int v, int tl, int tr, int l, int r, int value) {
if (l >= r) return;
if (l == tl && r == tr) {
t[v] |= value;
d[v] |= value;
return;
}
push(v);
int tm = (tl + tr) / 2;
OrImpl(2 * v + 1, tl, tm, l, min(r, tm), value);
OrImpl(2 * v + 2, tm, tr, max(l, tm), r, value);
t[v] = t[2 * v + 1] & t[2 * v + 2];
}
void Or(int l, int r, int value) { OrImpl(0, 0, sz, l, r, value); }
int GetAndImpl(int v, int tl, int tr, int l, int r) {
if (l >= r) return -1;
if (l == tl && r == tr) {
return t[v];
}
push(v);
int tm = (tl + tr) / 2;
return GetAndImpl(2 * v + 1, tl, tm, l, min(r, tm)) &
GetAndImpl(2 * v + 2, tm, tr, max(l, tm), r);
}
int GetAnd(int l, int r) { return GetAndImpl(0, 0, sz, l, r); }
};
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> a(m);
vector<int> b(m);
vector<int> c(m);
Tree t(n);
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i] >> c[i];
a[i]--;
}
for (int i = 0; i < m; i++) {
t.Or(a[i], b[i], c[i]);
}
for (int i = 0; i < m; i++) {
int x = t.GetAnd(a[i], b[i]);
if (x != c[i]) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
cout << t.GetAnd(i, i + 1) << " ";
}
cout << endl;
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
There was no problem about a cactus at the NERC 2020 online round. That's a bad mistake, so judges decided to fix it. You shall not pass to the World Finals 2021 without solving a problem about a cactus!
A cactus is a connected undirected graph in which every edge lies on at most one simple cycle. Intuitively, a cactus is a generalization of a tree where some cycles are allowed. Multiedges (multiple edges between a pair of vertices) and loops (edges that connect a vertex to itself) are not allowed in a cactus.
Cher has got a cactus. She calls cactus strong if it is impossible to add an edge to it in such a way that it still remains a cactus. But Cher thinks her cactus is not strong enough. She wants to add the smallest possible number of edges to it to make it strong, i. e. to create a new cactus with the same vertices, so that the original cactus is a subgraph of the new one, and it is impossible to add another edge to it so that the graph remains a cactus. Cher hired you to do this job for her. So... it's on you!
Input
The input consists of one or more independent test cases.
The first line of each test case contains two integers n and m (1 β€ n β€ 10^5, 0 β€ m β€ 10^5), where n is the number of vertices in the graph. Vertices are numbered from 1 to n. Edges of the graph are represented by a set of edge-distinct paths, where m is the number of such paths.
Each of the following m lines contains a path in the graph. A path starts with an integer number s_i (2 β€ s_i β€ 1000) followed by s_i integers from 1 to n. These s_i integers represent vertices of a path. Adjacent vertices in a path are distinct. The path can go through the same vertex multiple times, but every edge is traversed exactly once in the whole test case. There are no multiedges in the graph (there is at most one edge between any two vertices).
The last line of the input after all test cases always contains two zeros. It does not define a test case. It just marks the end of the input and does not require any output.
All graphs in the input are cacti. The total sum of all values of n and the total sum of all values of m throughout the input both do not exceed 10^5.
Output
For each test case, first output the line with the minimal possible number of additional edges A. Then output A lines, each describing one edge as u_i v_i, where u_i and v_i are the numbers of vertices to connect. After adding these edges, the resulting graph must be a strong cactus.
Example
Input
6 1
7 1 2 5 6 2 3 4
3 1
4 1 2 3 1
5 2
3 1 3 5
3 1 2 4
7 2
6 1 2 3 4 5 3
3 6 5 7
0 0
Output
1
1 4
0
1
5 4
2
1 3
6 7
### Response
```cpp
#pragma GCC optimize(3)
#include<bits/stdc++.h>
using namespace std;
struct front_star{
int to,next;
}e[500050];
struct grp{
int fp,sp;
}ans[500050];
front_star eg[500050];
int n,m,cnt=1,t=0,tot=0,all=0,root;
int head[100005],dfn[100005],low[100005],brg[500005],hd[100005],vis[100005],sz[100005],dep[100005],upt[100005];
inline int read()
{
int X=0,w=0; char ch=0;
while(!isdigit(ch)) {w|=ch=='-';ch=getchar();}
while(isdigit(ch)) X=(X<<3)+(X<<1)+(ch^48),ch=getchar();
return w?-X:X;
}
inline void write(int x)
{
if(x<0) putchar('-'),x=-x;
if(x>9) write(x/10);
putchar(x%10+'0');
}
inline void addedge(int u,int v)
{
cnt++;
e[cnt].to=v;
e[cnt].next=head[u];
head[u]=cnt;
}
inline void adde(int u,int v)
{
tot++;
eg[tot].to=v;
eg[tot].next=hd[u];
hd[u]=tot;
}
inline void tarjan(int x,int in_edge)
{
t++;
dfn[x]=low[x]=t;
for(register int i=head[x];~i;i=e[i].next)
{
int y=e[i].to;
if(!dfn[y])
{
tarjan(y,i);
low[x]=min(low[x],low[y]);
if(low[y]>dfn[x])
brg[i]=brg[i^1]=1;
}else if(i!=(in_edge^1))
low[x]=min(low[x],dfn[y]);
}
}
inline void dfs(int u,int fa)
{
int spe=0;
vis[u]=1;
upt[u]=u;
for(register int i=hd[u];~i;i=eg[i].next)
{
int v=eg[i].to;
if(v==fa)
continue;
sz[u]++;
if(!vis[v])
{
dep[v]=dep[u]+1;
dfs(v,u);
if(v==upt[v])
spe=v;
}
}
int pt=0,num=sz[u];
if(u==root)
{
if(num%2==0)
{
for(register int i=hd[u];~i;i=eg[i].next)
{
int v=eg[i].to;
if(v==fa)
continue;
pt++;
if(pt%2==1)
{
all++;
ans[all].fp=upt[v];
}
else
ans[all].sp=upt[v];
}
}
else
{
if(spe)
num--;
for(register int i=hd[u];~i;i=eg[i].next)
{
int v=eg[i].to;
if(v==fa||v==spe)
continue;
pt++;
if(pt%2==1)
{
all++;
ans[all].fp=upt[v];
if(pt==num)
ans[all].sp=u;
}
else
ans[all].sp=upt[v];
}
}
}
else
{
if(num%2==0)
{
if(spe)
num--;
for(register int i=hd[u];~i;i=eg[i].next)
{
int v=eg[i].to;
if(v==fa||v==spe)
continue;
pt++;
if(pt%2==1)
{
if(pt==num)
{
upt[u]=upt[v];
continue;
}
all++;
ans[all].fp=upt[v];
}
else
ans[all].sp=upt[v];
}
}
else
{
for(register int i=hd[u];~i;i=eg[i].next)
{
int v=eg[i].to;
if(v==fa)
continue;
pt++;
if(pt%2==1)
{
if(pt==num)
{
upt[u]=upt[v];
continue;
}
all++;
ans[all].fp=upt[v];
}
else
ans[all].sp=upt[v];
}
}
}
}
int main()
{
memset(head,-1,sizeof(head));
memset(dfn,0,sizeof(dfn));
memset(low,0,sizeof(low));
memset(brg,0,sizeof(brg));
memset(hd,-1,sizeof(hd));
memset(vis,0,sizeof(vis));
memset(sz,0,sizeof(sz));
while(1)
{
t=0;
cnt=1;
tot=0;
all=0;
n=read();
m=read();
if(n==0&&m==0)
break;
for(register int i=1;i<=m;i++)
{
int s;
s=read();
int a,b;
for(register int j=1;j<=s;j++)
{
a=read();
if(j!=1)
{
addedge(b,a);
addedge(a,b);
}
b=a;
}
}
for(register int i=1;i<=n;i++)
{
if(!dfn[i])
tarjan(i,0);
}
for(register int i=1;i<=n;i++)
for(register int j=head[i];~j;j=e[j].next)
{
if(brg[j])
adde(i,e[j].to);
}
for(register int i=1;i<=n;i++)
{
if(!vis[i])
{
root=i;
dep[i]=1;
dfs(i,0);
}
}
write(all);
printf("\n");
for(register int i=1;i<=all;i++)
{
write(ans[i].fp);
printf(" ");
write(ans[i].sp);
printf("\n");
}
for(int i=1;i<=n;i++)
{
head[i]=-1;
dfn[i]=0;
low[i]=0;
hd[i]=-1;
vis[i]=0;
sz[i]=0;
}
for(int i=1;i<=cnt+1;i++)
brg[i]=0;
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
DZY loves planting, and he enjoys solving tree problems.
DZY has a weighted tree (connected undirected graph without cycles) containing n nodes (they are numbered from 1 to n). He defines the function g(x, y) (1 β€ x, y β€ n) as the longest edge in the shortest path between nodes x and y. Specially g(z, z) = 0 for every z.
For every integer sequence p1, p2, ..., pn (1 β€ pi β€ n), DZY defines f(p) as <image>.
DZY wants to find such a sequence p that f(p) has maximum possible value. But there is one more restriction: the element j can appear in p at most xj times.
Please, find the maximum possible f(p) under the described restrictions.
Input
The first line contains an integer n (1 β€ n β€ 3000).
Each of the next n - 1 lines contains three integers ai, bi, ci (1 β€ ai, bi β€ n; 1 β€ ci β€ 10000), denoting an edge between ai and bi with length ci. It is guaranteed that these edges form a tree.
Each of the next n lines describes an element of sequence x. The j-th line contains an integer xj (1 β€ xj β€ n).
Output
Print a single integer representing the answer.
Examples
Input
4
1 2 1
2 3 2
3 4 3
1
1
1
1
Output
2
Input
4
1 2 1
2 3 2
3 4 3
4
4
4
4
Output
3
Note
In the first sample, one of the optimal p is [4, 3, 2, 1].
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3001;
int ex[MAXN], ey[MAXN], w[MAXN], f[MAXN], sum, par[MAXN], sz[MAXN], sumF[MAXN];
pair<int, int> all[MAXN];
bool bad;
int find(int x) {
if (par[x] != x) par[x] = find(par[x]);
return par[x];
}
void merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
sz[x] += sz[y];
sumF[x] += sumF[y];
par[y] = x;
if (sum - sumF[x] < sz[x]) bad = true;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> ex[i] >> ey[i] >> w[i];
ex[i]--;
ey[i]--;
all[i] = pair<int, int>(w[i], i);
}
for (int i = 0; i < n; i++)
cin >> f[i], sum += f[i], sumF[i] = f[i], par[i] = i, sz[i] = 1;
sort(all, all + n - 1);
int ans = 0, cur = 0;
while (cur < n - 1) {
int edgeId = all[cur].second;
if (!bad) ans = w[edgeId];
merge(ex[edgeId], ey[edgeId]);
while (cur < n - 1 && w[edgeId] == all[cur].first)
merge(ex[all[cur].second], ey[all[cur].second]), cur++;
}
if (!bad && n > 1) ans = w[all[n - 2].second];
cout << ans << endl;
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Thank you for helping Heidi! It is now the second of April, but she has been summoned by Jenny again. The pranks do not seem to end...
In the meantime, Heidi has decided that she does not trust her friends anymore. Not too much, anyway. Her relative lack of trust is manifested as follows: whereas previously she would not be made to visit the same person twice, now she can only be sure that she will not be made to visit the same person more than k times. (In the case of Jenny, this includes her first visit in the beginning. The situation from the easy version corresponds to setting k = 1.)
This is not as bad as it looks, since a single ticket for a route between two friends allows Heidi to travel between this pair of friends the whole day (in both directions). In other words, once she pays for travel between a pair of friends, all further travels between that pair are free.
How much money will Heidi waste now, in a worst-case scenario?
Input
The first line contains two space-separated integers β the number of friends n (<image>) and the parameter k (1 β€ k β€ 105). The next n - 1 lines each contain three space-separated integers u, v and c (0 β€ u, v β€ n - 1, 1 β€ c β€ 104) meaning that u and v are friends and the cost for traveling between u and v is c.
It is again guaranteed that the social network of the input forms a tree.
Output
Again, output a single integer β the maximum sum of costs of tickets.
Examples
Input
9 3
0 1 1
0 2 1
1 3 2
1 4 2
1 5 2
2 6 3
2 7 3
2 8 3
Output
15
Input
9 5
0 1 1
0 2 1
1 3 2
1 4 2
1 5 2
2 6 3
2 7 3
2 8 3
Output
17
Input
11 6
1 0 7932
2 1 1952
3 2 2227
4 0 9112
5 4 6067
6 0 6786
7 6 3883
8 4 7137
9 1 2796
10 5 6200
Output
54092
Note
In the first example, the worst-case scenario for Heidi is to visit the friends in the following order: 0, 1, 5, 1, 3, 1, 0, 2, 6, 2, 7, 2, 8. Observe that no friend is visited more than 3 times.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y) {
long long int res = 1;
while (y) {
if (y & 1) res = (res * x) % 1000000007;
y = y / 2, x = (x * x) % 1000000007;
}
return res % 1000000007;
}
long long int dp[100001][2] = {{0}};
vector<vector<pair<long long int, long long int> > > arr(100001);
long long int n, k;
void dfs(long long int u, long long int par) {
long long int cnt = 0;
vector<pair<long long int, long long int> > lol;
long long int i;
for (i = 0; i < arr[u].size(); i++) {
if (arr[u][i].first != par) {
dfs(arr[u][i].first, u);
dp[arr[u][i].first][0] += arr[u][i].second;
dp[arr[u][i].first][1] += arr[u][i].second;
cnt++;
}
}
if (cnt < k) {
cnt = 0;
for (i = 0; i < arr[u].size(); i++) {
if (arr[u][i].first != par)
dp[u][1] += dp[arr[u][i].first][1], cnt += dp[arr[u][i].first][1];
}
long long int tot = 0;
for (i = 0; i < arr[u].size(); i++) {
if (arr[u][i].first != par) {
tot = max(tot, cnt - dp[arr[u][i].first][1] + dp[arr[u][i].first][0]);
}
}
dp[u][0] = tot;
return;
}
for (i = 0; i < arr[u].size(); i++) {
if (arr[u][i].first != par)
lol.push_back(make_pair(dp[arr[u][i].first][1], arr[u][i].first));
}
sort(lol.begin(), lol.end());
reverse(lol.begin(), lol.end());
set<long long int> haha;
long long int ans = 0;
for (i = 0; i < k - 1; i++) ans += lol[i].first, haha.insert(lol[i].second);
dp[u][1] = ans;
ans += lol[k - 1].first;
haha.insert(lol[k - 1].second);
long long int tot = 0;
for (i = 0; i < arr[u].size(); i++) {
if (arr[u][i].first != par) {
if (haha.find(arr[u][i].first) != haha.end()) {
tot = max(tot, ans - dp[arr[u][i].first][1] + dp[arr[u][i].first][0]);
} else
tot = max(tot, dp[arr[u][i].first][0] + dp[u][1]);
}
}
dp[u][0] = tot;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
long long int i;
for (i = 0; i < n - 1; i++) {
long long int u, v, c;
cin >> u >> v >> c;
arr[u].push_back(make_pair(v, c));
arr[v].push_back(make_pair(u, c));
}
dfs(0, -1);
cout << dp[0][0];
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Write a program which reads two integers a, b and an operator op, and then prints the value of a op b.
The operator op is '+', '-', '*' or '/' (sum, difference, product or quotient). The division should truncate any fractional part.
Constraints
* 0 β€ a, b β€ 20000
* No divisions by zero are given.
Input
The input consists of multiple datasets. Each dataset is given in the following format.
a op b
The input ends with a dataset where op = '?'. Your program should not process for this dataset.
Output
For each dataset, print the value in a line.
Example
Input
1 + 2
56 - 18
13 * 2
100 / 10
27 + 81
0 ? 0
Output
3
38
26
10
108
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
int a, b;
char op;
while(1){
cin >> a >> op >> b;
if (op=='?') break;
if (op=='+') cout << a+b << endl;
else if (op=='-') cout << a-b << endl;
else if (op=='*') cout << a*b << endl;
else cout << a/b << endl;
}
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
<image>
It is well-known that the best decoration for a flower bed in Sweetland are vanilla muffins. Seedlings of this plant need sun to grow up. Slastyona has m seedlings, and the j-th seedling needs at least kj minutes of sunlight to grow up.
Most of the time it's sunny in Sweetland, but sometimes some caramel clouds come, the i-th of which will appear at time moment (minute) li and disappear at time moment ri. Of course, the clouds make shadows, and the seedlings can't grow when there is at least one cloud veiling the sun.
Slastyona wants to grow up her muffins as fast as possible. She has exactly C candies, which is the main currency in Sweetland.
One can dispel any cloud by paying ci candies. However, in order to comply with Sweetland's Department of Meteorology regulations, one can't dispel more than two clouds.
Slastyona hasn't decided yet which of the m seedlings will be planted at the princess' garden, so she needs your help. For each seedling determine the earliest moment it can grow up if Slastyona won't break the law and won't spend more candies than she has. Note that each of the seedlings is considered independently.
The seedlings start to grow at time moment 0.
Input
The first line contains two integers n and C (0 β€ n β€ 3Β·105, 0 β€ C β€ 109) β the number of caramel clouds and the number of candies Slastyona has.
The next n lines contain three integers each: li, ri, ci (0 β€ li < ri β€ 109, 0 β€ ci β€ 109), describing one caramel cloud.
The next line contains single integer m (1 β€ m β€ 3Β·105) β the number of seedlings. Each of the seedlings is described with one integer kj (1 β€ kj β€ 109) β the required number of sunny minutes.
Output
For each seedling print one integer β the minimum minute Slastyona can grow it up.
Examples
Input
3 5
1 7 1
1 6 2
1 7 1
3
7
2
5
Output
12
7
10
Input
3 15
1 4 17
2 8 6
4 8 9
2
5
1
Output
8
1
Input
2 10
3 7 9
10 90 10
2
10
100
Output
10
104
Note
Consider the first example. For each k it is optimal to dispel clouds 1 and 3. Then the remaining cloud will give shadow on time segment [1..6]. So, intervals [0..1] and [6..inf) are sunny.
<image>
In the second example for k = 1 it is not necessary to dispel anything, and for k = 5 the best strategy is to dispel clouds 2 and 3. This adds an additional sunny segment [4..8], which together with [0..1] allows to grow up the muffin at the eight minute.
<image> <image>
If the third example the two seedlings are completely different. For the first one it is necessary to dispel cloud 1 and obtain a sunny segment [0..10]. However, the same strategy gives answer 180 for the second seedling. Instead, we can dispel cloud 2, to make segments [0..3] and [7..inf) sunny, and this allows up to shorten the time to 104.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
map<int, int> pr[300000];
class stree {
public:
std::vector<std::pair<int, int> > t;
int s;
std::pair<int, int> combine(std::pair<int, int> a, std::pair<int, int> b) {
return make_pair(max(a.first, b.first),
max(max(a.second, b.second), min(a.first, b.first)));
}
void build(std::vector<int>& a, int v, int tl, int tr) {
if (v == 1) {
t.resize(a.size() * 4);
s = a.size();
}
if (tl == tr)
t[v] = make_pair(a[tl], 0);
else {
int tm = (tl + tr) / 2;
build(a, v * 2, tl, tm);
build(a, v * 2 + 1, tm + 1, tr);
t[v] = combine(t[v * 2], t[v * 2 + 1]);
}
}
void set(int v, int tl, int tr, int pos, int val) {
if (pos == tl && tr == pos) {
t[v] = make_pair(val, 0);
} else {
int tm = (tl + tr) / 2;
if (pos <= tm)
set(v * 2, tl, tm, pos, val);
else
set(v * 2 + 1, tm + 1, tr, pos, val);
t[v] = combine(t[v * 2], t[v * 2 + 1]);
}
}
std::pair<int, int> get(int v, int tl, int tr, int l, int r) {
if (l > r) return make_pair(0, 0);
if (tl == l && tr == r) return t[v];
int tm = (tl + tr) / 2;
return combine(get(v * 2, tl, tm, l, min(r, tm)),
get(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
};
std::vector<int> ctoi;
std::vector<int> lfori;
stree dj;
int main() {
int n, c;
scanf("%d %d", &n, &c);
std::vector<int> l(n), r(n), cost(n);
std::vector<std::pair<int, int> > allcost;
for (int i = 0; i < n; i++) scanf("%d %d %d", &l[i], &r[i], &cost[i]);
if (n == 0) {
int m;
scanf("%d", &m);
std::vector<int> q(m);
for (int i = 0; i < m; i++) {
scanf("%d", &q[i]);
printf("%d\n", q[i]);
}
return 0;
}
std::vector<int> def(n, 0);
dj.build(def, 1, 0, n - 1);
for (int i = 0; i < n; i++) allcost.push_back(make_pair(cost[i], i));
sort((allcost).begin(), (allcost).end());
ctoi.resize(n);
for (int i = 0; i < n; i++) ctoi[allcost[i].second] = i;
int re = n - 1;
lfori.resize(n);
for (int le = 0; le < n; le++) {
while (re >= 0 && allcost[le].first + allcost[re].first > c) re--;
lfori[le] = re;
}
std::vector<std::pair<int, int> > ev;
for (int i = 0; i < n; i++) {
ev.push_back(make_pair(l[i], -i - 1));
ev.push_back(make_pair(r[i], i + 1));
}
int m;
scanf("%d", &m);
std::vector<int> q(m);
for (int i = 0; i < m; i++) scanf("%d", &q[i]);
std::vector<int> qs = q;
int pq = 0;
map<int, int> ans;
sort((qs).begin(), (qs).end());
const int INF = 1e9;
ev.push_back(make_pair(2 * INF + 100, 0));
sort((ev).begin(), (ev).end());
const int A = 500;
std::vector<std::vector<int> > nb(n);
std::vector<int> big(n, 0);
int last = 0;
int fr = 0;
multiset<int> op;
int pt = 0;
std::vector<int> biglist;
std::pair<int, int> b2;
int b2res = 0;
std::vector<int> sin(n, 0);
std::vector<int> bestpair(n, 0);
std::vector<int> bestpval(n, 0);
while (1) {
if (pq == qs.size()) break;
auto x = ev[pt];
if (last == x.first) {
if (x.second < 0)
op.insert(-x.second - 1);
else
op.erase(op.find(x.second - 1));
pt++;
continue;
}
if (op.size() > 2)
last = x.first;
else if (op.size() == 2) {
auto it = op.begin();
int a = *it++;
int b = *it;
if (a > b) swap(a, b);
if (cost[a] + cost[b] > c) {
last = x.first;
continue;
}
if (pr[a].find(b) == pr[a].end()) {
nb[a].push_back(b);
nb[b].push_back(a);
pr[a][b] += x.first - last;
pr[b][a] += x.first - last;
if (nb[a].size() == A) {
for (auto x : pr[a]) {
int bt = x.first;
int abv = x.second;
if (bestpval[a] < abv + sin[bt] + sin[a]) {
bestpval[a] = abv + sin[bt] + sin[a];
bestpair[a] = bt;
}
}
big[a] = 1;
biglist.push_back(a);
}
if (nb[b].size() == A) {
for (auto x : pr[b]) {
int at = x.first;
int abv = x.second;
if (bestpval[b] < abv + sin[b] + sin[at]) {
bestpval[b] = abv + sin[b] + sin[at];
bestpair[b] = at;
}
}
big[b] = 1;
biglist.push_back(a);
}
} else {
pr[a][b] += x.first - last;
pr[b][a] += x.first - last;
}
int cand = fr + sin[a] + sin[b] + pr[a][b];
if (cand - fr > b2res) {
b2 = make_pair(a, b);
b2res = cand - fr;
}
while (pq != qs.size() && qs[pq] <= cand) {
ans[qs[pq]] = x.first - cand + qs[pq];
pq++;
}
last = x.first;
} else if (op.size() == 0) {
fr += x.first - last;
while (pq != qs.size() && qs[pq] <= fr + b2res) {
ans[qs[pq]] = x.first - fr - b2res + qs[pq];
pq++;
}
last = x.first;
} else {
int a = *op.begin();
if (cost[a] > c) {
last = x.first;
continue;
}
sin[a] += x.first - last;
int ind = ctoi[a];
int lind = lfori[ind];
dj.set(1, 0, n - 1, ind, sin[a]);
std::pair<int, int> res = dj.get(1, 0, n - 1, 0, lind);
if (ind <= lind && res.first == sin[a]) {
swap(res.first, res.second);
}
int cand = fr + sin[a] + res.first;
if (cand - fr > b2res) {
b2res = cand - fr;
}
while (pq != qs.size() && qs[pq] <= cand) {
ans[qs[pq]] = x.first - cand + qs[pq];
pq++;
}
if (!big[a]) {
for (auto u : pr[a]) {
int b = u.first;
int abv = u.second;
int cand = fr + sin[a] + sin[b] + abv;
if (cand - fr > b2res) {
b2 = make_pair(a, b);
b2res = cand - fr;
}
while (pq != qs.size() && qs[pq] <= cand) {
ans[qs[pq]] = x.first - cand + qs[pq];
pq++;
}
if (big[b]) {
if ((cand - fr) > bestpval[b]) {
bestpval[b] = cand - fr;
bestpair[b] = a;
}
}
}
} else {
int b = bestpair[a];
bestpval[a] += x.first - last;
int cand = bestpval[a] + fr;
if (cand - fr > b2res) {
b2 = make_pair(a, b);
b2res = cand - fr;
}
while (pq != qs.size() && qs[pq] <= cand) {
ans[qs[pq]] = x.first - cand + qs[pq];
pq++;
}
for (auto bc : biglist) {
if (bc == a) continue;
if (pr[a].find(bc) != pr[a].end()) {
int cand = sin[a] + sin[bc] + pr[a][bc];
if ((cand - fr) > bestpval[bc]) {
bestpval[bc] = cand;
bestpair[bc] = a;
}
}
}
}
last = x.first;
}
}
for (auto x : q) printf("%d\n", ans[x]);
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
As a New Year's gift, Dolphin received a string s of length 19.
The string s has the following format: `[five lowercase English letters],[seven lowercase English letters],[five lowercase English letters]`.
Dolphin wants to convert the comma-separated string s into a space-separated string.
Write a program to perform the conversion for him.
Constraints
* The length of s is 19.
* The sixth and fourteenth characters in s are `,`.
* The other characters in s are lowercase English letters.
Input
The input is given from Standard Input in the following format:
s
Output
Print the string after the conversion.
Examples
Input
happy,newyear,enjoy
Output
happy newyear enjoy
Input
haiku,atcoder,tasks
Output
haiku atcoder tasks
Input
abcde,fghihgf,edcba
Output
abcde fghihgf edcba
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string o;
int main(){
cin>>o;
for(char c:o)cout<<(c==','?' ':c);
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Now that Kuroni has reached 10 years old, he is a big boy and doesn't like arrays of integers as presents anymore. This year he wants a Bracket sequence as a Birthday present. More specifically, he wants a bracket sequence so complex that no matter how hard he tries, he will not be able to remove a simple subsequence!
We say that a string formed by n characters '(' or ')' is simple if its length n is even and positive, its first n/2 characters are '(', and its last n/2 characters are ')'. For example, the strings () and (()) are simple, while the strings )( and ()() are not simple.
Kuroni will be given a string formed by characters '(' and ')' (the given string is not necessarily simple). An operation consists of choosing a subsequence of the characters of the string that forms a simple string and removing all the characters of this subsequence from the string. Note that this subsequence doesn't have to be continuous. For example, he can apply the operation to the string ')()(()))', to choose a subsequence of bold characters, as it forms a simple string '(())', delete these bold characters from the string and to get '))()'.
Kuroni has to perform the minimum possible number of operations on the string, in such a way that no more operations can be performed on the remaining string. The resulting string does not have to be empty.
Since the given string is too large, Kuroni is unable to figure out how to minimize the number of operations. Can you help him do it instead?
A sequence of characters a is a subsequence of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters.
Input
The only line of input contains a string s (1 β€ |s| β€ 1000) formed by characters '(' and ')', where |s| is the length of s.
Output
In the first line, print an integer k β the minimum number of operations you have to apply. Then, print 2k lines describing the operations in the following format:
For each operation, print a line containing an integer m β the number of characters in the subsequence you will remove.
Then, print a line containing m integers 1 β€ a_1 < a_2 < ... < a_m β the indices of the characters you will remove. All integers must be less than or equal to the length of the current string, and the corresponding subsequence must form a simple string.
If there are multiple valid sequences of operations with the smallest k, you may print any of them.
Examples
Input
(()((
Output
1
2
1 3
Input
)(
Output
0
Input
(()())
Output
1
4
1 2 5 6
Note
In the first sample, the string is '(()(('. The operation described corresponds to deleting the bolded subsequence. The resulting string is '(((', and no more operations can be performed on it. Another valid answer is choosing indices 2 and 3, which results in the same final string.
In the second sample, it is already impossible to perform any operations.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char input[1005];
vector<int> open_idx;
vector<int> close_idx;
int valid_idxes[1005][1005];
int valid_idxes_len[1005];
int valid_idxes_sz = 0;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
scanf("%s", input);
while (true) {
open_idx.clear();
close_idx.clear();
for (int i = 0; input[i]; ++i) {
if (input[i] == '(')
open_idx.push_back(i + 1);
else if (input[i] == ')')
close_idx.push_back(i + 1);
}
int mx_remove = 0;
int mx_idx = -1;
for (int i = 0; i < open_idx.size(); ++i) {
int valid_close =
close_idx.end() -
lower_bound(close_idx.begin(), close_idx.end(), open_idx[i] + 1);
int val = min(valid_close, i + 1);
if (val > mx_remove) {
mx_remove = val;
mx_idx = i;
}
}
if (mx_idx == -1) break;
int valid_idxes_cur = 0;
for (int i = 0; i <= mx_idx; ++i) {
valid_idxes[valid_idxes_sz][valid_idxes_cur++] = open_idx[i];
input[open_idx[i] - 1] = ' ';
}
for (int i = (int)close_idx.size() - 1 - mx_idx; i < close_idx.size();
++i) {
valid_idxes[valid_idxes_sz][valid_idxes_cur++] = close_idx[i];
input[close_idx[i] - 1] = ' ';
}
valid_idxes_len[valid_idxes_sz++] = valid_idxes_cur;
}
printf("%d\n", valid_idxes_sz);
for (int i = 0; i < valid_idxes_sz; ++i) {
printf("%d\n", valid_idxes_len[i]);
for (int j = 0; j < valid_idxes_len[i]; ++j)
printf("%d ", valid_idxes[i][j]);
printf("\n");
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
Bizon the Champion isn't just charming, he also is very smart.
While some of us were learning the multiplication table, Bizon the Champion had fun in his own manner. Bizon the Champion painted an n Γ m multiplication table, where the element on the intersection of the i-th row and j-th column equals iΒ·j (the rows and columns of the table are numbered starting from 1). Then he was asked: what number in the table is the k-th largest number? Bizon the Champion always answered correctly and immediately. Can you repeat his success?
Consider the given multiplication table. If you write out all nΒ·m numbers from the table in the non-decreasing order, then the k-th number you write out is called the k-th largest number.
Input
The single line contains integers n, m and k (1 β€ n, m β€ 5Β·105; 1 β€ k β€ nΒ·m).
Output
Print the k-th largest number in a n Γ m multiplication table.
Examples
Input
2 2 2
Output
2
Input
2 3 4
Output
3
Input
1 10 5
Output
5
Note
A 2 Γ 3 multiplication table looks like this:
1 2 3
2 4 6
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int inf = 2147483647;
const long long llinf = 9223372036854775807LL;
int main() {
long long n, m, k;
cin >> n >> m >> k;
if (n > m) swap(n, m);
long long l = 1, r = n * m + 1;
while (l < r) {
long long res = 0;
long long mid = (l + r) / 2;
for (int i = 1; i <= n; i++) {
res += min(m, mid / i);
}
if (res < k)
l = mid + 1;
else
r = mid;
}
cout << r;
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
New Year is getting near. So it's time to change handles on codeforces. Mishka wants to change his handle but in such a way that people would not forget who he is.
To make it work, he only allowed to change letters case. More formally, during one handle change he can choose any segment of his handle [i; i + l - 1] and apply tolower or toupper to all letters of his handle on this segment (more fomally, replace all uppercase letters with corresponding lowercase or vice versa). The length l is fixed for all changes.
Because it is not allowed to change codeforces handle too often, Mishka can perform at most k such operations. What is the minimum value of min(lower, upper) (where lower is the number of lowercase letters, and upper is the number of uppercase letters) can be obtained after optimal sequence of changes?
Input
The first line of the input contains three integers n, k and l (1 β€ n, k, l β€ 10^6, l β€ n) β the length of Mishka's handle, the number of changes and the length of the segment.
The second line of the input contains one string s, consisting of n lowercase and uppercase Latin letters β Mishka's handle.
Output
Print one integer β the minimum value of min(lower, upper) after that Mishka change his handle at most k times in a way described in the problem statement.
Examples
Input
7 1 4
PikMike
Output
0
Input
15 2 2
AaAaAAaaAAAAaaA
Output
2
Input
14 2 6
aBcdEFGHIJklMn
Output
0
Input
9 2 2
aAaAAAaaA
Output
1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, k, len;
string s;
pair<long long, long long> f(long long lam, bool upper) {
vector<long long> dp(n);
vector<long long> cut(n);
for (long long i = 0; i < n; i++) {
cut[i] = (i == 0 ? 0 : cut[i - 1]);
if (upper)
dp[i] = (i == 0 ? 0 : dp[i - 1]) + (s[i] >= 'A' && s[i] <= 'Z');
else
dp[i] = (i == 0 ? 0 : dp[i - 1]) + (s[i] >= 'a' && s[i] <= 'z');
if ((i - len < 0 ? 0 : dp[i - len]) + lam < dp[i]) {
dp[i] = (i - len < 0 ? 0 : dp[i - len]) + lam;
cut[i] = 1 + (i - len < 0 ? 0 : cut[i - len]);
}
}
return {dp[n - 1] - k * lam, cut[n - 1]};
}
long long bs(bool upper) {
long long l = 0, r = 1e6 + 5;
while (l < r) {
long long m = (r + l) / 2;
if (f(m, upper).second > k) {
l = m + 1;
} else {
r = m;
}
}
return max(0ll, f(r, upper).first);
}
int32_t main() {
cin >> n >> k >> len >> s;
cout << min(bs(false), bs(true));
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Konrad is a Human Relations consultant working for VoltModder, a large electrical equipment producer. Today, he has been tasked with evaluating the level of happiness in the company.
There are n people working for VoltModder, numbered from 1 to n. Each employee earns a different amount of money in the company β initially, the i-th person earns i rubles per day.
On each of q following days, the salaries will be revised. At the end of the i-th day, employee v_i will start earning n+i rubles per day and will become the best-paid person in the company. The employee will keep his new salary until it gets revised again.
Some pairs of people don't like each other. This creates a great psychological danger in the company. Formally, if two people a and b dislike each other and a earns more money than b, employee a will brag about this to b. A dangerous triple is a triple of three employees a, b and c, such that a brags to b, who in turn brags to c. If a dislikes b, then b dislikes a.
At the beginning of each day, Konrad needs to evaluate the number of dangerous triples in the company. Can you help him do it?
Input
The first line contains two integers n and m (1 β€ n β€ 100 000, 0 β€ m β€ 100 000) β the number of employees in the company and the number of pairs of people who don't like each other. Each of the following m lines contains two integers a_i, b_i (1 β€ a_i, b_i β€ n, a_i β b_i) denoting that employees a_i and b_i hate each other (that is, a_i dislikes b_i and b_i dislikes a_i). Each such relationship will be mentioned exactly once.
The next line contains an integer q (0 β€ q β€ 100 000) β the number of salary revisions. The i-th of the following q lines contains a single integer v_i (1 β€ v_i β€ n) denoting that at the end of the i-th day, employee v_i will earn the most.
Output
Output q + 1 integers. The i-th of them should contain the number of dangerous triples in the company at the beginning of the i-th day.
Examples
Input
4 5
1 2
2 4
1 3
3 4
2 3
2
2
3
Output
4
3
2
Input
3 3
1 2
2 3
1 3
5
1
2
2
1
3
Output
1
1
1
1
1
1
Note
Consider the first sample test. The i-th row in the following image shows the structure of the company at the beginning of the i-th day. A directed edge from a to b denotes that employee a brags to employee b. The dangerous triples are marked by highlighted edges.
<image>
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
typedef int ll;
const ll MAX = 1e5 + 20;
const ll mod = 1e9 + 7;
const ll inf = 1e9;
ll n, m, q, in[MAX], out[MAX];
vector<ll> adj[MAX];
int main() {
cin >> n >> m;
ll u, v;
for (ll i = 0; i < (ll)m; i++) {
cin >> u >> v;
if (u > v) swap(u, v);
adj[u].push_back(v);
in[u]++, out[v]++;
}
long long cur = 0;
for (ll i = 1; i < (ll)n + 1; i++) cur += 1LL * in[i] * out[i];
cout << cur << endl;
cin >> q;
while (q--) {
cin >> u;
cur -= 1LL * in[u] * out[u];
for (ll v : adj[u]) {
cur -= 1LL * in[v] * out[v];
out[u]++, in[u]--;
in[v]++, out[v]--;
cur += 1LL * in[v] * out[v];
adj[v].push_back(u);
}
adj[u].clear();
cout << cur << endl;
}
return 0;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
You are given an array of n integer numbers. Let sum(l, r) be the sum of all numbers on positions from l to r non-inclusive (l-th element is counted, r-th element is not counted). For indices l and r holds 0 β€ l β€ r β€ n. Indices in array are numbered from 0.
For example, if a = [ - 5, 3, 9, 4], then sum(0, 1) = - 5, sum(0, 2) = - 2, sum(1, 4) = 16 and sum(i, i) = 0 for each i from 0 to 4.
Choose the indices of three delimiters delim0, delim1, delim2 (0 β€ delim0 β€ delim1 β€ delim2 β€ n) and divide the array in such a way that the value of res = sum(0, delim0) - sum(delim0, delim1) + sum(delim1, delim2) - sum(delim2, n) is maximal.
Note that some of the expressions sum(l, r) can correspond to empty segments (if l = r for some segment).
Input
The first line contains one integer number n (1 β€ n β€ 5000).
The second line contains n numbers a0, a1, ..., an - 1 ( - 109 β€ ai β€ 109).
Output
Choose three indices so that the value of res is maximal. If there are multiple answers, print any of them.
Examples
Input
3
-1 2 3
Output
0 1 3
Input
4
0 0 -1 0
Output
0 0 0
Input
1
10000
Output
1 1 1
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
long long dp[5005][5], p[5005][5];
long long a[5005], sum[5005];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
}
for (int i = 1; i <= n; ++i) {
dp[i][1] = sum[i];
p[i][1] = 0;
}
for (int z = 2; z <= 4; ++z) {
for (int i = 1; i <= n; ++i) {
dp[i][z] = z % 2 == 0 ? 9e18 : -9e18;
for (int j = 0; j <= i; ++j) {
long long cur = sum[i] - sum[j] - dp[j][z - 1];
if (z % 2 == 0 && cur < dp[i][z] || z % 2 != 0 && cur > dp[i][z]) {
dp[i][z] = cur;
p[i][z] = j;
}
}
}
}
int cur = n, curz = 4;
vector<int> ans;
while (curz > 1) {
ans.push_back(p[cur][curz]);
cur = p[cur][curz--];
}
cout << ans[2] << " " << ans[1] << " " << ans[0] << endl;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
There are n children in Jzzhu's school. Jzzhu is going to give some candies to them. Let's number all the children from 1 to n. The i-th child wants to get at least ai candies.
Jzzhu asks children to line up. Initially, the i-th child stands at the i-th place of the line. Then Jzzhu start distribution of the candies. He follows the algorithm:
1. Give m candies to the first child of the line.
2. If this child still haven't got enough candies, then the child goes to the end of the line, else the child go home.
3. Repeat the first two steps while the line is not empty.
Consider all the children in the order they go home. Jzzhu wants to know, which child will be the last in this order?
Input
The first line contains two integers n, m (1 β€ n β€ 100; 1 β€ m β€ 100). The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 100).
Output
Output a single integer, representing the number of the last child.
Examples
Input
5 2
1 3 1 4 2
Output
4
Input
6 4
1 1 2 2 3 3
Output
6
Note
Let's consider the first sample.
Firstly child 1 gets 2 candies and go home. Then child 2 gets 2 candies and go to the end of the line. Currently the line looks like [3, 4, 5, 2] (indices of the children in order of the line). Then child 3 gets 2 candies and go home, and then child 4 gets 2 candies and goes to the end of the line. Currently the line looks like [5, 2, 4]. Then child 5 gets 2 candies and goes home. Then child 2 gets two candies and goes home, and finally child 4 gets 2 candies and goes home.
Child 4 is the last one who goes home.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long int mxsize = 1e5 + 15;
const long long int linf = 1e16;
const long long int mod = 1e9 + 7;
long long int pow(long long int x, long long int n) {
if (n == 0) return 1ll;
long long int temp;
temp = pow(x, n / 2);
if (n % 2 == 0)
return temp * temp;
else
return x * temp * temp;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int sum_digit(int val) {
if (val < 0) return -1;
if (val == 0) return 0;
int ans = 0;
while (val > 0) {
ans = ans + val % 10;
val = val / 10;
}
return ans;
}
long long int count_div(long long int l, long long int r, long long int val) {
if (l % val == 0)
return (((r / val) - (l / val)) + 1);
else
return ((r / val) - (l / val));
}
int powmod(int x, int y, int m) {
int res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % m;
cout << res << endl;
y = y / 2;
cout << x << endl;
x = (x * x) % m;
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
queue<int> q;
int ans = -1;
for (int i = 0; i < n; i++) q.push(i + 1);
while (!q.empty()) {
int curr = q.front();
q.pop();
arr[curr - 1] = arr[curr - 1] - m;
ans = curr;
if (arr[curr - 1] > 0) q.push(curr);
}
cout << ans << endl;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
Pikachu had an array with him. He wrote down all the non-empty subsequences of the array on paper. Note that an array of size n has 2n - 1 non-empty subsequences in it.
Pikachu being mischievous as he always is, removed all the subsequences in which Maximum_element_of_the_subsequence - Minimum_element_of_subsequence β₯ d
Pikachu was finally left with X subsequences.
However, he lost the initial array he had, and now is in serious trouble. He still remembers the numbers X and d. He now wants you to construct any such array which will satisfy the above conditions. All the numbers in the final array should be positive integers less than 1018.
Note the number of elements in the output array should not be more than 104. If no answer is possible, print - 1.
Input
The only line of input consists of two space separated integers X and d (1 β€ X, d β€ 109).
Output
Output should consist of two lines.
First line should contain a single integer n (1 β€ n β€ 10 000)β the number of integers in the final array.
Second line should consist of n space separated integers β a1, a2, ... , an (1 β€ ai < 1018).
If there is no answer, print a single integer -1. If there are multiple answers, print any of them.
Examples
Input
10 5
Output
6
5 50 7 15 6 100
Input
4 2
Output
4
10 100 1000 10000
Note
In the output of the first example case, the remaining subsequences after removing those with Maximum_element_of_the_subsequence - Minimum_element_of_subsequence β₯ 5 are [5], [5, 7], [5, 6], [5, 7, 6], [50], [7], [7, 6], [15], [6], [100]. There are 10 of them. Hence, the array [5, 50, 7, 15, 6, 100] is valid.
Similarly, in the output of the second example case, the remaining sub-sequences after removing those with Maximum_element_of_the_subsequence - Minimum_element_of_subsequence β₯ 2 are [10], [100], [1000], [10000]. There are 4 of them. Hence, the array [10, 100, 1000, 10000] is valid.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long md = 1e9 + 7;
const long long MX = 2e5 + 5;
const long long INF = 1e18;
const long double PI = 4 * atan((long double)1);
long long power_md(long long a, long long n) {
long long res = 1;
while (n) {
if (n % 2) res = (res % md * a % md) % md;
a = (a % md * a % md) % md;
n /= 2;
}
res %= md;
return res;
}
long long power(long long a, long long n) {
long long res = 1;
while (n) {
if (n % 2) res *= a;
a = a * a;
n /= 2;
}
return res;
}
long long abst(long long a) { return ((a < 0) ? (-1 * a) : (a)); }
class cmp_set {
public:
bool operator()(long long a, long long b) { return a > b; }
};
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
long long x, d;
cin >> x >> d;
long long p = 1;
vector<long long> res;
for (long long i = 60; i >= 1; i--) {
if (x & ((long long)1 << i)) {
for (long long j = 0; j < i; j++) {
res.push_back(p);
}
p += (d + 1);
res.push_back(p);
p += (d + 1);
}
}
if (x % 2) {
res.push_back(p);
}
cout << res.size() << "\n";
for (long long i = 0; i < res.size(); i++) cout << res[i] << " ";
cout << "\n";
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
You've got an undirected graph, consisting of n vertices and m edges. We will consider the graph's vertices numbered with integers from 1 to n. Each vertex of the graph has a color. The color of the i-th vertex is an integer ci.
Let's consider all vertices of the graph, that are painted some color k. Let's denote a set of such as V(k). Let's denote the value of the neighbouring color diversity for color k as the cardinality of the set Q(k) = {cu : cu β k and there is vertex v belonging to set V(k) such that nodes v and u are connected by an edge of the graph}.
Your task is to find such color k, which makes the cardinality of set Q(k) maximum. In other words, you want to find the color that has the most diverse neighbours. Please note, that you want to find such color k, that the graph has at least one vertex with such color.
Input
The first line contains two space-separated integers n, m (1 β€ n, m β€ 105) β the number of vertices end edges of the graph, correspondingly. The second line contains a sequence of integers c1, c2, ..., cn (1 β€ ci β€ 105) β the colors of the graph vertices. The numbers on the line are separated by spaces.
Next m lines contain the description of the edges: the i-th line contains two space-separated integers ai, bi (1 β€ ai, bi β€ n; ai β bi) β the numbers of the vertices, connected by the i-th edge.
It is guaranteed that the given graph has no self-loops or multiple edges.
Output
Print the number of the color which has the set of neighbours with the maximum cardinality. It there are multiple optimal colors, print the color with the minimum number. Please note, that you want to find such color, that the graph has at least one vertex with such color.
Examples
Input
6 6
1 1 2 3 5 8
1 2
3 2
1 4
4 3
4 5
4 6
Output
3
Input
5 6
4 2 5 2 4
1 2
2 3
3 1
5 3
5 4
3 4
Output
2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100005];
set<int> fuck;
map<int, int> color;
vector<int> g[100005];
int n, m, ans, mx;
void solve(int x) {
set<int> s;
int sum = 0;
for (auto i : v[x]) {
sum += g[i].size();
for (auto j : g[i]) {
if (x != color[j]) {
s.insert(color[j]);
}
}
}
if (s.size() > mx) {
ans = x;
mx = s.size();
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
int t;
cin >> t;
fuck.insert(t);
v[t].push_back(i);
color[i] = t;
}
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
g[a].push_back(b);
g[b].push_back(a);
}
ans = *fuck.begin();
for (auto i : fuck) {
solve(i);
}
cout << ans;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
Bessie the cow and her best friend Elsie each received a sliding puzzle on Pi Day. Their puzzles consist of a 2 Γ 2 grid and three tiles labeled 'A', 'B', and 'C'. The three tiles sit on top of the grid, leaving one grid cell empty. To make a move, Bessie or Elsie can slide a tile adjacent to the empty cell into the empty cell as shown below:
<image>
In order to determine if they are truly Best Friends For Life (BFFLs), Bessie and Elsie would like to know if there exists a sequence of moves that takes their puzzles to the same configuration (moves can be performed in both puzzles). Two puzzles are considered to be in the same configuration if each tile is on top of the same grid cell in both puzzles. Since the tiles are labeled with letters, rotations and reflections are not allowed.
Input
The first two lines of the input consist of a 2 Γ 2 grid describing the initial configuration of Bessie's puzzle. The next two lines contain a 2 Γ 2 grid describing the initial configuration of Elsie's puzzle. The positions of the tiles are labeled 'A', 'B', and 'C', while the empty cell is labeled 'X'. It's guaranteed that both puzzles contain exactly one tile with each letter and exactly one empty position.
Output
Output "YES"(without quotes) if the puzzles can reach the same configuration (and Bessie and Elsie are truly BFFLs). Otherwise, print "NO" (without quotes).
Examples
Input
AB
XC
XB
AC
Output
YES
Input
AB
XC
AC
BX
Output
NO
Note
The solution to the first sample is described by the image. All Bessie needs to do is slide her 'A' tile down.
In the second sample, the two puzzles can never be in the same configuration. Perhaps Bessie and Elsie are not meant to be friends after all...
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T& input(T& v) {
for (int i = 0; i < v.size(); i++) cin >> v[i];
return v;
}
template <typename T>
T& input_2d(T& v) {
int N = v.size();
for (int i = 0; i < N; i++) {
for (int j = 0; j < v[i].size(); j++) cin >> v[i][j];
}
}
template <typename T>
T& input_pair(T& v) {
for (int i = 0; i < v.size(); i++) cin >> v[i].first >> v[i].second;
return v;
}
template <typename T>
void print(const T& v) {
int N = v.size();
for (int i = 0; i < N; i++) cout << v[i] << " ";
cout << '\n';
}
template <typename T>
void print_2d(T& v) {
int N = v.size();
for (int i = 0; i < N; i++) {
for (int j = 0; j < v[i].size(); j++) cout << v[i][j] << " ";
cout << '\n';
}
}
template <typename T>
void print_pair(const T& v) {
int N = v.size();
for (int i = 0; i < N; i++) cout << v[i].first << " " << v[i].second << '\n';
}
template <typename T>
inline int digits(const T& N) {
return (N > 0 ? (int)((log10(N)) + 1) : 1);
}
inline bool ispoweroftwo(int x) { return (x && (!(x & (x - 1)))); }
bool if_integer(double x) {
if (x - floor(x) == 0 && x > 0)
return true;
else
return false;
}
int binomial(int n, int k) {
vector<int> C(k + 1, 0);
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = min(i, k); j > 0; j--) C[j] = C[j] + C[j - 1];
}
return C[k];
}
inline double distance(int a, int b, int c, int d) {
return sqrt(((long long)(a - c)) * (a - c) + ((long long)(b - d)) * (b - d));
}
class compare {
bool operator()(pair<int, int>& p1, pair<int, int>& p2) {
if (p1.first == p2.first) return p1.second > p2.second;
return p1.first > p2.first;
}
};
bool sortbysec(const pair<int, int>& a, const pair<int, int>& b) {
if (a.first == b.first) return (a.second < b.second);
return (a.first > b.first);
}
bool mysort(const vector<int>& a, const vector<int>& b) {
return (a.size() < b.size());
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
vector<string> s(4);
input(s);
vector<int> v(4), v2(4);
int m = 0, k1, k2;
for (int i = 0; i < 2; i++) {
int j = 0, k;
if (i == 0) {
j = 0;
k = 1;
} else {
j = 1;
k = -1;
}
for (; j >= 0 && j < 2; j = j + k) {
if (s[i][j] == 'X') v[m] = 0;
if (s[i][j] == 'A') {
v[m] = 1;
k1 = m;
}
if (s[i][j] == 'B') v[m] = 2;
if (s[i][j] == 'C') v[m] = 3;
m++;
}
}
m = 0;
for (int i = 2; i < 4; i++) {
int j = 0, k;
if (i == 2) {
j = 0;
k = 1;
} else {
j = 1;
k = -1;
}
for (; j >= 0 && j < 2; j = j + k) {
if (s[i][j] == 'X') v2[m] = 0;
if (s[i][j] == 'A') {
v2[m] = 1;
k2 = m;
}
if (s[i][j] == 'B') v2[m] = 2;
if (s[i][j] == 'C') v2[m] = 3;
m++;
}
}
int k = 0;
for (int i = 0; i < 3; i++) {
if (v[k1] == 0) k1++;
if (v2[k2] == 0) k2++;
if (k1 > 3) k1 = 0;
if (k2 > 3) k2 = 0;
if (v[k1] == v2[k2]) k++;
k1++;
k2++;
if (k1 > 3) k1 = 0;
if (k2 > 3) k2 = 0;
}
if (k == 3) {
cout << "YES";
} else {
cout << "NO";
}
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
<image>
Arrange integers (0 or more and 99 or less) in a rhombus as illustrated in Fig. 1. Create a program that reads the data representing the rhombus and outputs the maximum value of the sum of the integers that pass when starting from the top and proceeding to the bottom according to the following rules.
* At each step, you can proceed to the lower left diagonal or the lower right diagonal.
For example, in the example of Fig. 1, as shown in Fig. 2, when 7,3,8,7,5,7,8,3,7 is selected and passed, the sum is the maximum 55 (7 + 3 + 8). + 7 + 5 + 7 + 8 + 3 + 7 = 55).
Input
As shown in the input example, a comma-separated sequence of integers is given to the diamond. Each line does not contain whitespace. The input example corresponds to Fig. 1. There are less than 100 rows of data.
Output
Outputs the maximum value of the sum of integers that pass according to the rules on one line.
Example
Input
7
3,8
8,1,0
2,7,4,4
4,5,2,6,5
2,7,4,4
8,1,0
3,8
7
Output
55
### Response
```cpp
#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
int s[111][111];
int main(void){
int a,k;
for(k = 0; cin >> a; k++){
s[k][0] = a;
for(int i = 1; getchar()==','; i++){
cin >> s[k][i];
}
}
int n=2,p=1;
//cout << s[0][0] << endl;
for(int i = 1; i < k; i++){
for(int j = 0; j < n; j++){
a = 0;
if(k/2 >= i && j > 0) a = max(a,s[i-1][j-1]);
if(k/2 < i && j+1 < p) a = max(a,s[i-1][j+1]);
if(j < p) a = max(a,s[i-1][j]);
s[i][j] += a;
//cout << s[i][j] << ",";
}
//cout << endl;
p = n;
n += (k/2>i)?1:-1;
}
cout << s[k-1][0] << endl;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
I see a pink boar and I want it painted black. Black boars look much more awesome and mighty than the pink ones. Since Jaggy became the ruler of the forest, he has been trying his best to improve the diplomatic relations between the forest region and the nearby ones.
Some other rulers, however, have requested too much in return for peace between their two regions, so he realized he has to resort to intimidation. Once a delegate for diplomatic relations of a neighboring region visits Jaggyβs forest, if they see a whole bunch of black boars, they might suddenly change their mind about attacking Jaggy. Black boars are really scary, after all.
Jaggyβs forest can be represented as a tree (connected graph without cycles) with n vertices. Each vertex represents a boar and is colored either black or pink. Jaggy has sent a squirrel to travel through the forest and paint all the boars black. The squirrel, however, is quite unusually trained and while it traverses the graph, it changes the color of every vertex it visits, regardless of its initial color: pink vertices become black and black vertices become pink.
Since Jaggy is too busy to plan the squirrelβs route, he needs your help. He wants you to construct a walk through the tree starting from vertex 1 such that in the end all vertices are black. A walk is a sequence of vertices, such that every consecutive pair has an edge between them in a tree.
Input
The first line of input contains integer n (2 β€ n β€ 200 000), denoting the number of vertices in the tree. The following n lines contains n integers, which represent the color of the nodes.
If the i-th integer is 1, if the i-th vertex is black and - 1 if the i-th vertex is pink.
Each of the next n - 1 lines contains two integers, which represent the indexes of the vertices which are connected by the edge. Vertices are numbered starting with 1.
Output
Output path of a squirrel: output a sequence of visited nodes' indexes in order of visiting. In case of all the nodes are initially black, you should print 1. Solution is guaranteed to exist. If there are multiple solutions to the problem you can output any of them provided length of sequence is not longer than 107.
Example
Input
5
1
1
-1
1
-1
2 5
4 3
2 4
4 1
Output
1 4 2 5 2 4 3 4 1 4 1
Note
At the beginning squirrel is at node 1 and its color is black. Next steps are as follows:
* From node 1 we walk to node 4 and change its color to pink.
* From node 4 we walk to node 2 and change its color to pink.
* From node 2 we walk to node 5 and change its color to black.
* From node 5 we return to node 2 and change its color to black.
* From node 2 we walk to node 4 and change its color to black.
* We visit node 3 and change its color to black.
* We visit node 4 and change its color to pink.
* We visit node 1 and change its color to pink.
* We visit node 4 and change its color to black.
* We visit node 1 and change its color to black.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int vis[200005], c[200005], fa[200005];
vector<int> g[200005];
vector<int> ans;
int flag;
void init(int u) {
vis[u] = 1;
for (int v : g[u]) {
if (vis[v]) continue;
fa[v] = u;
init(v);
}
}
void f(int u) {
ans.push_back(u);
c[u] = -c[u];
if (g[u].size() == 1 && u != 1) return;
for (int v : g[u]) {
if (fa[u] == v) continue;
f(v);
if (c[v] == -1) {
ans.push_back(u);
ans.push_back(v);
ans.push_back(u);
c[v] = 1;
} else {
ans.push_back(u);
c[u] = -c[u];
}
}
}
void work(int u) {
ans.push_back(u);
for (int v : g[u]) {
f(v);
if (c[v] == -1) {
ans.push_back(u);
ans.push_back(v);
ans.push_back(u);
c[v] = 1;
} else {
ans.push_back(u);
c[u] = -c[u];
}
}
if (c[u] == -1) flag = 1;
}
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> c[i];
for (int i = 1; i <= n - 1; ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
init(1);
work(1);
if (flag) {
ans.push_back(g[1][0]);
ans.push_back(1);
ans.push_back(g[1][0]);
c[1] = -c[1];
}
for (int i : ans) cout << i << " ";
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
On a random day, Neko found n treasure chests and m keys. The i-th chest has an integer a_i written on it and the j-th key has an integer b_j on it. Neko knows those chests contain the powerful mysterious green Grapes, thus Neko wants to open as many treasure chests as possible.
The j-th key can be used to unlock the i-th chest if and only if the sum of the key number and the chest number is an odd number. Formally, a_i + b_j β‘ 1 \pmod{2}. One key can be used to open at most one chest, and one chest can be opened at most once.
Find the maximum number of chests Neko can open.
Input
The first line contains integers n and m (1 β€ n, m β€ 10^5) β the number of chests and the number of keys.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the numbers written on the treasure chests.
The third line contains m integers b_1, b_2, β¦, b_m (1 β€ b_i β€ 10^9) β the numbers written on the keys.
Output
Print the maximum number of chests you can open.
Examples
Input
5 4
9 14 6 2 11
8 4 7 20
Output
3
Input
5 1
2 4 6 8 10
5
Output
1
Input
1 4
10
20 30 40 50
Output
0
Note
In the first example, one possible way to unlock 3 chests is as follows:
* Use first key to unlock the fifth chest,
* Use third key to unlock the second chest,
* Use fourth key to unlock the first chest.
In the second example, you can use the only key to unlock any single chest (note that one key can't be used twice).
In the third example, no key can unlock the given chest.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, oc = 0, ec = 0, ok = 0, ek = 0, i, a, b;
cin >> n >> m;
int a1[n], a2[m];
for (i = 0; i < n; i++) {
cin >> a1[i];
if (a1[i] % 2 == 0)
ec++;
else
oc++;
}
for (i = 0; i < m; i++) {
cin >> a2[i];
if (a2[i] % 2 == 0)
ek++;
else
ok++;
}
if ((oc == 0 && ok == 0) || (ec == 0 && ek == 0))
cout << 0;
else {
if (oc > ek)
a = ek;
else
a = oc;
if (ok > ec)
b = ec;
else
b = ok;
cout << a + b;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
You are given a correct solution of the sudoku puzzle. If you don't know what is the sudoku, you can read about it [here](http://tiny.cc/636xmz).
The picture showing the correct sudoku solution:
<image>
Blocks are bordered with bold black color.
Your task is to change at most 9 elements of this field (i.e. choose some 1 β€ i, j β€ 9 and change the number at the position (i, j) to any other number in range [1; 9]) to make it anti-sudoku. The anti-sudoku is the 9 Γ 9 field, in which:
* Any number in this field is in range [1; 9];
* each row contains at least two equal elements;
* each column contains at least two equal elements;
* each 3 Γ 3 block (you can read what is the block in the link above) contains at least two equal elements.
It is guaranteed that the answer exists.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 10^4) β the number of test cases. Then t test cases follow.
Each test case consists of 9 lines, each line consists of 9 characters from 1 to 9 without any whitespaces β the correct solution of the sudoku puzzle.
Output
For each test case, print the answer β the initial field with at most 9 changed elements so that the obtained field is anti-sudoku. If there are several solutions, you can print any. It is guaranteed that the answer exists.
Example
Input
1
154873296
386592714
729641835
863725149
975314628
412968357
631457982
598236471
247189563
Output
154873396
336592714
729645835
863725145
979314628
412958357
631457992
998236471
247789563
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
for (int i = 0; i < 9; i++) {
string a;
cin >> a;
for (int i = 0; i < 9; i++) {
if (a[i] == '5') {
a[i] = '6';
}
}
cout << a << "\n";
}
}
cerr << "\nTime elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << "s.\n";
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
Happy PMP is freshman and he is learning about algorithmic problems. He enjoys playing algorithmic games a lot.
One of the seniors gave Happy PMP a nice game. He is given two permutations of numbers 1 through n and is asked to convert the first one to the second. In one move he can remove the last number from the permutation of numbers and inserts it back in an arbitrary position. He can either insert last number between any two consecutive numbers, or he can place it at the beginning of the permutation.
Happy PMP has an algorithm that solves the problem. But it is not fast enough. He wants to know the minimum number of moves to convert the first permutation to the second.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the quantity of the numbers in the both given permutations.
Next line contains n space-separated integers β the first permutation. Each number between 1 to n will appear in the permutation exactly once.
Next line describe the second permutation in the same format.
Output
Print a single integer denoting the minimum number of moves required to convert the first permutation to the second.
Examples
Input
3
3 2 1
1 2 3
Output
2
Input
5
1 2 3 4 5
1 5 2 3 4
Output
1
Input
5
1 5 2 3 4
1 2 3 4 5
Output
3
Note
In the first sample, he removes number 1 from end of the list and places it at the beginning. After that he takes number 2 and places it between 1 and 3.
In the second sample, he removes number 5 and inserts it after 1.
In the third sample, the sequence of changes are like this:
* 1 5 2 3 4
* 1 4 5 2 3
* 1 3 4 5 2
* 1 2 3 4 5
So he needs three moves.
### Response
```cpp
#include <bits/stdc++.h>
int a[1000000], b[1000000], c[1000000];
int main() {
int n, i, j, x;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i]--;
}
for (i = 0; i < n; i++) {
scanf("%d", &x);
b[x - 1] = i;
}
for (i = 0; i < n; i++) {
a[i] = b[a[i]];
}
for (i = 1; i < n; i++) {
if (a[i] < a[i - 1]) break;
}
printf("%d\n", n - i);
return 0;
}
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
Alice received a set of Toy Trainβ’ from Bob. It consists of one train and a connected railway network of n stations, enumerated from 1 through n. The train occupies one station at a time and travels around the network of stations in a circular manner. More precisely, the immediate station that the train will visit after station i is station i+1 if 1 β€ i < n or station 1 if i = n. It takes the train 1 second to travel to its next station as described.
Bob gave Alice a fun task before he left: to deliver m candies that are initially at some stations to their independent destinations using the train. The candies are enumerated from 1 through m. Candy i (1 β€ i β€ m), now at station a_i, should be delivered to station b_i (a_i β b_i).
<image> The blue numbers on the candies correspond to b_i values. The image corresponds to the 1-st example.
The train has infinite capacity, and it is possible to load off any number of candies at a station. However, only at most one candy can be loaded from a station onto the train before it leaves the station. You can choose any candy at this station. The time it takes to move the candies is negligible.
Now, Alice wonders how much time is needed for the train to deliver all candies. Your task is to find, for each station, the minimum time the train would need to deliver all the candies were it to start from there.
Input
The first line contains two space-separated integers n and m (2 β€ n β€ 5 000; 1 β€ m β€ 20 000) β the number of stations and the number of candies, respectively.
The i-th of the following m lines contains two space-separated integers a_i and b_i (1 β€ a_i, b_i β€ n; a_i β b_i) β the station that initially contains candy i and the destination station of the candy, respectively.
Output
In the first and only line, print n space-separated integers, the i-th of which is the minimum time, in seconds, the train would need to deliver all the candies were it to start from station i.
Examples
Input
5 7
2 4
5 1
2 3
3 4
4 1
5 3
3 5
Output
10 9 10 10 9
Input
2 3
1 2
1 2
1 2
Output
5 6
Note
Consider the second sample.
If the train started at station 1, the optimal strategy is as follows.
1. Load the first candy onto the train.
2. Proceed to station 2. This step takes 1 second.
3. Deliver the first candy.
4. Proceed to station 1. This step takes 1 second.
5. Load the second candy onto the train.
6. Proceed to station 2. This step takes 1 second.
7. Deliver the second candy.
8. Proceed to station 1. This step takes 1 second.
9. Load the third candy onto the train.
10. Proceed to station 2. This step takes 1 second.
11. Deliver the third candy.
Hence, the train needs 5 seconds to complete the tasks.
If the train were to start at station 2, however, it would need to move to station 1 before it could load the first candy, which would take one additional second. Thus, the answer in this scenario is 5+1 = 6 seconds.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[20005], b[20005];
vector<int> c[5005];
int lens[5005];
multiset<int> s;
int ans[5005];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a[i] >> b[i];
if (b[i] < a[i]) b[i] += n;
c[a[i]].push_back(b[i]);
}
for (int i = 1; i <= n; i++) {
if (c[i].size() == 0)
lens[i] = 0;
else {
sort(c[i].begin(), c[i].end());
lens[i] = c[i][0] + (c[i].size() - 1) * n;
}
s.insert(lens[i]);
}
for (int i = 1; i <= n; i++) {
ans[i] = *(--s.end()) - i;
if (lens[i] != 0) s.erase(s.find(lens[i])), s.insert(lens[i] + n);
}
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
Long time ago Alex created an interesting problem about parallelogram. The input data for this problem contained four integer points on the Cartesian plane, that defined the set of vertices of some non-degenerate (positive area) parallelogram. Points not necessary were given in the order of clockwise or counterclockwise traversal.
Alex had very nice test for this problem, but is somehow happened that the last line of the input was lost and now he has only three out of four points of the original parallelogram. He remembers that test was so good that he asks you to restore it given only these three points.
Input
The input consists of three lines, each containing a pair of integer coordinates xi and yi ( - 1000 β€ xi, yi β€ 1000). It's guaranteed that these three points do not lie on the same line and no two of them coincide.
Output
First print integer k β the number of ways to add one new integer point such that the obtained set defines some parallelogram of positive area. There is no requirement for the points to be arranged in any special order (like traversal), they just define the set of vertices.
Then print k lines, each containing a pair of integer β possible coordinates of the fourth point.
Example
Input
0 0
1 0
0 1
Output
3
1 -1
-1 1
1 1
Note
If you need clarification of what parallelogram is, please check Wikipedia page:
https://en.wikipedia.org/wiki/Parallelogram
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<long long int> a;
int main() {
#pragma warning(disable : 4996)
int x1, y1, x2, y2, x3, y3;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
cout << 3 << endl;
cout << x1 + x2 - x3 << " " << y1 + y2 - y3 << endl;
cout << x1 + x3 - x2 << " " << y1 + y3 - y2 << endl;
cout << x3 + x2 - x1 << " " << y3 + y2 - y1;
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
One day Vasya went out for a walk in the yard but there weren't any of his friends outside and he had no one to play touch and run. But the boy didn't lose the high spirits and decided to play touch and run with himself. You may ask: "How did he do that?" The answer is simple.
Vasya noticed that the yard is a rectangular n Γ m field. The squares have coordinates (x, y) (1 β€ x β€ n, 1 β€ y β€ m), where x is the index of the row and y is the index of the column.
Initially Vasya stands in the square with coordinates (xc, yc). To play, he has got a list of k vectors (dxi, dyi) of non-zero length. The game goes like this. The boy considers all vectors in the order from 1 to k, and consecutively chooses each vector as the current one. After the boy has chosen a current vector, he makes the maximally possible number of valid steps in the vector's direction (it is possible that he makes zero steps).
A step is defined as one movement from the square where the boy is standing now, in the direction of the current vector. That is, if Vasya is positioned in square (x, y), and the current vector is (dx, dy), one step moves Vasya to square (x + dx, y + dy). A step is considered valid, if the boy does not go out of the yard if he performs the step.
Vasya stepped on and on, on and on until he ran out of vectors in his list. Ha had been stepping for so long that he completely forgot how many steps he had made. Help the boy and count how many steps he had made.
Input
The first input line contains two integers n and m (1 β€ n, m β€ 109) β the yard's sizes. The second line contains integers xc and yc β the initial square's coordinates (1 β€ xc β€ n, 1 β€ yc β€ m).
The third line contains an integer k (1 β€ k β€ 104) β the number of vectors. Then follow k lines, each of them contains two integers dxi and dyi (|dxi|, |dyi| β€ 109, |dx| + |dy| β₯ 1).
Output
Print the single number β the number of steps Vasya had made.
Please do not use the %lld specificator to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specificator.
Examples
Input
4 5
1 1
3
1 1
1 1
0 -2
Output
4
Input
10 10
1 2
1
-1 0
Output
0
Note
In the first sample Vasya is initially positioned at square (1, 1) and makes 3 steps by the first vector (1, 1). So, he consecutively visits the squares (2, 2), (3, 3), (4, 4). Then he makes 0 steps by the second vector (1, 1). He makes 1 more step by the third vector (0, - 2) and he ends up in square (4, 2). Overall, Vasya makes 4 steps.
In the second sample Vasya is initially positioned in square (1, 2) and makes 0 steps by vector ( - 1, 0), as the square with coordinates (0, 2) is located outside the yard.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
T power(T N, T P) {
return (P == 0) ? 1 : N * power(N, P - 1);
}
template <class T>
bool inside(T a, T b, T c) {
return (b >= a && b <= c);
}
const long long INF64 = (long long)1E16;
int distsq2d(int x1, int y1, int x2, int y2) {
return sqr(x1 - x2) + sqr(y1 - y2);
}
double dist2d(double x1, double y1, double x2, double y2) {
return sqrt(sqr(x1 - x2) + sqr(y1 - y2));
}
double dist3d(double x1, double y1, double z1, double x2, double y2,
double z2) {
return sqrt(sqr(x1 - x2) + sqr(y1 - y2) + sqr(z1 - z2));
}
long long toInt64(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
double LOG(long long N, long long B) { return (log10l(N)) / (log10l(B)); }
string itoa(long long a) {
if (a == 0) return "0";
string ret;
for (long long i = a; i > 0; i = i / 10) ret.push_back((i % 10) + 48);
reverse(ret.begin(), ret.end());
return ret;
}
vector<string> token(string a, string b) {
const char *q = a.c_str();
while (count(b.begin(), b.end(), *q)) q++;
vector<string> oot;
while (*q) {
const char *e = q;
while (*e && !count(b.begin(), b.end(), *e)) e++;
oot.push_back(string(q, e));
q = e;
while (count(b.begin(), b.end(), *q)) q++;
}
return oot;
}
int isvowel(char s) {
s = tolower(s);
if (s == 'a' || s == 'e' || s == 'i' || s == 'o' || s == 'u') return 1;
return 0;
}
int isupper(char s) {
if (s >= 'A' and s <= 'Z') return 1;
return 0;
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int reset(int N, int pos) { return N = N & ~(1 << pos); }
int check(int N, int pos) { return (N & (1 << pos)); }
int toggle(int N, int pos) {
if (check(N, pos)) return N = reset(N, pos);
return N = Set(N, pos);
}
void pbit(int N) {
printf("(");
for (int i = 10; i >= 0; i--) {
bool x = check(N, i);
cout << x;
}
puts(")");
}
int fx[] = {0, 1, 0, -1};
int fy[] = {1, 0, -1, 0};
int v[10003][4];
long long abs2(long long n) {
if (n < 0) n *= -1;
return n;
}
int main() {
long long r, c;
long long x, y;
long long k;
cin >> r >> c >> x >> y >> k;
long long ans = 0;
for (int i = 1; i <= k; i++) {
long long vx, vy, dx, dy, st;
if (vx == 0 and vy == 0) continue;
cin >> vx >> vy;
if (vx < 0)
dx = 1;
else
dx = r;
if (vy < 0)
dy = 1;
else
dy = c;
if (vx == 0)
st = abs2(dy - y) / abs2(vy);
else if (vy == 0)
st = abs2(dx - x) / abs2(vx);
else
st = min(abs2(dx - x) / abs2(vx), abs2(dy - y) / abs2(vy));
st = abs2(st);
x += st * vx;
y += st * vy;
ans += st;
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Create a solution in cpp for the following problem:
Hands that shed innocent blood!
There are n guilty people in a line, the i-th of them holds a claw with length Li. The bell rings and every person kills some of people in front of him. All people kill others at the same time. Namely, the i-th person kills the j-th person if and only if j < i and j β₯ i - Li.
You are given lengths of the claws. You need to find the total number of alive people after the bell rings.
Input
The first line contains one integer n (1 β€ n β€ 106) β the number of guilty people.
Second line contains n space-separated integers L1, L2, ..., Ln (0 β€ Li β€ 109), where Li is the length of the i-th person's claw.
Output
Print one integer β the total number of alive people after the bell rings.
Examples
Input
4
0 1 0 10
Output
1
Input
2
0 0
Output
2
Input
10
1 1 3 0 0 0 2 1 0 3
Output
3
Note
In first sample the last person kills everyone in front of him.
### Response
```cpp
#include <bits/stdc++.h>
const int N = 1e6 + 1;
const long long inf = (long long)1e18 + 1;
using namespace std;
long long n;
int a[N];
long long s[N], l, r;
long long ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
reverse(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
if (a[i] > 0) {
l = i + 1;
r = i + a[i];
}
r = min(n, r);
if (l <= r) {
s[l]++;
s[r + 1]--;
}
}
for (int i = 1; i <= n; i++) {
s[i] += s[i - 1];
if (s[i] == 0) {
ans++;
}
}
cout << ans;
exit(0);
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 β€ x β€ y β€ 109; 0 β€ p β€ q β€ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t β€ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long x, y, p, q;
cin >> x >> y >> p >> q;
if (p == q) {
if (x == y)
cout << "0\n";
else
cout << "-1\n";
continue;
}
long long l = 1ll, r = 1000000000ll, m;
while (l != r) {
m = (l + r) / 2ll;
if (((q * m - y) >= (p * m - x)) && ((q * m) >= y) && ((p * m) >= x))
r = m;
else
l = m + 1;
}
if (!(((q * r - y) >= (p * r - x)) && ((q * r) >= y) && ((p * r) >= x))) {
cout << -1 << '\n';
continue;
}
cout << q * r - y << '\n';
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
You are planning to build housing on a street. There are n spots available on the street on which you can build a house. The spots are labeled from 1 to n from left to right. In each spot, you can build a house with an integer height between 0 and h.
In each spot, if a house has height a, you will gain a^2 dollars from it.
The city has m zoning restrictions. The i-th restriction says that the tallest house from spots l_i to r_i (inclusive) must be at most x_i.
You would like to build houses to maximize your profit. Determine the maximum profit possible.
Input
The first line contains three integers n, h, and m (1 β€ n,h,m β€ 50) β the number of spots, the maximum height, and the number of restrictions.
Each of the next m lines contains three integers l_i, r_i, and x_i (1 β€ l_i β€ r_i β€ n, 0 β€ x_i β€ h) β left and right limits (inclusive) of the i-th restriction and the maximum possible height in that range.
Output
Print a single integer, the maximum profit you can make.
Examples
Input
3 3 3
1 1 1
2 2 3
3 3 2
Output
14
Input
4 10 2
2 3 8
3 4 7
Output
262
Note
In the first example, there are 3 houses, the maximum height of a house is 3, and there are 3 restrictions. The first restriction says the tallest house between 1 and 1 must be at most 1. The second restriction says the tallest house between 2 and 2 must be at most 3. The third restriction says the tallest house between 3 and 3 must be at most 2.
In this case, it is optimal to build houses with heights [1, 3, 2]. This fits within all the restrictions. The total profit in this case is 1^2 + 3^2 + 2^2 = 14.
In the second example, there are 4 houses, the maximum height of a house is 10, and there are 2 restrictions. The first restriction says the tallest house from 2 to 3 must be at most 8. The second restriction says the tallest house from 3 to 4 must be at most 7.
In this case, it's optimal to build houses with heights [10, 8, 7, 7]. We get a profit of 10^2+8^2+7^2+7^2 = 262. Note that there are two restrictions on house 3 and both of them must be satisfied. Also, note that even though there isn't any explicit restrictions on house 1, we must still limit its height to be at most 10 (h=10).
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const long double E = 1e-8;
mt19937_64 rnd(time(0));
long long p1 = 31, p2 = 29, p3 = 7, p4 = rnd() % 100 + 1, md1 = MOD,
md2 = 998244353, md3 = 998244357, md4 = rnd() % 1000000000;
long long n, m, k, h, T, x[300001], c[300001], dp[51][51][51], pen[55];
pair<long long, long long> a[300001];
long long tt[300001];
long long binpow(long long h, long long r, long long md = MOD) {
long long l = 1;
while (r) {
if (r & 1) l *= h, l %= md;
h *= h;
h %= md;
r /= 2;
}
return l;
}
long long gcd(long long x, long long y) {
if (x < y) swap(x, y);
while (x && y) {
x %= y;
swap(x, y);
}
return x + y;
}
struct dsu {
long long d[200001];
void make_set(int h) { d[h] = h; }
long long find_set(int h) {
if (h == d[h])
return h;
else
return d[h] = find_set(d[h]);
}
void unite_sets(int x, int y) {
x = find_set(x);
y = find_set(y);
if (x < y) swap(x, y);
d[x] = y;
}
};
int main() {
cin >> n >> h >> m;
for (int i = 1; i <= m; i++) {
cin >> a[i].first >> a[i].second >> x[i] >> c[i];
}
for (int q = 1; q <= n; q++)
for (int i = 1; i <= n - q + 1; i++) {
long long j = i + q - 1;
for (int mid = i; mid <= j; mid++) {
for (int ht = 0; ht <= h; ht++) pen[ht] = 0;
for (int u = 1; u <= m; u++)
if (a[u].first >= i && a[u].first <= mid && a[u].second >= mid &&
a[u].second <= j)
pen[x[u] + 1] += c[u];
long long mxl = 0, mxr = 0;
for (int ht = 0; ht <= h; ht++) {
mxl = max(mxl, dp[i][mid - 1][ht]);
mxr = max(mxr, dp[mid + 1][j][ht]);
dp[i][j][ht] = max(mxr + mxl + ht * ht - pen[ht], dp[i][j][ht]);
pen[ht + 1] += pen[ht];
}
}
}
long long ans = 0;
for (int i = 0; i <= h; i++) ans = max(ans, dp[1][n][i]);
cout << ans << "\n";
return 0;
}
``` |
### Prompt
Construct a CPP code solution to the problem outlined:
Emuskald considers himself a master of flow algorithms. Now he has completed his most ingenious program yet β it calculates the maximum flow in an undirected graph. The graph consists of n vertices and m edges. Vertices are numbered from 1 to n. Vertices 1 and n being the source and the sink respectively.
However, his max-flow algorithm seems to have a little flaw β it only finds the flow volume for each edge, but not its direction. Help him find for each edge the direction of the flow through this edges. Note, that the resulting flow should be correct maximum flow.
More formally. You are given an undirected graph. For each it's undirected edge (ai, bi) you are given the flow volume ci. You should direct all edges in such way that the following conditions hold:
1. for each vertex v (1 < v < n), sum of ci of incoming edges is equal to the sum of ci of outcoming edges;
2. vertex with number 1 has no incoming edges;
3. the obtained directed graph does not have cycles.
Input
The first line of input contains two space-separated integers n and m (2 β€ n β€ 2Β·105, n - 1 β€ m β€ 2Β·105), the number of vertices and edges in the graph. The following m lines contain three space-separated integers ai, bi and ci (1 β€ ai, bi β€ n, ai β bi, 1 β€ ci β€ 104), which means that there is an undirected edge from ai to bi with flow volume ci.
It is guaranteed that there are no two edges connecting the same vertices; the given graph is connected; a solution always exists.
Output
Output m lines, each containing one integer di, which should be 0 if the direction of the i-th edge is ai β bi (the flow goes from vertex ai to vertex bi) and should be 1 otherwise. The edges are numbered from 1 to m in the order they are given in the input.
If there are several solutions you can print any of them.
Examples
Input
3 3
3 2 10
1 2 10
3 1 5
Output
1
0
1
Input
4 5
1 2 10
1 3 10
2 3 5
4 2 15
3 4 5
Output
0
0
1
1
0
Note
In the first test case, 10 flow units pass through path <image>, and 5 flow units pass directly from source to sink: <image>.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct edge {
int a, b, c;
edge(int _a = 0, int _b = 0, int _c = 0) : a(_a), b(_b), c(_c) {}
int operator<(const edge &e) const {
if (a == e.a) {
return b < e.b;
}
return a < e.a;
}
};
const int MAXN = 200000;
vector<edge> ve[MAXN + 10];
int S[MAXN + 10], in[MAXN + 10], U[MAXN + 10];
int main(void) {
int n, m;
scanf("%d%d", &n, &m);
vector<edge> E;
set<edge> res;
for (int i = 0; i < (m); ++i) {
edge tmp;
scanf("%d%d%d", &tmp.a, &tmp.b, &tmp.c);
--tmp.a;
--tmp.b;
E.push_back(tmp);
ve[tmp.a].push_back(tmp);
swap(tmp.a, tmp.b);
ve[tmp.a].push_back(tmp);
}
for (int i = 0; i < (n); ++i) {
for (__typeof((ve[i]).begin()) it = (ve[i]).begin(); it != (ve[i]).end();
++it) {
S[i] += it->c;
}
}
queue<int> Q;
Q.push(0);
while (!Q.empty()) {
int v = Q.front();
U[v] = 1;
Q.pop();
for (__typeof((ve[v]).begin()) it = (ve[v]).begin(); it != (ve[v]).end();
++it) {
int w = it->b;
if (U[w]) {
continue;
}
res.insert(*it);
in[w] += it->c;
if (in[w] * 2 == S[w] && w != n - 1) {
Q.push(w);
}
}
}
for (__typeof((E).begin()) it = (E).begin(); it != (E).end(); ++it) {
if (res.find(*it) != res.end()) {
puts("0");
} else {
puts("1");
}
}
return 0;
}
``` |
### Prompt
Construct a cpp code solution to the problem outlined:
Polycarp is playing a new computer game. This game has n stones in a row. The stone on the position i has integer power a_i. The powers of all stones are distinct.
Each turn Polycarp can destroy either stone on the first position or stone on the last position (in other words, either the leftmost or the rightmost stone). When Polycarp destroys the stone it does not exist any more.
Now, Polycarp wants two achievements. He gets them if he destroys the stone with the least power and the stone with the greatest power. Help Polycarp find out what is the minimum number of moves he should make in order to achieve his goal.
For example, if n = 5 and a = [1, 5, 4, 3, 2], then Polycarp could make the following moves:
* Destroy the leftmost stone. After this move a = [5, 4, 3, 2];
* Destroy the rightmost stone. After this move a = [5, 4, 3];
* Destroy the leftmost stone. After this move a = [4, 3]. Polycarp destroyed the stones with the greatest and least power, so he can end the game.
Please note that in the example above, you can complete the game in two steps. For example:
* Destroy the leftmost stone. After this move a = [5, 4, 3, 2];
* Destroy the leftmost stone. After this move a = [4, 3, 2]. Polycarp destroyed the stones with the greatest and least power, so he can end the game.
Input
The first line contains an integer t (1 β€ t β€ 100). Then t test cases follow.
The first line of each test case contains one integer n (2 β€ n β€ 100) β the number of stones.
The second line contains n distinct integers a_1, a_2, β¦, a_n (1 β€ a_i β€ n) β the power of the stones.
Output
For each test case, output the minimum number of moves required to destroy the stones with the greatest and the lowest power.
Example
Input
5
5
1 5 4 3 2
8
2 1 3 4 5 6 8 7
8
4 2 3 1 8 6 7 5
4
3 4 2 1
4
2 3 1 4
Output
2
4
5
3
2
### Response
```cpp
#include<bits/stdc++.h>
#define int long long
using namespace std;
signed main(){
int tt;
cin>>tt;
while(tt--){
int n;
cin>>n;
int arr[n+1];
int l,r;
int minx=INT_MAX,maxn=INT_MIN;
for(int i=1;i<=n;i++){
cin>>arr[i];
if(arr[i]<minx){
l=i;
minx=arr[i];
}
if(arr[i]>maxn){
r=i;
maxn=arr[i];
}
}
int m1=n+1-abs(r-l);
int m2=max(l,r);
int m3=n+1-min(l,r);
cout<<min(m1,min(m2,m3))<<endl;
}
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
You have probably registered on Internet sites many times. And each time you should enter your invented password. Usually the registration form automatically checks the password's crypt resistance. If the user's password isn't complex enough, a message is displayed. Today your task is to implement such an automatic check.
Web-developers of the company Q assume that a password is complex enough, if it meets all of the following conditions:
* the password length is at least 5 characters;
* the password contains at least one large English letter;
* the password contains at least one small English letter;
* the password contains at least one digit.
You are given a password. Please implement the automatic check of its complexity for company Q.
Input
The first line contains a non-empty sequence of characters (at most 100 characters). Each character is either a large English letter, or a small English letter, or a digit, or one of characters: "!", "?", ".", ",", "_".
Output
If the password is complex enough, print message "Correct" (without the quotes), otherwise print message "Too weak" (without the quotes).
Examples
Input
abacaba
Output
Too weak
Input
X12345
Output
Too weak
Input
CONTEST_is_STARTED!!11
Output
Correct
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int check1 = 0, check2 = 0, check3 = 0, check4 = 0, check5 = 0;
if (s.size() >= 5) check1 = 1;
for (int i = 0; i < s.size(); i++) {
if (s[i] >= 65 && s[i] <= 90) check2 = 1;
if (s[i] >= 97 && s[i] <= 122) check3 = 1;
if (s[i] >= 48 && s[i] <= 57) check4 = 1;
}
if (check1 == 1 && check2 == 1 && check3 == 1 && check4 == 1)
cout << "Correct";
else
cout << "Too weak";
}
``` |
### Prompt
Create a solution in cpp for the following problem:
There is a connected undirected graph with N vertices and M edges. The vertices are numbered 1 to N, and the edges are numbered 1 to M. Also, each of these vertices and edges has a specified weight. Vertex i has a weight of X_i; Edge i has a weight of Y_i and connects Vertex A_i and B_i.
We would like to remove zero or more edges so that the following condition is satisfied:
* For each edge that is not removed, the sum of the weights of the vertices in the connected component containing that edge, is greater than or equal to the weight of that edge.
Find the minimum number of edges that need to be removed.
Constraints
* 1 \leq N \leq 10^5
* N-1 \leq M \leq 10^5
* 1 \leq X_i \leq 10^9
* 1 \leq A_i < B_i \leq N
* 1 \leq Y_i \leq 10^9
* (A_i,B_i) \neq (A_j,B_j) (i \neq j)
* The given graph is connected.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
X_1 X_2 ... X_N
A_1 B_1 Y_1
A_2 B_2 Y_2
:
A_M B_M Y_M
Output
Find the minimum number of edges that need to be removed.
Examples
Input
4 4
2 3 5 7
1 2 7
1 3 9
2 3 12
3 4 18
Output
2
Input
6 10
4 4 1 1 1 7
3 5 19
2 5 20
4 5 8
1 6 16
2 3 9
3 6 16
3 4 1
2 6 20
2 4 19
1 2 9
Output
4
Input
10 9
81 16 73 7 2 61 86 38 90 28
6 8 725
3 10 12
1 4 558
4 9 615
5 6 942
8 9 918
2 7 720
4 7 292
7 10 414
Output
8
### Response
```cpp
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 100100;
struct edges
{
int to, next;
long long len;
}edge[maxn << 1];
int point[maxn] = {0}, te = 1;
void add(int a, int b, int c)
{
te ++;
edge[te].to = b;
edge[te].next = point[a];
edge[te].len = c;
point[a] = te;
}
int n, m;
long long v[maxn];
struct E2
{
int a, b;
long long c;
bool operator<(const E2 &a) const
{
return c < a.c;
}
}ea[maxn];
int par[maxn];
long long sum[maxn] = {0};
bool con[maxn] = {0};
int getr(int x)
{
if(x == par[x])
return x;
return par[x] = getr(par[x]);
}
void merge(int ra, int rb)
{
if(ra == rb)
return ;
par[ra] = rb;
sum[rb] += sum[ra];
}
bool flag[maxn] = {0};
void dfs(int now, long long mx)
{
for(int e = point[now]; e; e = edge[e].next)
if(!flag[e / 2] && edge[e].len <= mx)
{
//cout << now << " " << edge[e].to << " " << edge[e].len << endl;
flag[e / 2] = 1;
dfs(edge[e].to, mx);
}
}
int main()
{
std::ios::sync_with_stdio(false);
cin >> n >> m;
for(int i = 1; i <= n; i ++)
cin >> v[i];
for(int i = 1; i <= m; i ++)
cin >> ea[i].a >> ea[i].b >> ea[i].c;
sort(ea + 1, ea + m + 1);
for(int i = 1; i <= n; i ++)
{
par[i] = i;
sum[i] = v[i];
}
for(int i = 1; i <= m; i ++)
{
int ra = getr(ea[i].a), rb = getr(ea[i].b);
merge(ra, rb);
if(ea[i].c <= sum[rb])
{
con[i] = 1;
//cout << i << " " << ea[i].a << " " << ea[i].b << " " << ea[i].c << endl;
}
add(ea[i].a, ea[i].b, ea[i].c);
add(ea[i].b, ea[i].a, ea[i].c);
}
for(int i = m; i >= 1; i --)
if(!flag[i] && con[i])
{
//cout << i << " " << ea[i].a << " " << ea[i].b << " " << ea[i].c << " ------------------------- " << endl;
dfs(ea[i].a, ea[i].c);
}
int ans = 0;
for(int i = 1; i <= m; i ++)
if(!flag[i] && !con[i])
ans ++;
cout << ans << endl;
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
There is an empty array. The following N operations will be performed to insert integers into the array. In the i-th operation (1β€iβ€N), b_i copies of an integer a_i are inserted into the array. Find the K-th smallest integer in the array after the N operations. For example, the 4-th smallest integer in the array \\{1,2,2,3,3,3\\} is 3.
Constraints
* 1β€Nβ€10^5
* 1β€a_i,b_iβ€10^5
* 1β€Kβ€b_1β¦+β¦b_n
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N K
a_1 b_1
:
a_N b_N
Output
Print the K-th smallest integer in the array after the N operations.
Examples
Input
3 4
1 1
2 2
3 3
Output
3
Input
10 500000
1 100000
1 100000
1 100000
1 100000
1 100000
100000 100000
100000 100000
100000 100000
100000 100000
100000 100000
Output
1
### Response
```cpp
#include <iostream>
#include <map>
int main()
{
long long n, k;
std::cin >> n >> k;
std::map<long long, long long> m;
for (int i = 0; i < n; i++) {
long long a, b;
std::cin >> a >> b;
m[a] += b;
}
for (auto it : m) {
k -= it.second;
if (k <= 0) {
std::cout << it.first << std::endl;
break;
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
There is a square field of size n Γ n in which two cells are marked. These cells can be in the same row or column.
You are to mark two more cells so that they are the corners of a rectangle with sides parallel to the coordinate axes.
For example, if n=4 and a rectangular field looks like this (there are asterisks in the marked cells):
$$$ \begin{matrix} . & . & * & . \\\ . & . & . & . \\\ * & . & . & . \\\ . & . & . & . \\\ \end{matrix} $$$
Then you can mark two more cells as follows
$$$ \begin{matrix} * & . & * & . \\\ . & . & . & . \\\ * & . & * & . \\\ . & . & . & . \\\ \end{matrix} $$$
If there are several possible solutions, then print any of them.
Input
The first line contains a single integer t (1 β€ t β€ 400). Then t test cases follow.
The first row of each test case contains a single integer n (2 β€ n β€ 400) β the number of rows and columns in the table.
The following n lines each contain n characters '.' or '*' denoting empty and marked cells, respectively.
It is guaranteed that the sums of n for all test cases do not exceed 400.
It is guaranteed that there are exactly two asterisks on the field. They can be in the same row/column.
It is guaranteed that the solution exists.
Output
For each test case, output n rows of n characters β a field with four asterisks marked corresponding to the statements. If there multiple correct answers, print any of them.
Example
Input
6
4
..*.
....
*...
....
2
*.
.*
2
.*
.*
3
*.*
...
...
5
.....
..*..
.....
.*...
.....
4
....
....
*...
*...
Output
*.*.
....
*.*.
....
**
**
**
**
*.*
*.*
...
.....
.**..
.....
.**..
.....
....
....
**..
**..
### Response
```cpp
#include <iostream>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>
#include <vector>
#include <string>
#include <iomanip>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <climits>
#define Buff std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
#define ll long long
#define inf LONG_LONG_MAX
#define Inf INT_MAX
#define endl "\n"
using namespace std;
const int Maxn = 1e3 + 10;
const ll Mod = 1e9 + 7;
int t, n;
char bd[Maxn][Maxn];
bool firPos1;
int posX1, posX2, posX3, posX4;
int posY1, posY2, posY3, posY4;
int dis;
void work()
{
firPos1 = false;
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
{
cin >> bd[i][j];
if (bd[i][j] == '*')
{
if (firPos1 == false)
{
posX1 = i;
posY1 = j;
firPos1 = true;
}else
{
posX2 = i;
posY2 = j;
}
}
}
if (posX2 == posX1)
{
dis = 1;
if (posX1 - dis >= 1)
{
posX3 = posX1 - dis;
posX4 = posX1 - dis;
posY3 = posY1;
posY4 = posY2;
}else
{
posX3 = posX1 + dis;
posX4 = posX1 + dis;
posY3 = posY1;
posY4 = posY2;
}
}else
if (posY2 == posY1)
{
dis = 1;
if (posY1 - dis >= 1)
{
posY3 = posY1 - dis;
posY4 = posY1 - dis;
posX3 = posX1;
posX4 = posX2;
}else
{
posY3 = posY1 + dis;
posY4 = posY1 + dis;
posX3 = posX1;
posX4 = posX2;
}
}else
{
int minx = min(posX1,posX2);
int maxx = max(posX1,posX2);
int miny = min(posY1,posY2);
int maxy = max(posY1,posY2);
posX1 = minx;
posY1 = miny;
posX2 = minx;
posY2 = maxy;
posX3 = maxx;
posY3 = miny;
posX4 = maxx;
posY4 = maxy;
}
bd[posX1][posY1] = '*';
bd[posX2][posY2] = '*';
bd[posX3][posY3] = '*';
bd[posX4][posY4] = '*';
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= n; j++)
cout << bd[i][j];
cout << endl;
}
}
int main()
{
Buff;
cin >> t;
while (t--)
work();
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
problem
Once upon a time there were settlements and many people lived there. People built buildings of various shapes and sizes. But those buildings have already been lost, only the literature and the pillars found in the ruins. Was a clue to the location of the building.
There is a description of the temple in the literature. The temple was exactly square when viewed from above, and there were pillars at its four corners. It is unknown which direction the temple was facing. Also, on the sides and inside. I don't know if there were any pillars. Archaeologists believed that among the pillars found in the ruins, the one with the largest square area must be the temple.
Since the coordinates of the position of the pillar are given, find the square with the largest area among the four pillars and write a program to output the area. Note that the sides of the square are not always parallel to the coordinate axes. Be careful.
input
The input consists of multiple datasets. Each dataset is given in the following format. The input ends on a line containing one zero.
On the first line, the number n of pillars found in the ruins is written.
In each of the n lines from the 2nd line to the n + 1st line, the x and y coordinates of the column are written separated by blanks.
A pillar never appears more than once.
n is an integer that satisfies 1 β€ n β€ 3000, and the x and y coordinates of the column are integers greater than or equal to 0 and less than or equal to 5000.
Of the scoring data, 30% of the points satisfy 1 β€ n β€ 100, and 60% of the points satisfy 1 β€ n β€ 500.
The number of datasets does not exceed 10.
output
Outputs one integer for each dataset. If there is a square with four columns, it outputs the area of ββthe largest of those squares, and if no such square exists. Output 0.
Examples
Input
10
9 4
4 3
1 1
4 2
2 4
5 8
4 0
5 3
0 5
5 2
10
9 4
4 3
1 1
4 2
2 4
5 8
4 0
5 3
0 5
5 2
0
Output
10
10
Input
None
Output
None
### Response
```cpp
#include <iostream>
#include <cstdio>
#include <vector>
#include <map>
#include <cmath>
#include <algorithm>
using namespace std;
struct P{
int x,y;
P(int x_, int y_){
x = x_; y = y_;
}
P(){}
};
bool exist[5001][5001];
int x[3001], y[3001];
int main(){
int n;
while( cin >> n , n ){
for(int i=0 ; i < 5001 ; i++ ){
for(int j=0 ; j < 5001 ; j++ ){
exist[i][j] = false;
}
}
for(int i=0 ; i < n ; i++ ){
cin >> x[i] >> y[i];
exist[y[i]][x[i]] = true;
}
int ans = 0;
for(int i=0 ; i < n ; i++ ){
for(int j=i+1 ; j < n ; j++ ){
P p1 = P( x[i] , y[i] );
P p2 = P( x[j] , y[j] );
int dx = abs(p1.x - p2.x);
int dy = abs(p1.y - p2.y);
P p3( p2.x - dy , p2.y + dx );
P p4( p1.x - dy , p1.y + dx );
if( p3.x < 0 || p3.x > 5000 || p3.y < 0 || p3.y > 5000 ) continue;
if( p4.x < 0 || p4.x > 5000 || p4.y < 0 || p4.y > 5000 ) continue;
if( exist[p3.y][p3.x] && exist[p4.y][p4.x] ){
ans = max( ans , dx*dx + dy*dy );
}
p3 = P( p1.x + dy , p1.y - dx );
p4 = P( p2.x + dy , p2.y - dx );
if( p3.x < 0 || p3.x > 5000 || p3.y < 0 || p3.y > 5000 ) continue;
if( p4.x < 0 || p4.x > 5000 || p4.y < 0 || p4.y > 5000 ) continue;
if( exist[p3.y][p3.x] && exist[p4.y][p4.x] ){
ans = max( ans , dx*dx + dy*dy );
}
}
}
cout << ans << endl;
}
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
Let's consider a table consisting of n rows and n columns. The cell located at the intersection of i-th row and j-th column contains number i Γ j. The rows and columns are numbered starting from 1.
You are given a positive integer x. Your task is to count the number of cells in a table that contain number x.
Input
The single line contains numbers n and x (1 β€ n β€ 105, 1 β€ x β€ 109) β the size of the table and the number that we are looking for in the table.
Output
Print a single number: the number of times x occurs in the table.
Examples
Input
10 5
Output
2
Input
6 12
Output
4
Input
5 13
Output
0
Note
A table for the second sample test is given below. The occurrences of number 12 are marked bold.
<image>
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long int n, m, i = 0, a, counter = 0;
cin >> n >> m;
for (i = n; i >= 1; --i) {
if (m % i == 0) break;
}
a = m / i;
if (a <= n) {
for (int j = a; j <= i; ++j) {
if (m % j == 0) counter++;
}
}
cout << counter;
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
int n, t = 0;
cin >> n;
if (n == 1) {
cout << "1";
return 0;
}
for (int i = 2; i < n; i++) t += 1 + i * (n - i);
cout << t + n + 1;
return 0;
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
You are given $n$ packages of $w_i$ kg from a belt conveyor in order ($i = 0, 1, ... n-1$). You should load all packages onto $k$ trucks which have the common maximum load $P$. Each truck can load consecutive packages (more than or equals to zero) from the belt conveyor unless the total weights of the packages in the sequence does not exceed the maximum load $P$.
Write a program which reads $n$, $k$ and $w_i$, and reports the minimum value of the maximum load $P$ to load all packages from the belt conveyor.
Constraints
* $1 \leq n \leq 100,000$
* $1 \leq k \leq 100,000$
* $1 \leq w_i \leq 10,000$
Input
In the first line, two integers $n$ and $k$ are given separated by a space character. In the following $n$ lines, $w_i$ are given respectively.
Output
Print the minimum value of $P$ in a line.
Examples
Input
5 3
8
1
7
3
9
Output
10
Input
4 2
1
2
2
6
Output
6
### Response
```cpp
#include <iostream>
using namespace std;
#define MAX 100000
typedef long long ll;
int n,k;
ll T[MAX];
int check(ll p)
{
int i = 0;
for (int j = 0; j < k; ++j)
{
ll s = 0;
while(s+T[i] <= p)
{
s+=T[i];
i++;
if(i==n) return i;
}
}
return i;
}
int slove()
{
ll left = 0;
ll right = 100000 * 10000;
while(left < right)
{
ll mid = left+(right-left)/2;
int v = check(mid);
if(v >= n) right = mid;
else left = mid+1;
}
return right;
}
int main(int argc, char const *argv[])
{
cin>>n>>k;
for (int i = 0; i < n; ++i)
{
cin>>T[i];
}
ll ans = slove();
cout<<ans<<endl;
return 0;
}
``` |
### Prompt
Please create a solution in Cpp to 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
#pragma GCC optimize("O3")
#include<bits/stdc++.h>
#define rc(x) return cout<<x<<endl,0
#define pb push_back
#define in insert
#define er erase
#define fr first
#define sc second
typedef long long ll;
const long long llinf=LLONG_MAX;
const int inf=LONG_MAX;
const int nmax=1e5+5;
const int mod=1e9+7;
using namespace std;
int n,m,i,x,y,viz[nmax];
vector<int>a[nmax],ans;
void dfs(int x)
{
if(!viz[x])ans.pb(x);
viz[x]=1;
for(i=0;i<a[x].size();i++)
if(!viz[a[x][i]])
{
dfs(a[x][i]);
break;
}
}
int main()
{
//freopen("sol.in","r",stdin);
ios_base::sync_with_stdio(false);cin.tie(0);cerr.tie(0);cout.tie(0);
cin>>n>>m;
while(m--)
{
cin>>x>>y;
a[x].pb(y);
a[y].pb(x);
}
dfs(1);
reverse(ans.begin(),ans.end());
dfs(1);
cout<<ans.size()<<endl;
for(i=0;i<ans.size();i++)cout<<ans[i]<<" ";cout<<endl;
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
Petya loves lucky numbers. Everybody knows that positive integers are lucky if their decimal representation doesn't contain digits other than 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Lucky number is super lucky if it's decimal representation contains equal amount of digits 4 and 7. For example, numbers 47, 7744, 474477 are super lucky and 4, 744, 467 are not.
One day Petya came across a positive integer n. Help him to find the least super lucky number which is not less than n.
Input
The only line contains a positive integer n (1 β€ n β€ 10100000). This number doesn't have leading zeroes.
Output
Output the least super lucky number that is more than or equal to n.
Examples
Input
4500
Output
4747
Input
47
Output
47
### Response
```cpp
#include <bits/stdc++.h>
const int maxn = 1e5 + 10;
using namespace std;
char str[maxn], ans[maxn];
int n, a[maxn];
bool dfs(int pos, int cnt4, int cnt7, bool flag) {
if (pos == n) return true;
if (flag) {
for (int i = 1; i <= cnt4; i++) ans[pos++] = '4';
for (int i = 1; i <= cnt7; i++) ans[pos++] = '7';
return true;
}
if (a[pos] <= 4 && cnt4) {
if (dfs(pos + 1, cnt4 - 1, cnt7, a[pos] < 4)) {
ans[pos] = '4';
return true;
}
}
if (a[pos] <= 7 && cnt7) {
if (dfs(pos + 1, cnt4, cnt7 - 1, a[pos] < 7)) {
ans[pos] = '7';
return true;
}
}
return false;
}
int main() {
scanf("%s", str);
n = strlen(str);
for (int i = 0; i < n; i++) a[i] = str[i] - '0';
if (n & 1) {
int temp = (n + 1) / 2;
for (int i = 1; i <= temp; i++) cout << 4;
for (int i = 1; i <= temp; i++) cout << 7;
return 0;
} else if (!dfs(0, n / 2, n / 2, 0)) {
int temp = (n + 2) / 2;
for (int i = 1; i <= temp; i++) cout << 4;
for (int i = 1; i <= temp; i++) cout << 7;
return 0;
}
for (int i = 0; i < n; i++) printf("%c", ans[i]);
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
One day n friends gathered together to play "Mafia". During each round of the game some player must be the supervisor and other n - 1 people take part in the game. For each person we know in how many rounds he wants to be a player, not the supervisor: the i-th person wants to play ai rounds. What is the minimum number of rounds of the "Mafia" game they need to play to let each person play at least as many rounds as they want?
Input
The first line contains integer n (3 β€ n β€ 105). The second line contains n space-separated integers a1, a2, ..., an (1 β€ ai β€ 109) β the i-th number in the list is the number of rounds the i-th person wants to play.
Output
In a single line print a single integer β the minimum number of game rounds the friends need to let the i-th person play at least ai rounds.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
3 2 2
Output
4
Input
4
2 2 2 2
Output
3
Note
You don't need to know the rules of "Mafia" to solve this problem. If you're curious, it's a game Russia got from the Soviet times: http://en.wikipedia.org/wiki/Mafia_(party_game).
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, i, a[120000], sm, b, ans;
int main() {
while (scanf("%I64d", &n) == 1) {
for (i = 0; i < n; i++) scanf("%I64d", &a[i]);
sort(a, a + n);
sm = 0;
for (i = 1; i < n - 1; i++) sm += (a[n - 1] - a[i]);
if (sm >= a[0])
printf("%I64d\n", a[n - 1]);
else {
ans = a[0];
b = a[0] - sm;
ans += b / (n - 1);
if (b % (n - 1) == 0)
ans += a[n - 1] - a[0];
else
ans += (a[n - 1] - a[0]) + 1;
printf("%I64d\n", ans);
}
}
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
You are given an integer array a_1, a_2, β¦, a_n.
The array b is called to be a subsequence of a if it is possible to remove some elements from a to get b.
Array b_1, b_2, β¦, b_k is called to be good if it is not empty and for every i (1 β€ i β€ k) b_i is divisible by i.
Find the number of good subsequences in a modulo 10^9 + 7.
Two subsequences are considered different if index sets of numbers included in them are different. That is, the values βof the elements βdo not matter in the comparison of subsequences. In particular, the array a has exactly 2^n - 1 different subsequences (excluding an empty subsequence).
Input
The first line contains an integer n (1 β€ n β€ 100 000) β the length of the array a.
The next line contains integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^6).
Output
Print exactly one integer β the number of good subsequences taken modulo 10^9 + 7.
Examples
Input
2
1 2
Output
3
Input
5
2 2 1 22 14
Output
13
Note
In the first example, all three non-empty possible subsequences are good: \{1\}, \{1, 2\}, \{2\}
In the second example, the possible good subsequences are: \{2\}, \{2, 2\}, \{2, 22\}, \{2, 14\}, \{2\}, \{2, 22\}, \{2, 14\}, \{1\}, \{1, 22\}, \{1, 14\}, \{22\}, \{22, 14\}, \{14\}.
Note, that some subsequences are listed more than once, since they occur in the original array multiple times.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void SolveA() {
int n, S;
cin >> n >> S;
cout << (S + n - 1) / n;
}
void SolveB() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
size_t n, m;
cin >> n >> m;
vector<long long> v(n);
for (size_t i = 0; i < n; ++i) cin >> v[i];
make_heap(v.begin(), v.end());
sort_heap(v.begin(), v.end());
reverse(v.begin(), v.end());
long long covered = 1;
long long y = v[0] - 1;
for (size_t i = 1; i < n; ++i) {
if (y > v[i]) y = v[i];
if (y > 0) {
++covered;
--y;
}
}
long long sum = 0;
for (size_t i = 0; i < n; ++i) sum += v[i];
long long kept = v[0] + n - covered;
cout << sum - kept;
}
void SolveC() {
const long long MOD = 1000000007;
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
size_t n;
cin >> n;
vector<int_least32_t> a(n);
vector<pair<int_least32_t, int_least32_t> > v;
vector<int> minDiv(1000001, 0);
for (int i = 2; i <= 1000000; ++i)
if (minDiv[i] == 0)
for (int tmp = 2 * i; tmp <= 1000000; tmp += i) minDiv[tmp] = i;
vector<int_least32_t> oldDivs, newDivs;
vector<size_t> nextPos(1000001, 0);
for (size_t i = 0; i < n; ++i) {
int_least32_t x;
cin >> x;
a[i] = x;
oldDivs.clear();
oldDivs.push_back(1);
while (x > 1) {
int_least32_t p = (minDiv[x] == 0) ? x : minDiv[x];
size_t cnt = 0;
while (minDiv[x] == p || x == p) {
++cnt;
x /= p;
}
newDivs.clear();
for (size_t j = 0; j < oldDivs.size(); ++j) {
int_least32_t v = oldDivs[j];
newDivs.push_back(v);
for (size_t k = 0; k < cnt; ++k) {
v *= p;
newDivs.push_back(v);
}
}
oldDivs.swap(newDivs);
}
for (size_t j = 0; j < oldDivs.size(); ++j) ++nextPos[oldDivs[j]];
}
size_t totalCount = 0;
for (size_t i = 1; i <= 1000000; ++i) {
size_t tmp = totalCount + nextPos[i];
nextPos[i] = totalCount;
totalCount = tmp;
}
v.resize(totalCount);
for (size_t i = 0; i < n; ++i) {
int_least32_t x = a[i];
oldDivs.clear();
oldDivs.push_back(1);
while (x > 1) {
int_least32_t p = (minDiv[x] == 0) ? x : minDiv[x];
size_t cnt = 0;
while (minDiv[x] == p || x == p) {
++cnt;
x /= p;
}
newDivs.clear();
for (size_t j = 0; j < oldDivs.size(); ++j) {
int_least32_t v = oldDivs[j];
newDivs.push_back(v);
for (size_t k = 0; k < cnt; ++k) {
v *= p;
newDivs.push_back(v);
}
}
oldDivs.swap(newDivs);
}
for (size_t j = 0; j < oldDivs.size(); ++j)
v[nextPos[oldDivs[j]]++] = make_pair(oldDivs[j], i);
}
long long ans = n;
vector<int_least32_t> prevPos, curPos;
vector<long long> prevVal, curVal;
for (size_t i = 0; i < n; ++i) {
prevPos.push_back(i);
prevVal.push_back(1);
}
size_t iCur = n;
for (int_least32_t div = 2; div <= 1000000; ++div) {
curPos.clear();
curVal.clear();
long long curSum = 0;
size_t iNextPrev = 0;
for (; iCur < v.size() && v[iCur].first == div; ++iCur) {
while (iNextPrev < prevPos.size() &&
prevPos[iNextPrev] < v[iCur].second) {
curSum += prevVal[iNextPrev];
++iNextPrev;
}
curPos.push_back(v[iCur].second);
curVal.push_back(curSum % MOD);
}
for (size_t i = 0; i < curVal.size(); ++i) ans += curVal[i];
ans = ans % MOD;
if (curPos.empty()) break;
curVal.swap(prevVal);
curPos.swap(prevPos);
}
cout << ans;
}
void SolveD() {}
void SolveE() {}
int main() {
SolveC();
return 0;
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
Yet another round on DecoForces is coming! Grandpa Maks wanted to participate in it but someone has stolen his precious sofa! And how can one perform well with such a major loss?
Fortunately, the thief had left a note for Grandpa Maks. This note got Maks to the sofa storehouse. Still he had no idea which sofa belongs to him as they all looked the same!
The storehouse is represented as matrix n Γ m. Every sofa takes two neighbouring by some side cells. No cell is covered by more than one sofa. There can be empty cells.
Sofa A is standing to the left of sofa B if there exist two such cells a and b that xa < xb, a is covered by A and b is covered by B. Sofa A is standing to the top of sofa B if there exist two such cells a and b that ya < yb, a is covered by A and b is covered by B. Right and bottom conditions are declared the same way.
Note that in all conditions A β B. Also some sofa A can be both to the top of another sofa B and to the bottom of it. The same is for left and right conditions.
The note also stated that there are cntl sofas to the left of Grandpa Maks's sofa, cntr β to the right, cntt β to the top and cntb β to the bottom.
Grandpa Maks asks you to help him to identify his sofa. It is guaranteed that there is no more than one sofa of given conditions.
Output the number of Grandpa Maks's sofa. If there is no such sofa that all the conditions are met for it then output -1.
Input
The first line contains one integer number d (1 β€ d β€ 105) β the number of sofas in the storehouse.
The second line contains two integer numbers n, m (1 β€ n, m β€ 105) β the size of the storehouse.
Next d lines contains four integer numbers x1, y1, x2, y2 (1 β€ x1, x2 β€ n, 1 β€ y1, y2 β€ m) β coordinates of the i-th sofa. It is guaranteed that cells (x1, y1) and (x2, y2) have common side, (x1, y1) β (x2, y2) and no cell is covered by more than one sofa.
The last line contains four integer numbers cntl, cntr, cntt, cntb (0 β€ cntl, cntr, cntt, cntb β€ d - 1).
Output
Print the number of the sofa for which all the conditions are met. Sofas are numbered 1 through d as given in input. If there is no such sofa then print -1.
Examples
Input
2
3 2
3 1 3 2
1 2 2 2
1 0 0 1
Output
1
Input
3
10 10
1 2 1 1
5 5 6 5
6 4 5 4
2 1 2 0
Output
2
Input
2
2 2
2 1 1 1
1 2 2 2
1 0 0 0
Output
-1
Note
Let's consider the second example.
* The first sofa has 0 to its left, 2 sofas to its right ((1, 1) is to the left of both (5, 5) and (5, 4)), 0 to its top and 2 to its bottom (both 2nd and 3rd sofas are below).
* The second sofa has cntl = 2, cntr = 1, cntt = 2 and cntb = 0.
* The third sofa has cntl = 2, cntr = 1, cntt = 1 and cntb = 1.
So the second one corresponds to the given conditions.
In the third example
* The first sofa has cntl = 1, cntr = 1, cntt = 0 and cntb = 1.
* The second sofa has cntl = 1, cntr = 1, cntt = 1 and cntb = 0.
And there is no sofa with the set (1, 0, 0, 0) so the answer is -1.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int D, N, M, cnt[4];
int mp[100005][4];
vector<pair<pair<int, int>, pair<int, int> > > pos;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> D >> N >> M;
int x1, y1, x2, y2;
for (int i = 1; i <= D; i++) {
cin >> x1 >> y1 >> x2 >> y2;
pos.push_back(make_pair(make_pair(x1, y1), make_pair(x2, y2)));
mp[min(x1, x2)][0]++;
mp[max(x1, x2)][1]++;
mp[min(y1, y2)][2]++;
mp[max(y1, y2)][3]++;
}
for (int i = 0; i <= 3; i++) cin >> cnt[i];
for (int i = 1; i <= N; i++) mp[i][0] += mp[i - 1][0];
for (int i = N - 1; i >= 0; i--) mp[i][1] += mp[i + 1][1];
for (int i = 1; i <= M; i++) mp[i][2] += mp[i - 1][2];
for (int i = M - 1; i >= 0; i--) mp[i][3] += mp[i + 1][3];
int c[4];
for (int i = 0; i <= D - 1; i++) {
x1 = pos[i].first.first, y1 = pos[i].first.second, x2 = pos[i].second.first,
y2 = pos[i].second.second;
c[0] = mp[max(x1, x2) - 1][0];
c[1] = mp[min(x1, x2) + 1][1];
if (x1 != x2) c[0]--, c[1]--;
c[2] = mp[max(y1, y2) - 1][2];
c[3] = mp[min(y1, y2) + 1][3];
if (y1 != y2) c[2]--, c[3]--;
bool first = false;
for (int j = 0; j <= 3; j++) {
if (c[j] != cnt[j]) first = true;
}
if (first) continue;
cout << i + 1 << '\n';
return 0;
}
cout << -1 << '\n';
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
If the girl doesn't go to Denis, then Denis will go to the girl. Using this rule, the young man left home, bought flowers and went to Nastya.
On the way from Denis's house to the girl's house is a road of n lines. This road can't be always crossed in one green light. Foreseeing this, the good mayor decided to place safety islands in some parts of the road. Each safety island is located after a line, as well as at the beginning and at the end of the road. Pedestrians can relax on them, gain strength and wait for a green light.
Denis came to the edge of the road exactly at the moment when the green light turned on. The boy knows that the traffic light first lights up g seconds green, and then r seconds red, then again g seconds green and so on.
Formally, the road can be represented as a segment [0, n]. Initially, Denis is at point 0. His task is to get to point n in the shortest possible time.
He knows many different integers d_1, d_2, β¦, d_m, where 0 β€ d_i β€ n β are the coordinates of points, in which the safety islands are located. Only at one of these points, the boy can be at a time when the red light is on.
Unfortunately, Denis isn't always able to control himself because of the excitement, so some restrictions are imposed:
* He must always move while the green light is on because it's difficult to stand when so beautiful girl is waiting for you. Denis can change his position by Β± 1 in 1 second. While doing so, he must always stay inside the segment [0, n].
* He can change his direction only on the safety islands (because it is safe). This means that if in the previous second the boy changed his position by +1 and he walked on a safety island, then he can change his position by Β± 1. Otherwise, he can change his position only by +1. Similarly, if in the previous second he changed his position by -1, on a safety island he can change position by Β± 1, and at any other point by -1.
* At the moment when the red light is on, the boy must be on one of the safety islands. He can continue moving in any direction when the green light is on.
Denis has crossed the road as soon as his coordinate becomes equal to n.
This task was not so simple, because it's possible that it is impossible to cross the road. Since Denis has all thoughts about his love, he couldn't solve this problem and asked us to help him. Find the minimal possible time for which he can cross the road according to these rules, or find that it is impossible to do.
Input
The first line contains two integers n and m (1 β€ n β€ 10^6, 2 β€ m β€ min(n + 1, 10^4)) β road width and the number of safety islands.
The second line contains m distinct integers d_1, d_2, β¦, d_m (0 β€ d_i β€ n) β the points where the safety islands are located. It is guaranteed that there are 0 and n among them.
The third line contains two integers g, r (1 β€ g, r β€ 1000) β the time that the green light stays on and the time that the red light stays on.
Output
Output a single integer β the minimum time for which Denis can cross the road with obeying all the rules.
If it is impossible to cross the road output -1.
Examples
Input
15 5
0 3 7 14 15
11 11
Output
45
Input
13 4
0 3 7 13
9 9
Output
-1
Note
In the first test, the optimal route is:
* for the first green light, go to 7 and return to 3. In this case, we will change the direction of movement at the point 7, which is allowed, since there is a safety island at this point. In the end, we will be at the point of 3, where there is also a safety island. The next 11 seconds we have to wait for the red light.
* for the second green light reaches 14. Wait for the red light again.
* for 1 second go to 15. As a result, Denis is at the end of the road.
In total, 45 seconds are obtained.
In the second test, it is impossible to cross the road according to all the rules.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int m;
int g, r;
int bfs(vector<long long> &a) {
vector<vector<int>> dp(10010, vector<int>(2010, -1));
deque<pair<int, int>> q;
q.push_front({0, 0});
dp[0][0] = 0;
int ret = 1e9;
while (!q.empty()) {
auto nw = q.front();
q.pop_front();
int position = nw.first;
int time = nw.second;
if (position == m - 1) {
ret = min(ret, dp[position][time]);
continue;
}
int new_position = position + 1;
int new_time = time + a[new_position] - a[position];
if (new_time == g && dp[new_position][0] == -1) {
q.push_back({new_position, 0});
dp[new_position][0] = dp[position][time] + a[new_position] - a[position] +
r * (new_position != m - 1);
}
if (new_time < g && dp[new_position][new_time] == -1) {
q.push_front({new_position, new_time});
dp[new_position][new_time] =
dp[position][time] + a[new_position] - a[position];
}
new_position = position - 1;
new_time = (position == 0) ? 1e9 : time + a[position] - a[new_position];
if (new_time == g && dp[new_position][0] == -1) {
q.push_back({new_position, 0});
dp[new_position][0] =
dp[position][time] + a[position] - a[new_position] + r;
}
if (new_time < g && dp[new_position][new_time] == -1) {
q.push_front({new_position, new_time});
dp[new_position][new_time] =
dp[position][time] + a[position] - a[new_position];
}
}
if (ret == 1e9) ret = -1;
return ret;
}
int main() {
int n;
cin >> n >> m;
vector<long long> a(m);
for (int i = 0; i < m; i++) {
scanf("%d", &a[i]);
}
sort(a.begin(), a.end());
cin >> g >> r;
printf("%d\n", bfs(a));
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to 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;
const int MAX = 100000;
const int INF = 1000000001;
int H, W, n;
struct coor {
int x1, x2, y1, y2;
coor() {}
coor(int x1, int y1, int x2, int y2) : x1(x1), y1(y1), x2(x2), y2(y2) {}
int area() const { return (x2 - x1) * (y2 - y1); }
};
vector<coor> V, cuts;
void solve() {
for (__typeof((cuts).begin()) cut = (cuts).begin(); cut != (cuts).end();
++cut)
for (__typeof((V).begin()) v = (V).begin(); v != (V).end(); ++v)
if (cut->y1 == cut->y2 && v->x1 == cut->x1 && v->x2 == cut->x2 &&
v->y1 < cut->y1 && cut->y2 < v->y2) {
int i = v - V.begin();
V.push_back(coor(v->x1, cut->y1, v->x2, v->y2));
V[i].y2 = cut->y2;
cuts.erase(cut);
return;
} else if (cut->x1 == cut->x2 && cut->y1 == v->y1 && cut->y2 == v->y2 &&
v->x1 < cut->x1 && cut->x2 < v->x2) {
int i = v - V.begin();
V.push_back(coor(cut->x1, cut->y1, v->x2, v->y2));
V[i].x2 = cut->x2;
cuts.erase(cut);
return;
}
}
int main(int argc, char *argv[]) {
scanf("%d %d %d", &W, &H, &n);
V.push_back(coor(0, 0, W, H));
while (n--) {
int x1, x2, y1, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
cuts.push_back(coor(x1, y1, x2, y2));
}
while (!cuts.empty()) solve();
vector<int> ans;
for (__typeof((V).begin()) it = (V).begin(); it != (V).end(); ++it)
ans.push_back(it->area());
sort((ans).begin(), (ans).end());
for (__typeof((ans).begin()) i = (ans).begin(); i != (ans).end(); ++i)
printf("%d ", *i);
printf("\n");
return 0;
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
Special Agent Smart Beaver works in a secret research department of ABBYY. He's been working there for a long time and is satisfied with his job, as it allows him to eat out in the best restaurants and order the most expensive and exotic wood types there.
The content special agent has got an important task: to get the latest research by British scientists on the English Language. These developments are encoded and stored in a large safe. The Beaver's teeth are strong enough, so the authorities assured that upon arriving at the place the beaver won't have any problems with opening the safe.
And he finishes his aspen sprig and leaves for this important task. Of course, the Beaver arrived at the location without any problems, but alas. He can't open the safe with his strong and big teeth. At this point, the Smart Beaver get a call from the headquarters and learns that opening the safe with the teeth is not necessary, as a reliable source has sent the following information: the safe code consists of digits and has no leading zeroes. There also is a special hint, which can be used to open the safe. The hint is string s with the following structure:
* if si = "?", then the digit that goes i-th in the safe code can be anything (between 0 to 9, inclusively);
* if si is a digit (between 0 to 9, inclusively), then it means that there is digit si on position i in code;
* if the string contains letters from "A" to "J", then all positions with the same letters must contain the same digits and the positions with distinct letters must contain distinct digits.
* The length of the safe code coincides with the length of the hint.
For example, hint "?JGJ9" has such matching safe code variants: "51919", "55959", "12329", "93539" and so on, and has wrong variants such as: "56669", "00111", "03539" and "13666".
After receiving such information, the authorities change the plan and ask the special agents to work quietly and gently and not to try to open the safe by mechanical means, and try to find the password using the given hint.
At a special agent school the Smart Beaver was the fastest in his platoon finding codes for such safes, but now he is not in that shape: the years take their toll ... Help him to determine the number of possible variants of the code to the safe, matching the given hint. After receiving this information, and knowing his own speed of entering codes, the Smart Beaver will be able to determine whether he will have time for tonight's show "Beavers are on the trail" on his favorite TV channel, or he should work for a sleepless night...
Input
The first line contains string s β the hint to the safe code. String s consists of the following characters: ?, 0-9, A-J. It is guaranteed that the first character of string s doesn't equal to character 0.
The input limits for scoring 30 points are (subproblem A1):
* 1 β€ |s| β€ 5.
The input limits for scoring 100 points are (subproblems A1+A2):
* 1 β€ |s| β€ 105.
Here |s| means the length of string s.
Output
Print the number of codes that match the given hint.
Examples
Input
AJ
Output
81
Input
1?AA
Output
100
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
char c;
char zeroalpha = 'Z';
bool alphafirst = false;
int counter = 9;
int qn = 0;
int used[10];
int i = 0;
long long ans = 1;
int total;
double power;
char first;
memset(used, 0, sizeof(used));
cin >> c;
if (c == '?' || isalpha(c)) {
ans = 9;
zeroalpha = c;
}
first = c;
if (cin.peek() == '\n') {
if (c == '?' || isalpha(c)) {
cout << "9" << endl;
return 0;
} else {
cout << "1" << endl;
return 0;
}
}
do {
cin >> c;
if (c == '?') {
qn++;
} else if (isalpha(c) && c != zeroalpha) {
used[(static_cast<int>(c)) - 65] = 1;
}
} while (cin.peek() != '\n');
static_cast<double>(qn);
if (qn != 0) {
total = accumulate(used, used + 10, 0);
if (isalpha(first)) {
counter = 9;
} else {
counter = 10;
}
for (i = 0; i < total; i++) {
ans *= counter;
counter--;
}
ans *= (long long)pow(10.0, qn);
} else {
total = accumulate(used, used + 10, 0);
if (isalpha(first)) {
counter = 9;
} else {
counter = 10;
}
for (i = 0; i < total; i++) {
ans *= counter;
counter--;
}
}
cout << ans << endl;
return 0;
}
``` |
### Prompt
Generate a cpp solution to the following problem:
There is a rectangular grid of size n Γ m. Each cell of the grid is colored black ('0') or white ('1'). The color of the cell (i, j) is c_{i, j}. You are also given a map of directions: for each cell, there is a direction s_{i, j} which is one of the four characters 'U', 'R', 'D' and 'L'.
* If s_{i, j} is 'U' then there is a transition from the cell (i, j) to the cell (i - 1, j);
* if s_{i, j} is 'R' then there is a transition from the cell (i, j) to the cell (i, j + 1);
* if s_{i, j} is 'D' then there is a transition from the cell (i, j) to the cell (i + 1, j);
* if s_{i, j} is 'L' then there is a transition from the cell (i, j) to the cell (i, j - 1).
It is guaranteed that the top row doesn't contain characters 'U', the bottom row doesn't contain characters 'D', the leftmost column doesn't contain characters 'L' and the rightmost column doesn't contain characters 'R'.
You want to place some robots in this field (at most one robot in a cell). The following conditions should be satisfied.
* Firstly, each robot should move every time (i.e. it cannot skip the move). During one move each robot goes to the adjacent cell depending on the current direction.
* Secondly, you have to place robots in such a way that there is no move before which two different robots occupy the same cell (it also means that you cannot place two robots in the same cell). I.e. if the grid is "RL" (one row, two columns, colors does not matter there) then you can place two robots in cells (1, 1) and (1, 2), but if the grid is "RLL" then you cannot place robots in cells (1, 1) and (1, 3) because during the first second both robots will occupy the cell (1, 2).
The robots make an infinite number of moves.
Your task is to place the maximum number of robots to satisfy all the conditions described above and among all such ways, you have to choose one where the number of black cells occupied by robots before all movements is the maximum possible. Note that you can place robots only before all movements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and m (1 < nm β€ 10^6) β the number of rows and the number of columns correspondingly.
The next n lines contain m characters each, where the j-th character of the i-th line is c_{i, j} (c_{i, j} is either '0' if the cell (i, j) is black or '1' if the cell (i, j) is white).
The next n lines also contain m characters each, where the j-th character of the i-th line is s_{i, j} (s_{i, j} is 'U', 'R', 'D' or 'L' and describes the direction of the cell (i, j)).
It is guaranteed that the sum of the sizes of fields does not exceed 10^6 (β nm β€ 10^6).
Output
For each test case, print two integers β the maximum number of robots you can place to satisfy all the conditions described in the problem statement and the maximum number of black cells occupied by robots before all movements if the number of robots placed is maximized. Note that you can place robots only before all movements.
Example
Input
3
1 2
01
RL
3 3
001
101
110
RLL
DLD
ULL
3 3
000
000
000
RRD
RLD
ULL
Output
2 1
4 3
2 2
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
const long long MOD = 1e9 + 7;
const long long INF = 0x3f3f3f3f;
long long read() {
long long x = 0, f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do {
x = x * 10 + ch - 48;
ch = getchar();
} while (ch >= '0' && ch <= '9');
return x * f;
}
int N, M;
bool black[MAXN];
char mp[MAXN];
int val[MAXN];
int nxt[MAXN][30];
char goes[10] = "LURD";
int change[10];
int ans1, ans2;
int id(int i, int j) { return i * M + j; }
void init() {
for (int i = N * M; i >= 0; i--) {
val[i] = 0;
}
change[0] = -1;
change[1] = -M;
change[2] = 1;
change[3] = M;
ans1 = ans2 = 0;
for (int i = N * M - 1; i >= 0; i--) {
for (int j = 0; j < 4; j++) {
if (mp[i] == goes[j]) {
nxt[i][0] = i + change[j];
break;
}
}
}
}
void solve() {
int x, y;
int now;
scanf("%d%d", &N, &M);
getchar();
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
black[id(i, j)] = (getchar() == '0');
}
getchar();
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
mp[id(i, j)] = getchar();
}
getchar();
}
init();
for (int j = 0; j < 20; j++) {
for (int i = N * M - 1; i >= 0; i--) {
nxt[i][j + 1] = nxt[nxt[i][j]][j];
}
}
for (int i = N * M - 1; i >= 0; i--) {
val[nxt[i][20]] |= 2 | black[i];
}
for (int i = N * M - 1; i >= 0; i--) {
ans1 += (bool)val[i];
ans2 += (val[i] & 1);
}
printf("%d %d\n", ans1, ans2);
}
int main() {
int T;
T = 1;
scanf("%d", &T);
while (T--) {
solve();
}
return 0;
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
You have N items that you want to put them into a knapsack. Item i has value vi, weight wi and limitation mi.
You want to find a subset of items to put such that:
* The total value of the items is as large as possible.
* The items have combined weight at most W, that is capacity of the knapsack.
* You can select at most mi items for ith item.
Find the maximum total value of items in the knapsack.
Constraints
* 1 β€ N β€ 100
* 1 β€ vi β€ 1,000
* 1 β€ wi β€ 1,000
* 1 β€ mi β€ 10,000
* 1 β€ W β€ 10,000
Input
N W
v1 w1 m1
v2 w2 m2
:
vN wN mN
The first line consists of the integers N and W. In the following N lines, the value, weight and limitation of the i-th item are given.
Output
Print the maximum total values of the items in a line.
Examples
Input
4 8
4 3 2
2 1 1
1 2 4
3 2 2
Output
12
Input
2 100
1 1 100
2 1 50
Output
150
### Response
```cpp
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
//#define int long long
#define DBG 1
#define dump(o) if(DBG){cerr<<#o<<" "<<o<<endl;}
#define dumpc(o) if(DBG){cerr<<#o; for(auto &e:(o))cerr<<" "<<e;cerr<<endl;}
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define each(it,c) for(auto it=(c).begin();it!=(c).end();it++)
#define all(c) c.begin(),c.end()
const int INF = sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9 + 7);
const double EPS = 1e-10;
signed main() {
int N, W; cin >> N >> W;
vector<int>v, w; v.push_back(0), w.push_back(0);
rep(i, 0, N) {
int a, b, m; cin >> a >> b >> m;
for (int x = 1; x <= m; x++) {
v.push_back(x*a);
w.push_back(x*b);
m -= x;
}
if (m > 0) v.push_back(m*a), w.push_back(m*b);
}
vector<int>dp(W + 1, 0);
rep(i, 1, v.size())rrep(j, w[i], W + 1) {
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
}
cout << dp[W] << endl;
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
There are N towns on a plane. The i-th town is located at the coordinates (x_i,y_i). There may be more than one town at the same coordinates.
You can build a road between two towns at coordinates (a,b) and (c,d) for a cost of min(|a-c|,|b-d|) yen (the currency of Japan). It is not possible to build other types of roads.
Your objective is to build roads so that it will be possible to travel between every pair of towns by traversing roads. At least how much money is necessary to achieve this?
Constraints
* 2 β€ N β€ 10^5
* 0 β€ x_i,y_i β€ 10^9
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print the minimum necessary amount of money in order to build roads so that it will be possible to travel between every pair of towns by traversing roads.
Examples
Input
3
1 5
3 9
7 8
Output
3
Input
6
8 3
4 9
12 19
18 1
13 5
7 6
Output
8
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
template<typename T>vector<T>&operator<<(vector<T>&v,const T t){v.push_back(t);return v;}
template<typename T,typename U>istream&operator>>(istream&s,pair<T,U>&p){return s>>p.first>>p.second;}
template<typename T,typename U>ostream&operator<<(ostream&s,const pair<T,U>p){return s<<p.first<<" "<<p.second;}
#define all(x) x.begin(),x.end()
typedef pair<int,int>pii;
int p[100000];
int uni(int i){
return p[i]!=i?p[i]=uni(p[i]):i;
}
pair<int,pii>dist(pii v,pii u){
return {abs(v.first-u.first),{v.second,u.second}};
}
int N;
vector<pii>xi,yi;
vector<pair<int,pii>>E;
int main(){
cin>>N;
for(int i=0;i<N;++i){
int x,y;
cin>>x>>y;
xi<<(pii){x,i};
yi<<(pii){y,i};
p[i]=i;
}
sort(all(xi));
sort(all(yi));
for(int i=0;i<N-1;++i){
E<<dist(xi[i],xi[i+1])<<dist(yi[i],yi[i+1]);
}
sort(all(E));
long long a=0;
for(auto e:E){
int x=uni(e.second.first);
int y=uni(e.second.second);
if(x!=y){
p[x]=y;
a+=e.first;
}
}
cout<<a;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
This problem consists of two subproblems: for solving subproblem D1 you will receive 3 points, and for solving subproblem D2 you will receive 16 points.
Manao is the chief architect involved in planning a new supercollider. He has to identify a plot of land where the largest possible supercollider can be built. The supercollider he is building requires four-way orthogonal collisions of particles traveling at the same speed, so it will consist of four accelerating chambers and be shaped like a plus sign (i.e., +). Each of the four accelerating chambers must be the same length and must be aligned with the Earth's magnetic field (parallel or orthogonal) to minimize interference.
The accelerating chambers need to be laid down across long flat stretches of land to keep costs under control. Thus, Manao has already commissioned a topographical study that has identified all possible maximal length tracts of land available for building accelerating chambers that are either parallel or orthogonal to the Earth's magnetic field. To build the largest possible supercollider, Manao must identify the largest symmetric plus shape from among these candidate tracts. That is, he must find the two tracts of land that form an axis-aligned plus shape with the largest distance from the center of the plus to the tip of the shortest of the four arms of the plus. Note that the collider need not use the entire length of the tracts identified (see the example in the notes).
Input
The first line of the input will contain two single-space-separated integers n, the number of north-south tracts and m, the number of west-east tracts.
Each of the n lines following the first describes a north-south tract. Each such tract is described by three single-space-separated integers xi, yi, li representing the vertical line segment from (xi, yi) to (xi, yi + li).
Similarly, after the n lines describing north-south tracts follow m similar lines describing the west-east tracts. Each such tract is described by three single-space-separated integers xi, yi, li representing the horizontal line segment from (xi, yi) to (xi + li, yi).
All xi and yi are between -100000000 and 100000000, inclusive. All li are between 1 and 100000000, inclusive. No pair of horizontal segments will touch or intersect, and no pair of vertical segments will touch or intersect.
The problem consists of two subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem D1 (3 points), n and m will be between 1 and 1000, inclusive.
* In subproblem D2 (16 points), n and m will be between 1 and 50000, inclusive.
Output
Print one line containing a single integer, the size of the largest supercollider that can be built on one north-south tract and one west-east tract. The size of the supercollider is defined to be the length of one of the four accelerating chambers. In other words, the size of the resulting supercollider is defined to be the distance from the intersection of the two line segments to the closest endpoint of either of the two segments. If no pair of north-south and west-east tracts intersects, it is not possible to build a supercollider and the program should report a maximum size of zero.
Examples
Input
1 2
4 0 9
1 1 8
1 2 7
Output
2
Note
Consider the example. There is one vertical line segment from (4, 0) to (4, 9) and two horizontal line segments: from (1, 1) to (9, 1) and from (1, 2) to (8, 2). The largest plus shape that can be found among these segments is formed from the only vertical segment and the second of horizontal segments, and is centered at (4, 2).
The program should output 2 because the closest end point of those segments to the center is (4, 0), which is distance 2 from the center point of (4, 2). The collider will be formed by the line segments from (2, 2) to (6, 2) and from (4, 0) to (4, 4).
### Response
```cpp
#include <bits/stdc++.h>
long long a11[1010], b11[1010], b12[1010];
long long a21[1010], b21[1010], b22[1010];
long long min(long long a, long long b) {
if (a < b) {
return a;
}
return b;
}
long long max(long long a, long long b) {
if (a > b) {
return a;
}
return b;
}
int main(void) {
int n, m, i, j;
long long ans, temp;
while (scanf("%d %d", &n, &m) != EOF) {
ans = 0;
for (i = 1; i <= n; i++) {
scanf("%I64d %I64d %I64d", &a11[i], &b11[i], &b12[i]);
b12[i] += b11[i];
}
for (i = 1; i <= m; i++) {
scanf("%I64d %I64d %I64d", &b21[i], &a21[i], &b22[i]);
b22[i] += b21[i];
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
temp = 2000000000;
temp *= 100000;
if (a21[j] >= b11[i] && a21[j] <= b12[i] && a11[i] >= b21[j] &&
a11[i] <= b22[j]) {
temp = min(temp, a21[j] - b11[i]);
temp = min(temp, b12[i] - a21[j]);
temp = min(temp, a11[i] - b21[j]);
temp = min(temp, b22[j] - a11[i]);
ans = max(temp, ans);
}
}
}
printf("%I64d\n", ans);
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
Bajtek is learning to skate on ice. He's a beginner, so his only mode of transportation is pushing off from a snow drift to the north, east, south or west and sliding until he lands in another snow drift. He has noticed that in this way it's impossible to get from some snow drifts to some other by any sequence of moves. He now wants to heap up some additional snow drifts, so that he can get from any snow drift to any other one. He asked you to find the minimal number of snow drifts that need to be created.
We assume that Bajtek can only heap up snow drifts at integer coordinates.
Input
The first line of input contains a single integer n (1 β€ n β€ 100) β the number of snow drifts. Each of the following n lines contains two integers xi and yi (1 β€ xi, yi β€ 1000) β the coordinates of the i-th snow drift.
Note that the north direction coinΡides with the direction of Oy axis, so the east direction coinΡides with the direction of the Ox axis. All snow drift's locations are distinct.
Output
Output the minimal number of snow drifts that need to be created in order for Bajtek to be able to reach any snow drift from any other one.
Examples
Input
2
2 1
1 2
Output
1
Input
2
2 1
4 1
Output
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100010;
pair<int, int> a[MAX_N];
vector<int> adj[MAX_N];
bool visit[MAX_N];
int par[MAX_N];
int Height[MAX_N];
void dfs(int root) {
visit[root] = 1;
for (int i = 0; i < adj[root].size(); i++) {
if (visit[adj[root][i]] == 0) {
par[adj[root][i]] = root;
Height[adj[root][i]] = Height[root] + 1;
dfs(adj[root][i]);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
for (int i = 0; i < n - 1; i++) {
for (int j = 1; j < n; j++) {
if (a[i].first == a[j].first || a[i].second == a[j].second) {
adj[i].push_back(j);
adj[j].push_back(i);
}
}
}
int ans = 0;
while (true) {
bool flag = 0;
for (int i = 0; i < n; i++) {
if (visit[i] == 0) {
dfs(i);
ans++;
flag = 1;
}
}
if (flag == 0) {
break;
}
}
cout << ans - 1;
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
Bankopolis is an incredible city in which all the n crossroads are located on a straight line and numbered from 1 to n along it. On each crossroad there is a bank office.
The crossroads are connected with m oriented bicycle lanes (the i-th lane goes from crossroad ui to crossroad vi), the difficulty of each of the lanes is known.
Oleg the bank client wants to gift happiness and joy to the bank employees. He wants to visit exactly k offices, in each of them he wants to gift presents to the employees.
The problem is that Oleg don't want to see the reaction on his gifts, so he can't use a bicycle lane which passes near the office in which he has already presented his gifts (formally, the i-th lane passes near the office on the x-th crossroad if and only if min(ui, vi) < x < max(ui, vi))). Of course, in each of the offices Oleg can present gifts exactly once. Oleg is going to use exactly k - 1 bicycle lane to move between offices. Oleg can start his path from any office and finish it in any office.
Oleg wants to choose such a path among possible ones that the total difficulty of the lanes he will use is minimum possible. Find this minimum possible total difficulty.
Input
The first line contains two integers n and k (1 β€ n, k β€ 80) β the number of crossroads (and offices) and the number of offices Oleg wants to visit.
The second line contains single integer m (0 β€ m β€ 2000) β the number of bicycle lanes in Bankopolis.
The next m lines contain information about the lanes.
The i-th of these lines contains three integers ui, vi and ci (1 β€ ui, vi β€ n, 1 β€ ci β€ 1000), denoting the crossroads connected by the i-th road and its difficulty.
Output
In the only line print the minimum possible total difficulty of the lanes in a valid path, or -1 if there are no valid paths.
Examples
Input
7 4
4
1 6 2
6 2 2
2 4 2
2 7 1
Output
6
Input
4 3
4
2 1 2
1 3 2
3 4 2
4 1 1
Output
3
Note
In the first example Oleg visiting banks by path 1 β 6 β 2 β 4.
Path 1 β 6 β 2 β 7 with smaller difficulity is incorrect because crossroad 2 β 7 passes near already visited office on the crossroad 6.
In the second example Oleg can visit banks by path 4 β 1 β 3.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void rd(int &x) { scanf("%d", &x); }
void rd(int &x, int &y) { scanf("%d%d", &x, &y); }
void rd(int &x, int &y, int &z) { scanf("%d%d%d", &x, &y, &z); }
void rd(int &x, int &y, int &z, int &s) { scanf("%d%d%d%d", &x, &y, &z, &s); }
struct debugger {
template <class T>
debugger &operator,(const T &v) {
cerr << v << " ";
return *this;
}
} dbg;
void debugv(vector<long long> vec) {
cerr << "printing vector:: ";
for (int i = 0; i < (vec.size()); i++) {
cout << vec[i] << " ";
}
cerr << endl;
}
void debugs(set<long long> s) {
cerr << "printing set:: ";
for (auto it = s.begin(); it != s.end(); it++) {
cout << (*it) << " ";
}
cerr << endl;
}
int n, k, m, dis[81][81];
int dp[81][81][81][81];
int back(long long l, long long r, long long cur, long long p) {
if (p == k) return 0;
int &x = dp[l][r][cur][p];
if (x != -1) return x;
int ret = 1e8 + 5;
for (int i = l; i <= r; i++) {
if (i != cur && dis[cur][i] < 1e8 + 5) {
if (i < cur)
ret = min(ret, back(l, cur - 1, i, p + 1) + dis[cur][i]);
else
ret = min(ret, back(cur + 1, r, i, p + 1) + dis[cur][i]);
}
}
return x = ret;
}
int main() {
rd(n, k, m);
for (int i = 1; i <= (n); i++) {
for (int w = 1; w <= (n); w++) dis[i][w] = 1e8 + 5;
}
for (int i = 1; i <= (m); i++) {
int u, v, c;
rd(u, v, c);
dis[u][v] = min(dis[u][v], c);
}
memset((dp), -1, sizeof((dp)));
int ans = 1e8 + 5;
for (int i = 1; i <= (n); i++) {
ans = min(ans, back(1, n, i, 1));
}
if (ans == 1e8 + 5) ans = -1;
printf("%d", ans);
return 0;
}
``` |
End of preview. Expand
in Dataset Viewer.
10k random lines of the "text" column of the https://huggingface.co/datasets/wttw/code_contest_instruct_cpp dataset
- Downloads last month
- 4
Size of downloaded dataset files:
31.9 MB
Size of the auto-converted Parquet files:
15.1 MB
Number of rows:
10,000
Models trained or fine-tuned on dumb-dev/cpp-10k