input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
Iahub likes trees very much. Recently he discovered an interesting tree named propagating tree. The tree consists of n nodes numbered from 1 to n, each node i having an initial value ai. The root of the tree is node 1.
This tree has a special property: when a value val is added to a value of node i, the value -val is added to values of all the children of node i. Note that when you add value -val to a child of node i, you also add -(-val) to all children of the child of node i and so on. Look an example explanation to understand better how it works.
This tree supports two types of queries:
* "1 x val" — val is added to the value of node x;
* "2 x" — print the current value of node x.
In order to help Iahub understand the tree better, you must answer m queries of the preceding type.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 200000). The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1000). Each of the next n–1 lines contains two integers vi and ui (1 ≤ vi, ui ≤ n), meaning that there is an edge between nodes vi and ui.
Each of the next m lines contains a query in the format described above. It is guaranteed that the following constraints hold for all queries: 1 ≤ x ≤ n, 1 ≤ val ≤ 1000.
Output
For each query of type two (print the value of node x) you must print the answer to the query on a separate line. The queries must be answered in the order given in the input.
Examples
Input
5 5
1 2 1 1 2
1 2
1 3
2 4
2 5
1 2 3
1 1 2
2 1
2 2
2 4
Output
3
3
0
Note
The values of the nodes are [1, 2, 1, 1, 2] at the beginning.
Then value 3 is added to node 2. It propagates and value -3 is added to it's sons, node 4 and node 5. Then it cannot propagate any more. So the values of the nodes are [1, 5, 1, - 2, - 1].
Then value 2 is added to node 1. It propagates and value -2 is added to it's sons, node 2 and node 3. From node 2 it propagates again, adding value 2 to it's sons, node 4 and node 5. Node 3 has no sons, so it cannot propagate from there. The values of the nodes are [3, 3, - 1, 0, 1].
You can see all the definitions about the tree at the following link: http://en.wikipedia.org/wiki/Tree_(graph_theory)
|
#include <bits/stdc++.h>
using namespace std;
const int c = 2e5 + 5;
int strength[c], level[c], size[c], visited[c], tree_even[4 * c],
tree_odd[4 * c], M;
std::vector<int> v[c], preorder;
map<int, int> Map;
int dfs(int vertex, int lev) {
if (visited[vertex]) return 0;
visited[vertex] = 1;
level[vertex] = lev;
size[vertex] = 1;
preorder.push_back(vertex);
Map[vertex] = (int)preorder.size() - 1;
for (int i = 0; i < (int)v[vertex].size(); i++) {
size[vertex] += dfs(v[vertex][i], lev + 1);
}
return size[vertex];
}
void update(int index, int s, int e, int l, int r, int val) {
if (e < l || s > r) return;
if (s >= l && e <= r) {
if (M == 0)
tree_even[index] += val;
else
tree_odd[index] += val;
return;
}
int mid = (s + e) / 2;
update(2 * index, s, mid, l, r, val);
update(2 * index + 1, mid + 1, e, l, r, val);
return;
}
int sum;
int query(int index, int l, int r, int i) {
if (i < l || i > r) return 0;
if (l <= i && i <= r) {
if (M == 0)
sum += tree_even[index] - tree_odd[index];
else
sum += tree_odd[index] - tree_even[index];
}
if (l == r) return 0;
int mid = (l + r) / 2;
query(2 * index, l, mid, i);
query(2 * index + 1, mid + 1, r, i);
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
int n, m, v1, v2, type, node, upd, start;
cin >> n >> m;
for (int i = 1; i < n + 1; i++) cin >> strength[i];
for (int i = 0; i < n - 1; i++) {
cin >> v1 >> v2;
v[v1].push_back(v2);
v[v2].push_back(v1);
}
preorder.push_back(0);
dfs(1, 0);
while (m--) {
cin >> type;
if (type == 1) {
cin >> node >> upd;
start = Map[node];
M = level[node] % 2;
update(1, 1, n, start, start + size[node] - 1, upd);
} else {
cin >> node;
start = Map[node];
M = level[node] % 2;
sum = strength[node];
query(1, 1, n, start);
cout << sum << "\n";
}
}
return 0;
}
|
Little Chris is very keen on his toy blocks. His teacher, however, wants Chris to solve more problems, so he decided to play a trick on Chris.
There are exactly s blocks in Chris's set, each block has a unique number from 1 to s. Chris's teacher picks a subset of blocks X and keeps it to himself. He will give them back only if Chris can pick such a non-empty subset Y from the remaining blocks, that the equality holds:
<image> "Are you kidding me?", asks Chris.
For example, consider a case where s = 8 and Chris's teacher took the blocks with numbers 1, 4 and 5. One way for Chris to choose a set is to pick the blocks with numbers 3 and 6, see figure. Then the required sums would be equal: (1 - 1) + (4 - 1) + (5 - 1) = (8 - 3) + (8 - 6) = 7.
<image>
However, now Chris has exactly s = 106 blocks. Given the set X of blocks his teacher chooses, help Chris to find the required set Y!
Input
The first line of input contains a single integer n (1 ≤ n ≤ 5·105), the number of blocks in the set X. The next line contains n distinct space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 106), the numbers of the blocks in X.
Note: since the size of the input and output could be very large, don't use slow output techniques in your language. For example, do not use input and output streams (cin, cout) in C++.
Output
In the first line of output print a single integer m (1 ≤ m ≤ 106 - n), the number of blocks in the set Y. In the next line output m distinct space-separated integers y1, y2, ..., ym (1 ≤ yi ≤ 106), such that the required equality holds. The sets X and Y should not intersect, i.e. xi ≠ yj for all i, j (1 ≤ i ≤ n; 1 ≤ j ≤ m). It is guaranteed that at least one solution always exists. If there are multiple solutions, output any of them.
Examples
Input
3
1 4 5
Output
2
999993 1000000
Input
1
1
Output
1
1000000
|
#include <bits/stdc++.h>
using namespace std;
bool a[1000000 + 100];
int tot = 0, idx = 0, ans[1000000], n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int p;
scanf("%d", &p);
a[p] = 1;
}
for (int i = 1; i <= 1000000 / 2; i++) {
if (a[i] && !a[1000000 - i + 1]) ans[++tot] = 1000000 - i + 1;
if (!a[i] && a[1000000 - i + 1]) ans[++tot] = i;
if (a[i] && a[1000000 - i + 1]) ++idx;
}
for (int i = 1; i <= 1000000 / 2; i++) {
if (idx <= 0) break;
if (!a[i] && !a[1000000 - i + 1]) {
ans[++tot] = i;
ans[++tot] = 1000000 - i + 1;
idx--;
}
}
printf("%d\n", tot);
for (int i = 1; i <= tot; i++) printf("%d ", ans[i]);
return 0;
}
|
You have an n × m rectangle table, its cells are not initially painted. Your task is to paint all cells of the table. The resulting picture should be a tiling of the table with squares. More formally:
* each cell must be painted some color (the colors are marked by uppercase Latin letters);
* we will assume that two cells of the table are connected if they are of the same color and share a side; each connected region of the table must form a square.
Given n and m, find lexicographically minimum coloring of the table that meets the described properties.
Input
The first line contains two integers, n and m (1 ≤ n, m ≤ 100).
Output
Print lexicographically minimum coloring of the table that meets the described conditions.
One coloring (let's call it X) is considered lexicographically less than the other one (let's call it Y), if:
* consider all the table cells from left to right and from top to bottom (first, the first cell in the first row, then the second cell in the first row and so on);
* let's find in this order the first cell that has distinct colors in two colorings;
* the letter that marks the color of the cell in X, goes alphabetically before the letter that marks the color of the cell in Y.
Examples
Input
1 3
Output
ABA
Input
2 2
Output
AA
AA
Input
3 4
Output
AAAB
AAAC
AAAB
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool MinPlace(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool MaxPlace(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename S, typename T>
ostream &operator<<(ostream &out, const pair<S, T> &p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
out << "[";
for (int i = 0; i < (int)v.size(); i++) {
out << v[i];
if (i != (int)v.size() - 1) out << ", ";
}
out << "]";
return out;
}
char mex(int i, int j, vector<string> &t) {
int n = t.size(), m = t[0].size();
set<char> hood;
vector<pair<int, int> > diff(
{make_pair(-1, 0), make_pair(0, -1), make_pair(1, 0), make_pair(0, 1)});
for (auto pd : diff) {
int ni = i + pd.first, nj = j + pd.second;
if (ni >= 0 and ni < n and nj >= 0 and nj < m) hood.insert(t[ni][nj]);
}
for (char c = 'A'; c < 'F'; c++)
if (!hood.count(c)) return c;
return 'E';
}
bool isClear(int i, int j, vector<string> &t, int c) {
int n = t.size(), m = t[0].size(), ii, jj;
if (i + c >= n || j - c < 0) return false;
for (ii = i + 1; ii <= i + c; ii++)
if (t[ii][j] != ' ') break;
for (jj = j - 1; jj >= j - c; jj--)
if (t[i + c][jj] != ' ') break;
return (ii == i + c + 1 && jj == j - c - 1 &&
(i && j
? (t[i - 1][j] != t[i][j - 1] && t[i - 1][j - 1] != t[i][j - 1])
: true));
}
void fill(int i, int j, vector<string> &t, int rc, char ch) {
for (int ii = i; ii <= i + rc; ii++) t[ii][j] = ch;
for (int jj = j - 1; jj >= j - rc; jj--) t[i + rc][jj] = ch;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int i, j, n, m;
cin >> n >> m;
vector<string> t(n, string(m, ' '));
for (int i = 0; i < n; i++) {
for (int j = 0, c = 0; j < m; j++) {
if (t[i][j] != ' ') continue;
char ch = mex(i, j, t);
if (j && t[i][j - 1] < ch && isClear(i, j, t, c))
ch = t[i][j - 1];
else
c = 0;
fill(i, j, t, c, ch);
c++;
}
}
for (int i = 0; i < n; i++) cout << t[i] << "\n";
}
|
Andrew, Fedor and Alex are inventive guys. Now they invent the game with strings for two players.
Given a group of n non-empty strings. During the game two players build the word together, initially the word is empty. The players move in turns. On his step player must add a single letter in the end of the word, the resulting word must be prefix of at least one string from the group. A player loses if he cannot move.
Andrew and Alex decided to play this game k times. The player who is the loser of the i-th game makes the first move in the (i + 1)-th game. Guys decided that the winner of all games is the player who wins the last (k-th) game. Andrew and Alex already started the game. Fedor wants to know who wins the game if both players will play optimally. Help him.
Input
The first line contains two integers, n and k (1 ≤ n ≤ 105; 1 ≤ k ≤ 109).
Each of the next n lines contains a single non-empty string from the given group. The total length of all strings from the group doesn't exceed 105. Each string of the group consists only of lowercase English letters.
Output
If the player who moves first wins, print "First", otherwise print "Second" (without the quotes).
Examples
Input
2 3
a
b
Output
First
Input
3 1
a
b
c
Output
First
Input
1 2
ab
Output
Second
|
#include <bits/stdc++.h>
using namespace std;
const int inf = int(1e9);
const double pi = 4 * atan(double(1.0));
const double eps = 1e-9;
const int LEN = int(1e5) + 100;
char s[LEN];
bool can_win[LEN], can_loose[LEN];
int _next[LEN][26];
void dfs(int v) {
bool exists = false;
for (int i = 0; i < 26; ++i) {
if (_next[v][i] != -1) {
exists = true;
dfs(_next[v][i]);
}
}
if (!exists) {
can_loose[v] = true;
} else {
for (int i = 0; i < 26; ++i) {
if (_next[v][i] != -1) {
can_loose[v] |= !can_loose[_next[v][i]];
}
}
}
for (int i = 0; i < 26; ++i) {
if (_next[v][i] != -1) {
can_win[v] |= !can_win[_next[v][i]];
}
}
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < 26; ++i) {
_next[0][i] = -1;
}
int ptr = 0;
for (int i = 0; i < n; ++i) {
scanf("%s", s);
int len = strlen(s), cur = 0;
for (int j = 0; j < len; ++j) {
int c = s[j] - 'a';
if (_next[cur][c] == -1) {
_next[cur][c] = ++ptr;
for (int z = 0; z < 26; ++z) {
_next[ptr][z] = -1;
}
}
cur = _next[cur][c];
}
}
dfs(0);
if (k == 1) {
if (can_win[0]) {
puts("First");
} else {
puts("Second");
}
return 0;
}
if (!can_win[0]) {
puts("Second");
return 0;
}
if (can_loose[0] && can_win[0]) {
puts("First");
return 0;
}
if (k % 2 == 0) {
puts("Second");
return 0;
}
puts("First");
return 0;
}
|
Dreamoon has just created a document of hard problems using notepad.exe. The document consists of n lines of text, ai denotes the length of the i-th line. He now wants to know what is the fastest way to move the cursor around because the document is really long.
Let (r, c) be a current cursor position, where r is row number and c is position of cursor in the row. We have 1 ≤ r ≤ n and 0 ≤ c ≤ ar.
We can use following six operations in notepad.exe to move our cursor assuming the current cursor position is at (r, c):
1. up key: the new cursor position (nr, nc) = (max(r - 1, 1), min(anr, c))
2. down key: the new cursor position (nr, nc) = (min(r + 1, n), min(anr, c))
3. left key: the new cursor position (nr, nc) = (r, max(0, c - 1))
4. right key: the new cursor position (nr, nc) = (r, min(anr, c + 1))
5. HOME key: the new cursor position (nr, nc) = (r, 0)
6. END key: the new cursor position (nr, nc) = (r, ar)
You're given the document description (n and sequence ai) and q queries from Dreamoon. Each query asks what minimal number of key presses is needed to move the cursor from (r1, c1) to (r2, c2).
Input
The first line contains an integer n(1 ≤ n ≤ 400, 000) — the number of lines of text.
The second line contains n integers a1, a2, ..., an(1 ≤ ai ≤ 108).
The third line contains an integer q(1 ≤ q ≤ 400, 000).
Each of the next q lines contains four integers r1, c1, r2, c2 representing a query (1 ≤ r1, r2 ≤ n, 0 ≤ c1 ≤ ar1, 0 ≤ c2 ≤ ar2).
Output
For each query print the result of the query.
Examples
Input
9
1 3 5 3 1 3 5 3 1
4
3 5 3 1
3 3 7 3
1 0 3 3
6 0 7 3
Output
2
5
3
2
Input
2
10 5
1
1 0 1 5
Output
3
Note
In the first sample, the first query can be solved with keys: HOME, right.
The second query can be solved with keys: down, down, down, END, down.
The third query can be solved with keys: down, END, down.
The fourth query can be solved with keys: END, down.
|
#include <bits/stdc++.h>
using namespace std;
int Ans[400005], n, m;
int a[400005], b[400005], W[400005], top;
int lc[800005], rc[800005], f[3][800005], rt;
struct O {
int p, q, x, y, i;
} o[400005];
bool cmo(O a, O b) { return a.x < b.x; }
void build(int &u, int p, int q) {
u = ++top;
f[1][u] = f[2][u] = 1000000000;
if (p == q) {
f[0][u] = W[p];
return;
}
build(lc[u], p, (p + q) / 2);
build(rc[u], (p + q) / 2 + 1, q);
f[0][u] = min(f[0][lc[u]], f[0][rc[u]]);
}
void mody(int u, int p, int q, int k) {
if (p == q) {
f[1][u] = b[p] - 2 * a[p];
f[2][u] = -b[p] - 2 * a[p];
return;
}
if (k <= (p + q) / 2)
mody(lc[u], p, (p + q) / 2, k);
else
mody(rc[u], (p + q) / 2 + 1, q, k);
f[1][u] = min(f[1][lc[u]], f[1][rc[u]]);
f[2][u] = min(f[2][lc[u]], f[2][rc[u]]);
}
int qmin(int I, int u, int p, int q, int l, int r) {
if (l <= p && q <= r) return f[I][u];
int tmp = 1000000000;
if (l <= (p + q) / 2) tmp = qmin(I, lc[u], p, (p + q) / 2, l, r);
if (r > (p + q) / 2) tmp = min(tmp, qmin(I, rc[u], (p + q) / 2 + 1, q, l, r));
return tmp;
}
void go(O o, int L, int R) {
if (L > R) return;
int k1 = upper_bound(b + L, b + R + 1, o.q) - b;
int k2 = lower_bound(b + L, b + R + 1, o.y) - b;
if (k1 > k2) swap(k1, k2);
int ans;
if (L <= k1 - 1) {
ans = o.q < b[L];
if (b[L] < o.y)
ans += o.y + o.x + o.p + qmin(2, 1, 1, n, L, k1 - 1);
else
ans += o.x + o.p - o.y + qmin(1, 1, 1, n, L, k1 - 1);
Ans[o.i] = min(Ans[o.i], ans);
}
if (k1 <= k2 - 1) {
ans = o.q < b[k1];
if (b[k1] < o.y)
ans += o.y + o.x + o.p + qmin(2, 1, 1, n, k1, k2 - 1);
else
ans += o.x + o.p - o.y + qmin(1, 1, 1, n, k1, k2 - 1);
Ans[o.i] = min(Ans[o.i], ans);
}
if (k2 <= R) {
ans = o.q < b[k2];
if (b[k2] < o.y)
ans += o.y + o.x + o.p + qmin(2, 1, 1, n, k2, R);
else
ans += o.x + o.p - o.y + qmin(1, 1, 1, n, k2, R);
Ans[o.i] = min(Ans[o.i], ans);
}
}
void solve() {
top = 0;
for (int i = 1, j = 1; i <= n && j <= m; ++i) {
while (top && b[top] >= W[i]) --top;
a[++top] = i;
b[top] = W[i];
mody(1, 1, n, top);
for (; j <= m && o[j].x == i; ++j)
if (o[j].p <= o[j].x) {
int k = lower_bound(a + 1, a + top + 1, o[j].p) - a;
go(o[j], 1, k - 1);
int q = min(o[j].q, b[k]);
int t = lower_bound(b + k, b + top + 1, o[j].y) - b;
if (t <= top)
Ans[o[j].i] = min(Ans[o[j].i], o[j].x - o[j].p + abs(b[t] - o[j].y) +
(int)(q < b[t]));
if (--t >= k)
Ans[o[j].i] = min(Ans[o[j].i], o[j].x - o[j].p + abs(b[t] - o[j].y) +
(int)(q < b[t]));
Ans[o[j].i] = min(Ans[o[j].i], o[j].x - o[j].p + abs(q - o[j].y));
} else {
int tmp = o[j].q;
o[j].q = min(tmp, qmin(0, 1, 1, n, o[j].x, o[j].p));
go(o[j], 1, top);
o[j].q = tmp;
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &W[i]);
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d%d", &o[i].p, &o[i].q, &o[i].x, &o[i].y);
o[i].i = i;
Ans[i] = abs(o[i].x - o[i].p) + 1 + o[i].y;
}
sort(o + 1, o + m + 1, cmo);
top = 0;
build(rt, 1, n);
solve();
for (int i = 1; i <= n / 2; ++i) swap(W[i], W[n - i + 1]);
for (int i = 1; i <= m / 2; ++i) swap(o[i], o[m - i + 1]);
for (int i = 1; i <= m; ++i) o[i].x = n - o[i].x + 1, o[i].p = n - o[i].p + 1;
top = 0;
build(rt, 1, n);
solve();
for (int i = 1; i <= m; ++i) printf("%d\n", Ans[i]);
return 0;
}
|
User ainta has a permutation p1, p2, ..., pn. As the New Year is coming, he wants to make his permutation as pretty as possible.
Permutation a1, a2, ..., an is prettier than permutation b1, b2, ..., bn, if and only if there exists an integer k (1 ≤ k ≤ n) where a1 = b1, a2 = b2, ..., ak - 1 = bk - 1 and ak < bk all holds.
As known, permutation p is so sensitive that it could be only modified by swapping two distinct elements. But swapping two elements is harder than you think. Given an n × n binary matrix A, user ainta can swap the values of pi and pj (1 ≤ i, j ≤ n, i ≠ j) if and only if Ai, j = 1.
Given the permutation p and the matrix A, user ainta wants to know the prettiest permutation that he can obtain.
Input
The first line contains an integer n (1 ≤ n ≤ 300) — the size of the permutation p.
The second line contains n space-separated integers p1, p2, ..., pn — the permutation p that user ainta has. Each integer between 1 and n occurs exactly once in the given permutation.
Next n lines describe the matrix A. The i-th line contains n characters '0' or '1' and describes the i-th row of A. The j-th character of the i-th line Ai, j is the element on the intersection of the i-th row and the j-th column of A. It is guaranteed that, for all integers i, j where 1 ≤ i < j ≤ n, Ai, j = Aj, i holds. Also, for all integers i where 1 ≤ i ≤ n, Ai, i = 0 holds.
Output
In the first and only line, print n space-separated integers, describing the prettiest permutation that can be obtained.
Examples
Input
7
5 2 4 3 6 7 1
0001001
0000000
0000010
1000001
0000000
0010000
1001000
Output
1 2 4 3 6 7 5
Input
5
4 2 1 5 3
00100
00011
10010
01101
01010
Output
1 2 3 4 5
Note
In the first sample, the swap needed to obtain the prettiest permutation is: (p1, p7).
In the second sample, the swaps needed to obtain the prettiest permutation is (p1, p3), (p4, p5), (p3, p4).
<image>
A permutation p is a sequence of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. The i-th element of the permutation p is denoted as pi. The size of the permutation p is denoted as n.
|
par=[0]*310
rank=[0]*310
def init_union_find(V):#initial state
for i in xrange(V):
par[i]=i
rank[i]=0
def find(x):#where the root
if par[x]==x:
return x
else:
par[x]=find(par[x])
return par[x]
def unite(x,y):#x and y unite
x=find(x)
y=find(y)
if x==y:
return
if rank[x]<rank[y]:
par[x]=y
else:
par[y]=x
if(rank[x] == rank[y]): rank[x] += 1
def same(x,y):#x and y same root?
return find(x)==find(y)
init_union_find(310)
edge=[0]*310
node=[0]*310
N=int(raw_input())
p=map(int,raw_input().split())
uv=[]
for i in range(N):
s=str(raw_input())
for j in range(N):
if s[j]=='1':
uv.append([i,j])
for u,v in uv:
unite(u,v)
list=[0]*310
for i in range(len(p)):
for j in range(i+1,len(p)):
if p[i]>p[j] and find(i)==find(j):
p[i],p[j]=p[j],p[i]
print " ".join(map(str,p))
|
Anya loves to fold and stick. Today she decided to do just that.
Anya has n cubes lying in a line and numbered from 1 to n from left to right, with natural numbers written on them. She also has k stickers with exclamation marks. We know that the number of stickers does not exceed the number of cubes.
Anya can stick an exclamation mark on the cube and get the factorial of the number written on the cube. For example, if a cube reads 5, then after the sticking it reads 5!, which equals 120.
You need to help Anya count how many ways there are to choose some of the cubes and stick on some of the chosen cubes at most k exclamation marks so that the sum of the numbers written on the chosen cubes after the sticking becomes equal to S. Anya can stick at most one exclamation mark on each cube. Can you do it?
Two ways are considered the same if they have the same set of chosen cubes and the same set of cubes with exclamation marks.
Input
The first line of the input contains three space-separated integers n, k and S (1 ≤ n ≤ 25, 0 ≤ k ≤ n, 1 ≤ S ≤ 1016) — the number of cubes and the number of stickers that Anya has, and the sum that she needs to get.
The second line contains n positive integers ai (1 ≤ ai ≤ 109) — the numbers, written on the cubes. The cubes in the input are described in the order from left to right, starting from the first one.
Multiple cubes can contain the same numbers.
Output
Output the number of ways to choose some number of cubes and stick exclamation marks on some of them so that the sum of the numbers became equal to the given number S.
Examples
Input
2 2 30
4 3
Output
1
Input
2 2 7
4 3
Output
1
Input
3 1 1
1 1 1
Output
6
Note
In the first sample the only way is to choose both cubes and stick an exclamation mark on each of them.
In the second sample the only way is to choose both cubes but don't stick an exclamation mark on any of them.
In the third sample it is possible to choose any of the cubes in three ways, and also we may choose to stick or not to stick the exclamation mark on it. So, the total number of ways is six.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int Mod = 1e9 + 7;
map<long long, int> Left[26], Right[26];
int n, k, a[30];
long long sum, fact[20];
void cal(int pos, int crk, long long crSum, int last) {
if (pos == last) {
if (last != n)
Left[crk][crSum]++;
else
Right[crk][crSum]++;
return;
}
if (crk < k && a[pos] < 19) cal(pos + 1, crk + 1, crSum + fact[a[pos]], last);
cal(pos + 1, crk, crSum + a[pos], last);
cal(pos + 1, crk, crSum, last);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> k >> sum;
for (int i = 0; i < n; ++i) cin >> a[i];
fact[0] = 1;
for (long long i = 1; i < 20; ++i) fact[i] = i * fact[i - 1];
cal(0, 0, 0, n / 2);
cal(n / 2, 0, 0, n);
long long ans = 0;
for (int i = 0; i <= k; ++i) Left[i][0] = Right[i][0] = 1;
for (int i = 0; i <= k; ++i) {
for (auto j : Left[i]) {
if (j.first == sum) {
ans += j.second;
continue;
}
if (j.first == 0) continue;
for (int x = 0; x + i <= k; ++x) {
if (Right[x].count(sum - j.first))
ans += (j.second * Right[x][sum - j.first]);
}
}
}
for (int i = 0; i <= k; ++i) {
for (auto j : Right[i]) {
if (j.first == sum) ans += j.second;
}
}
cout << ans;
}
|
Professor GukiZ likes programming contests. He especially likes to rate his students on the contests he prepares. Now, he has decided to prepare a new contest.
In total, n students will attend, and before the start, every one of them has some positive integer rating. Students are indexed from 1 to n. Let's denote the rating of i-th student as ai. After the contest ends, every student will end up with some positive integer position. GukiZ expects that his students will take places according to their ratings.
He thinks that each student will take place equal to <image>. In particular, if student A has rating strictly lower then student B, A will get the strictly better position than B, and if two students have equal ratings, they will share the same position.
GukiZ would like you to reconstruct the results by following his expectations. Help him and determine the position after the end of the contest for each of his students if everything goes as expected.
Input
The first line contains integer n (1 ≤ n ≤ 2000), number of GukiZ's students.
The second line contains n numbers a1, a2, ... an (1 ≤ ai ≤ 2000) where ai is the rating of i-th student (1 ≤ i ≤ n).
Output
In a single line, print the position after the end of the contest for each of n students in the same order as they appear in the input.
Examples
Input
3
1 3 3
Output
3 1 1
Input
1
1
Output
1
Input
5
3 5 3 4 5
Output
4 1 4 3 1
Note
In the first sample, students 2 and 3 are positioned first (there is no other student with higher rating), and student 1 is positioned third since there are two students with higher rating.
In the second sample, first student is the only one on the contest.
In the third sample, students 2 and 5 share the first position with highest rating, student 4 is next with third position, and students 1 and 3 are the last sharing fourth position.
|
#include <bits/stdc++.h>
using namespace std;
int a[2001] = {0}, b[2001];
int main() {
int n;
cin >> n;
for (int i = 1, j; i <= n; i++) {
cin >> j;
a[j]++;
b[i] = j;
}
int ranking = 1, temp;
for (int i = 2000; i >= 1; i--) {
if (a[i] != 0) {
temp = a[i];
a[i] = ranking;
ranking += temp;
}
}
for (int i = 1; i <= n; i++) {
if (i == n) {
cout << a[b[i]];
break;
}
cout << a[b[i]] << " ";
}
return 0;
}
|
You are given n numbers a1, a2, ..., an. You can perform at most k operations. For each operation you can multiply one of the numbers by x. We want to make <image> as large as possible, where <image> denotes the bitwise OR.
Find the maximum possible value of <image> after performing at most k operations optimally.
Input
The first line contains three integers n, k and x (1 ≤ n ≤ 200 000, 1 ≤ k ≤ 10, 2 ≤ x ≤ 8).
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109).
Output
Output the maximum value of a bitwise OR of sequence elements after performing operations.
Examples
Input
3 1 2
1 1 1
Output
3
Input
4 2 3
1 2 4 8
Output
79
Note
For the first sample, any possible choice of doing one operation will result the same three numbers 1, 1, 2 so the result is <image>.
For the second sample if we multiply 8 by 3 two times we'll get 72. In this case the numbers will become 1, 2, 4, 72 so the OR value will be 79 and is the largest possible result.
|
#include <bits/stdc++.h>
using namespace std;
int N, y, K;
long long P;
int A[2 * 100005];
int pref[2 * 100005], suf[2 * 100005];
int main() {
cin >> N >> K >> P;
for (int i = 0; i < N; ++i) {
cin >> A[i];
}
pref[0] = A[0];
suf[N] = A[N];
for (int i = 1; i < N; ++i) pref[i] = (A[i] | pref[i - 1]);
for (int i = N - 1; i >= 0; --i) suf[i] = (A[i] | suf[i + 1]);
long long ormax = -1;
for (int i = 0; i < N; ++i) {
long long x = A[i];
for (int j = 0; j < K; ++j) x = P * x;
long long orr;
if (i == 0)
orr = x | suf[i + 1];
else
orr = x | pref[i - 1] | suf[i + 1];
ormax = max(orr, ormax);
}
cout << ormax;
return 0;
}
|
In Ancient Berland there were n cities and m two-way roads of equal length. The cities are numbered with integers from 1 to n inclusively. According to an ancient superstition, if a traveller visits three cities ai, bi, ci in row, without visiting other cities between them, a great disaster awaits him. Overall there are k such city triplets. Each triplet is ordered, which means that, for example, you are allowed to visit the cities in the following order: ai, ci, bi. Vasya wants to get from the city 1 to the city n and not fulfil the superstition. Find out which minimal number of roads he should take. Also you are required to find one of his possible path routes.
Input
The first line contains three integers n, m, k (2 ≤ n ≤ 3000, 1 ≤ m ≤ 20000, 0 ≤ k ≤ 105) which are the number of cities, the number of roads and the number of the forbidden triplets correspondingly.
Then follow m lines each containing two integers xi, yi (1 ≤ xi, yi ≤ n) which are the road descriptions. The road is described by the numbers of the cities it joins. No road joins a city with itself, there cannot be more than one road between a pair of cities.
Then follow k lines each containing three integers ai, bi, ci (1 ≤ ai, bi, ci ≤ n) which are the forbidden triplets. Each ordered triplet is listed mo more than one time. All three cities in each triplet are distinct.
City n can be unreachable from city 1 by roads.
Output
If there are no path from 1 to n print -1. Otherwise on the first line print the number of roads d along the shortest path from the city 1 to the city n. On the second line print d + 1 numbers — any of the possible shortest paths for Vasya. The path should start in the city 1 and end in the city n.
Examples
Input
4 4 1
1 2
2 3
3 4
1 3
1 4 3
Output
2
1 3 4
Input
3 1 0
1 2
Output
-1
Input
4 4 2
1 2
2 3
3 4
1 3
1 2 3
1 3 4
Output
4
1 3 2 3 4
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
long long n, m, k;
cin >> n >> m >> k;
vector<vector<long long>> a(n + 1);
set<vector<long long>> s;
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
a[u].push_back(v);
a[v].push_back(u);
}
for (long long i = 0; i < k; i++) {
vector<long long> v(3);
cin >> v[0] >> v[1] >> v[2];
s.insert(v);
}
queue<vector<long long>> q;
map<pair<long long, long long>, pair<long long, long long>> par;
q.push({1, 0, 0});
set<pair<long long, long long>> vis;
while (!q.empty()) {
auto tmp = q.front();
q.pop();
if (tmp[0] == n) {
pair<long long, long long> start = {n, tmp[1]};
cout << tmp[2] << endl;
vector<long long> b;
while (start.second) {
b.push_back(start.first);
start = par[start];
}
b.push_back(1);
reverse(b.begin(), b.end());
for (auto x : b) cout << x << " ";
return 0;
} else {
for (auto x : a[tmp[0]]) {
if (vis.count({x, tmp[0]}) || s.count({tmp[2], tmp[0], x})) continue;
vis.insert({x, tmp[0]});
q.push({x, tmp[0], tmp[2] + 1});
par[{x, tmp[0]}] = {tmp[0], tmp[1]};
}
}
}
cout << "-1" << endl;
return 0;
}
|
There are n sharks who grow flowers for Wet Shark. They are all sitting around the table, such that sharks i and i + 1 are neighbours for all i from 1 to n - 1. Sharks n and 1 are neighbours too.
Each shark will grow some number of flowers si. For i-th shark value si is random integer equiprobably chosen in range from li to ri. Wet Shark has it's favourite prime number p, and he really likes it! If for any pair of neighbouring sharks i and j the product si·sj is divisible by p, then Wet Shark becomes happy and gives 1000 dollars to each of these sharks.
At the end of the day sharks sum all the money Wet Shark granted to them. Find the expectation of this value.
Input
The first line of the input contains two space-separated integers n and p (3 ≤ n ≤ 100 000, 2 ≤ p ≤ 109) — the number of sharks and Wet Shark's favourite prime number. It is guaranteed that p is prime.
The i-th of the following n lines contains information about i-th shark — two space-separated integers li and ri (1 ≤ li ≤ ri ≤ 109), the range of flowers shark i can produce. Remember that si is chosen equiprobably among all integers from li to ri, inclusive.
Output
Print a single real number — the expected number of dollars that the sharks receive in total. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 2
1 2
420 421
420420 420421
Output
4500.0
Input
3 5
1 4
2 3
11 14
Output
0.0
Note
A prime number is a positive integer number that is divisible only by 1 and itself. 1 is not considered to be prime.
Consider the first sample. First shark grows some number of flowers from 1 to 2, second sharks grows from 420 to 421 flowers and third from 420420 to 420421. There are eight cases for the quantities of flowers (s0, s1, s2) each shark grows:
1. (1, 420, 420420): note that s0·s1 = 420, s1·s2 = 176576400, and s2·s0 = 420420. For each pair, 1000 dollars will be awarded to each shark. Therefore, each shark will be awarded 2000 dollars, for a total of 6000 dollars.
2. (1, 420, 420421): now, the product s2·s0 is not divisible by 2. Therefore, sharks s0 and s2 will receive 1000 dollars, while shark s1 will receive 2000. The total is 4000.
3. (1, 421, 420420): total is 4000
4. (1, 421, 420421): total is 0.
5. (2, 420, 420420): total is 6000.
6. (2, 420, 420421): total is 6000.
7. (2, 421, 420420): total is 6000.
8. (2, 421, 420421): total is 4000.
The expected value is <image>.
In the second sample, no combination of quantities will garner the sharks any money.
|
import java.util.Scanner;
public class Main {
Scanner in = new Scanner(System.in);
double calc(int l, int r, int p) {
return (double)(r / p - (l - 1) / p) / (r - l + 1);
}
public void run() {
int n = in.nextInt(), p = in.nextInt();
int[] l = new int[n];
int[] r = new int[n];
for (int i = 0; i < n; i++) {
l[i] = in.nextInt();
r[i] = in.nextInt();
}
double res = 0;
for (int i = 0; i < n; i++) {
res += 2000 * (1.0 - (1.0 - calc(l[i], r[i], p)) * (1.0 - calc(l[(i+1)%n], r[(i+1)%n], p)));
}
System.out.println(res);
}
public static void main(String[] args) {
new Main().run();
}
}
|
Bear Limak has n colored balls, arranged in one long row. Balls are numbered 1 through n, from left to right. There are n possible colors, also numbered 1 through n. The i-th ball has color ti.
For a fixed interval (set of consecutive elements) of balls we can define a dominant color. It's a color occurring the biggest number of times in the interval. In case of a tie between some colors, the one with the smallest number (index) is chosen as dominant.
There are <image> non-empty intervals in total. For each color, your task is to count the number of intervals in which this color is dominant.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 5000) — the number of balls.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ n) where ti is the color of the i-th ball.
Output
Print n integers. The i-th of them should be equal to the number of intervals where i is a dominant color.
Examples
Input
4
1 2 1 2
Output
7 3 0 0
Input
3
1 1 1
Output
6 0 0
Note
In the first sample, color 2 is dominant in three intervals:
* An interval [2, 2] contains one ball. This ball's color is 2 so it's clearly a dominant color.
* An interval [4, 4] contains one ball, with color 2 again.
* An interval [2, 4] contains two balls of color 2 and one ball of color 1.
There are 7 more intervals and color 1 is dominant in all of them.
|
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, a[10001], b[10001], v, h[10001], k;
int main() {
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) b[j] = 0;
k = 0;
for (j = i; j <= n; j++) {
v = a[j];
b[v]++;
if (b[v] > b[k] or (b[v] == b[k] and v < k)) k = v;
h[k]++;
}
}
for (i = 1; i <= n; i++) cout << h[i] << " ";
return 0;
}
|
On the planet Mars a year lasts exactly n days (there are no leap years on Mars). But Martians have the same weeks as earthlings — 5 work days and then 2 days off. Your task is to determine the minimum possible and the maximum possible number of days off per year on Mars.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 1 000 000) — the number of days in a year on Mars.
Output
Print two integers — the minimum possible and the maximum possible number of days off per year on Mars.
Examples
Input
14
Output
4 4
Input
2
Output
0 2
Note
In the first sample there are 14 days in a year on Mars, and therefore independently of the day a year starts with there will be exactly 4 days off .
In the second sample there are only 2 days in a year on Mars, and they can both be either work days or days off.
|
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
scanf("%d", &n);
int minday = n / 7 * 2, maxday = n;
if (n % 7 == 6) minday++;
if (n > 2) {
maxday = 2;
n -= 2;
maxday += n / 7 * 2;
if (n % 7 == 6) maxday++;
}
cout << minday << " " << maxday << endl;
return 0;
}
|
You are given a positive decimal number x.
Your task is to convert it to the "simple exponential notation".
Let x = a·10b, where 1 ≤ a < 10, then in general case the "simple exponential notation" looks like "aEb". If b equals to zero, the part "Eb" should be skipped. If a is an integer, it should be written without decimal point. Also there should not be extra zeroes in a and b.
Input
The only line contains the positive decimal number x. The length of the line will not exceed 106. Note that you are given too large number, so you can't use standard built-in data types "float", "double" and other.
Output
Print the only line — the "simple exponential notation" of the given number x.
Examples
Input
16
Output
1.6E1
Input
01.23400
Output
1.234
Input
.100
Output
1E-1
Input
100.
Output
1E2
|
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
inline void gmax(T1 &a, T2 b) {
if (b > a) a = b;
}
template <class T1, class T2>
inline void gmin(T1 &a, T2 b) {
if (b < a) a = b;
}
const int N = 1e6 + 10;
const long long INF = 1e18;
int casenum, casei;
const int Z = 1e9 + 7;
int n, m;
char s[N];
int st, ed, dot, E;
int main() {
while (~scanf("%s", s)) {
int len = strlen(s);
for (int i = 0; i < len; i++) {
if (s[i] == '0' || s[i] == '.')
continue;
else {
st = i;
break;
}
}
dot = -1;
for (int i = 0; i < len; i++) {
if (s[i] == '.') {
dot = i;
break;
}
}
if (dot == -1) dot = len;
if (dot > st)
E = dot - st - 1;
else
E = dot - st;
for (int i = len - 1; i >= 0; i--) {
if (s[i] == '0' || s[i] == '.')
continue;
else {
ed = i;
break;
}
}
printf("%c", s[st]);
if (ed > st) printf(".");
for (int i = st + 1; i <= ed; i++)
if (s[i] != '.') printf("%c", s[i]);
if (E) {
printf("E");
printf("%d", E);
}
puts("");
}
return 0;
}
|
ZS the Coder is playing a game. There is a number displayed on the screen and there are two buttons, ' + ' (plus) and '<image>' (square root). Initially, the number 2 is displayed on the screen. There are n + 1 levels in the game and ZS the Coder start at the level 1.
When ZS the Coder is at level k, he can :
1. Press the ' + ' button. This increases the number on the screen by exactly k. So, if the number on the screen was x, it becomes x + k.
2. Press the '<image>' button. Let the number on the screen be x. After pressing this button, the number becomes <image>. After that, ZS the Coder levels up, so his current level becomes k + 1. This button can only be pressed when x is a perfect square, i.e. x = m2 for some positive integer m.
Additionally, after each move, if ZS the Coder is at level k, and the number on the screen is m, then m must be a multiple of k. Note that this condition is only checked after performing the press. For example, if ZS the Coder is at level 4 and current number is 100, he presses the '<image>' button and the number turns into 10. Note that at this moment, 10 is not divisible by 4, but this press is still valid, because after it, ZS the Coder is at level 5, and 10 is divisible by 5.
ZS the Coder needs your help in beating the game — he wants to reach level n + 1. In other words, he needs to press the '<image>' button n times. Help him determine the number of times he should press the ' + ' button before pressing the '<image>' button at each level.
Please note that ZS the Coder wants to find just any sequence of presses allowing him to reach level n + 1, but not necessarily a sequence minimizing the number of presses.
Input
The first and only line of the input contains a single integer n (1 ≤ n ≤ 100 000), denoting that ZS the Coder wants to reach level n + 1.
Output
Print n non-negative integers, one per line. i-th of them should be equal to the number of times that ZS the Coder needs to press the ' + ' button before pressing the '<image>' button at level i.
Each number in the output should not exceed 1018. However, the number on the screen can be greater than 1018.
It is guaranteed that at least one solution exists. If there are multiple solutions, print any of them.
Examples
Input
3
Output
14
16
46
Input
2
Output
999999999999999998
44500000000
Input
4
Output
2
17
46
97
Note
In the first sample case:
On the first level, ZS the Coder pressed the ' + ' button 14 times (and the number on screen is initially 2), so the number became 2 + 14·1 = 16. Then, ZS the Coder pressed the '<image>' button, and the number became <image>.
After that, on the second level, ZS pressed the ' + ' button 16 times, so the number becomes 4 + 16·2 = 36. Then, ZS pressed the '<image>' button, levelling up and changing the number into <image>.
After that, on the third level, ZS pressed the ' + ' button 46 times, so the number becomes 6 + 46·3 = 144. Then, ZS pressed the '<image>' button, levelling up and changing the number into <image>.
Note that 12 is indeed divisible by 4, so ZS the Coder can reach level 4.
Also, note that pressing the ' + ' button 10 times on the third level before levelling up does not work, because the number becomes 6 + 10·3 = 36, and when the '<image>' button is pressed, the number becomes <image> and ZS the Coder is at Level 4. However, 6 is not divisible by 4 now, so this is not a valid solution.
In the second sample case:
On the first level, ZS the Coder pressed the ' + ' button 999999999999999998 times (and the number on screen is initially 2), so the number became 2 + 999999999999999998·1 = 1018. Then, ZS the Coder pressed the '<image>' button, and the number became <image>.
After that, on the second level, ZS pressed the ' + ' button 44500000000 times, so the number becomes 109 + 44500000000·2 = 9·1010. Then, ZS pressed the '<image>' button, levelling up and changing the number into <image>.
Note that 300000 is a multiple of 3, so ZS the Coder can reach level 3.
|
n=int(input())
print(2)
for lvl in range(2,n+1):
print(lvl*(lvl+1)*(lvl+1)-(lvl-1))
|
Ostap is preparing to play chess again and this time he is about to prepare. Thus, he was closely monitoring one recent chess tournament. There were m players participating and each pair of players played exactly one game. The victory gives 2 points, draw — 1 points, lose — 0 points.
Ostap is lazy, so he never tries to remember the outcome of each game. Instead, he computes the total number of points earned by each of the players (the sum of his points in all games which he took part in), sort these value in non-ascending order and then remembers first n integers in this list.
Now the Great Strategist Ostap wonders whether he remembers everything correct. He considers that he is correct if there exists at least one tournament results table such that it will produce the given integers. That means, if we count the sum of points for each player, sort them and take first n elements, the result will coincide with what Ostap remembers. Can you check if such table exists?
Input
The first line of the input contains two integers m and n (1 ≤ n ≤ m ≤ 3000) — the number of participants of the tournament and the number of top results Ostap remembers.
The second line contains n integers, provided in non-ascending order — the number of points earned by top participants as Ostap remembers them. It's guaranteed that this integers are non-negative and do not exceed 2·m.
Output
If there is no tournament such that Ostap can obtain the given set of integers using the procedure described in the statement, then print "no" in the only line of the output. Otherwise, the first line of the output should contain the word "yes". Next m lines should provide the description of any valid tournament. Each of these lines must contain m characters 'X', 'W', 'D' and 'L'. Character 'X' should always be located on the main diagonal (and only there), that is on the i-th position of the i-th string. Character 'W' on the j-th position of the i-th string means that the i-th player won the game against the j-th. In the same way character 'L' means loose and 'D' means draw.
The table you print must be consistent and the points earned by best n participants should match the memory of Ostap. If there are many possible answers, print any of them.
Examples
Input
5 5
8 6 4 2 0
Output
yes
XWWWW
LXWWW
LLXWW
LLLXW
LLLLX
Input
5 1
9
Output
no
|
#include <bits/stdc++.h>
using namespace std;
void assign(vector<vector<int>> &res, int i, int j, int v) {
res[i][j] = v;
res[j][i] = 2 - v;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
int N, K;
cin >> N >> K;
vector<pair<int, int>> pts(N);
for (int i = 0; i < K; i++) cin >> pts[i].first;
int sum = 0;
for (int i = 0; i < N; i++) {
int lim = 2 * (i + 1) * (N - i - 1) + i * (i + 1) - sum;
if (pts[i].first > lim) {
cout << "no\n";
return 0;
}
if (i >= K) {
pts[i].first = min(lim, pts[i - 1].first);
}
sum += pts[i].first;
pts[i].second = i;
}
if (sum != N * (N - 1)) {
cout << "no\n";
return 0;
}
vector<vector<int>> res(N, vector<int>(N));
while (pts.size() > 0) {
sort((pts).begin(), (pts).end(), [&](pair<int, int> &a, pair<int, int> &b) {
return a.first > b.first;
});
for (int i = pts.size() - 1; i > 0; i--) {
int take = min(2, pts[0].first);
assign(res, pts[0].second, pts[i].second, take);
pts[0].first -= take;
pts[i].first -= (2 - take);
}
pts.erase(pts.begin());
}
const string out = "LDW";
cout << "yes\n";
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (i == j)
cout << 'X';
else
cout << out[res[i][j]];
}
cout << "\n";
}
return 0;
}
|
Nikita has a stack. A stack in this problem is a data structure that supports two operations. Operation push(x) puts an integer x on the top of the stack, and operation pop() deletes the top integer from the stack, i. e. the last added. If the stack is empty, then the operation pop() does nothing.
Nikita made m operations with the stack but forgot them. Now Nikita wants to remember them. He remembers them one by one, on the i-th step he remembers an operation he made pi-th. In other words, he remembers the operations in order of some permutation p1, p2, ..., pm. After each step Nikita wants to know what is the integer on the top of the stack after performing the operations he have already remembered, in the corresponding order. Help him!
Input
The first line contains the integer m (1 ≤ m ≤ 105) — the number of operations Nikita made.
The next m lines contain the operations Nikita remembers. The i-th line starts with two integers pi and ti (1 ≤ pi ≤ m, ti = 0 or ti = 1) — the index of operation he remembers on the step i, and the type of the operation. ti equals 0, if the operation is pop(), and 1, is the operation is push(x). If the operation is push(x), the line also contains the integer xi (1 ≤ xi ≤ 106) — the integer added to the stack.
It is guaranteed that each integer from 1 to m is present exactly once among integers pi.
Output
Print m integers. The integer i should equal the number on the top of the stack after performing all the operations Nikita remembered on the steps from 1 to i. If the stack is empty after performing all these operations, print -1.
Examples
Input
2
2 1 2
1 0
Output
2
2
Input
3
1 1 2
2 1 3
3 0
Output
2
3
2
Input
5
5 0
4 0
3 1 1
2 1 1
1 1 2
Output
-1
-1
-1
-1
2
Note
In the first example, after Nikita remembers the operation on the first step, the operation push(2) is the only operation, so the answer is 2. After he remembers the operation pop() which was done before push(2), answer stays the same.
In the second example, the operations are push(2), push(3) and pop(). Nikita remembers them in the order they were performed.
In the third example Nikita remembers the operations in the reversed order.
|
#include <bits/stdc++.h>
using namespace std;
int getint() {
int f = 1, x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return f * x;
}
struct node {
long long x, y;
int l, r;
} tr[212345 << 2];
void pushup(int i) {
int lx = tr[(i << 1)].x, ly = tr[(i << 1)].y, rx = tr[(i << 1 | 1)].x,
ry = tr[(i << 1 | 1)].y;
int t = min(ly, rx);
int x = lx + rx - t;
int y = ry + ly - t;
tr[i].x = x;
tr[i].y = y;
return;
}
void build(int i, int l, int r) {
tr[i].l = l;
tr[i].r = r;
tr[i].x = tr[i].y = 0;
if (l == r) {
return;
}
int mid = (l + r) >> 1;
build((i << 1), l, (mid));
build((i << 1 | 1), (mid + 1), r);
return;
}
int op[212345];
int w[212345];
void modify(int i, int id) {
int l = tr[i].l, r = tr[i].r;
if (l == r) {
if (op[id])
tr[i].y = 1;
else
tr[i].x = 1;
return;
}
int mid = (l + r) >> 1;
if (id <= (mid))
modify((i << 1), id);
else
modify((i << 1 | 1), id);
pushup(i);
return;
}
int query(int i, int x) {
int l = tr[i].l, r = tr[i].r;
if (tr[i].y <= x) return 0;
if (l == r) return l;
if (tr[(i << 1 | 1)].y && tr[(i << 1 | 1)].y > x)
return query((i << 1 | 1), x);
else
return query((i << 1), x - tr[(i << 1 | 1)].y + tr[(i << 1 | 1)].x);
}
int main() {
int n = getint();
build(1, 1, n);
for (int i = 1; i <= n; i++) {
int id = getint();
op[id] = getint();
if (op[id]) w[id] = getint();
modify(1, id);
id = query(1, 0);
if (op[id] == 0)
printf("-1\n");
else
printf("%d\n", w[id]);
}
return 0;
}
|
Input
The input contains a single integer a (1 ≤ a ≤ 30).
Output
Output a single integer.
Example
Input
3
Output
27
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[31] = {0, 4, 22, 27, 58, 85, 94, 121, 166, 202, 265,
274, 319, 346, 355, 378, 382, 391, 438, 454, 483, 517,
526, 535, 562, 576, 588, 627, 634, 636, 645};
int n;
cin >> n;
cout << a[n] << endl;
return 0;
}
|
In Isart people don't die. There are n gangs of criminals. The i-th gang contains si evil people numerated from 0 to si - 1. Some of these people took part in a big mine robbery and picked one gold bullion each (these people are given in the input). That happened 10100 years ago and then all of the gangs escaped to a remote area, far from towns.
During the years, they were copying some gold bullions according to an organized plan in order to not get arrested. They constructed a tournament directed graph (a graph where there is exactly one directed edge between every pair of vertices) of gangs (the graph is given in the input). In this graph an edge from u to v means that in the i-th hour the person <image> of the gang u can send a fake gold bullion to person <image> of gang v. He sends it if he has some bullion (real or fake), while the receiver doesn't have any. Thus, at any moment each of the gangsters has zero or one gold bullion. Some of them have real bullions, and some of them have fake ones.
In the beginning of this year, the police has finally found the gangs, but they couldn't catch them, as usual. The police decided to open a jewelry store so that the gangsters would sell the bullions. Thus, every gangster that has a bullion (fake or real) will try to sell it. If he has a real gold bullion, he sells it without problems, but if he has a fake one, there is a choice of two events that can happen:
* The person sells the gold bullion successfully.
* The person is arrested by police.
The power of a gang is the number of people in it that successfully sold their bullion. After all selling is done, the police arrests b gangs out of top gangs. Sort the gangs by powers, we call the first a gang top gangs(you can sort the equal powers in each order). Consider all possible results of selling fake gold bullions and all possible choice of b gangs among the top gangs. Count the number of different sets of these b gangs modulo 109 + 7. Two sets X and Y are considered different if some gang is in X and isn't in Y.
Input
The first line contains four integers n, a and b (1 ≤ b ≤ a ≤ n ≤ 5·103) — the number of gangs, the constants a and b from the statement.
Then n lines follow, each line contains a string of size n consisting of zeros and ones. The j-th character in the i-th of these lines is equal to 1, then the vertex i have a directed edge to the vertex j. It is guaranteed that aii = 0 and aij + aji = 1 if i ≠ j.
Then n lines follow, each line starts with the integer si (1 ≤ si ≤ 2·106) — the number of gangsters in the i-th gang, and then contains a string of zeros and ones with length si. The j-th character is 0 if the j-th person of the i-th gang had a real gold bullion initially, otherwise it is 1. It is guaranteed that the sum of si does not exceed 2·106.
Output
Print single integer: the number of different sets of b gangs the police can arrest modulo 109 + 7.
Examples
Input
2 2 1
01
00
5 11000
6 100000
Output
2
Input
5 2 1
00000
10000
11011
11000
11010
2 00
1 1
6 100110
1 0
1 0
Output
5
|
#include <bits/stdc++.h>
inline int read() {
int x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
ch = getchar();
if (ch == '-') w = -1;
}
while (ch <= '9' && ch >= '0') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * w;
}
using namespace std;
const int N = 5005;
const int M = 2e6 + 5;
const int Mod = 1e9 + 7;
char str[M];
int n, k1, k2, tot, tim, ans;
int s[N], bg[N], vis[N];
int dfn[N], low[N], b[N];
int mn[N], mx[N], cnt[N];
int fac[M], inv[M], apr[M];
inline void ad(int &x, int y) {
x += y;
if (x >= Mod) x -= Mod;
if (x < 0) x += Mod;
}
inline int Pow(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = 1ll * res * x % Mod;
x = 1ll * x * x % Mod;
y >>= 1;
}
return res;
}
inline void math_init(int nn) {
fac[0] = 1;
for (int i = 1; i <= nn; ++i) fac[i] = 1ll * fac[i - 1] * i % Mod;
inv[nn] = Pow(fac[nn], Mod - 2);
for (int i = nn; i; --i) inv[i - 1] = 1ll * inv[i] * i % Mod;
}
inline int C(int x, int y) {
if (x < y || x < 0 || y < 0) return 0;
return 1ll * (1ll * fac[x] * inv[y] % Mod) * inv[x - y] % Mod;
}
vector<int> G[N], g[N], f[N];
stack<int> sta;
int gcd(int x, int y) {
if (!y) return x;
return gcd(y, x % y);
}
inline void input() {
n = read(), k1 = read(), k2 = read();
for (int i = 1; i <= n; ++i) {
scanf("%s", str + 1);
for (int j = 1; j <= n; ++j)
if (str[j] == '1') G[i].push_back(j);
}
for (int i = 1; i <= n; ++i) {
s[i] = read();
scanf("%s", str + 1);
for (int j = 1; j <= s[i]; ++j) {
g[i].push_back(str[j] - '0');
mn[i] += str[j] - '0';
}
}
}
void tarjan(int x) {
dfn[x] = low[x] = ++tim;
sta.push(x), vis[x] = 1;
for (int i = 0, sz = G[x].size(); i < sz; ++i) {
int y = G[x][i];
if (!dfn[y]) {
tarjan(y);
low[x] = min(low[x], low[y]);
} else if (vis[y])
low[x] = min(low[x], dfn[y]);
}
if (low[x] == dfn[x]) {
int now = 0;
++tot;
do {
now = sta.top(), sta.pop(), vis[now] = 0;
b[now] = tot, bg[tot] = gcd(bg[tot], s[now]);
} while (now != x);
}
}
namespace sub1 {
inline void build() {
for (int i = 1; i <= n; ++i)
if (!dfn[i]) tarjan(i);
for (int i = 1; i <= tot; ++i) f[i].resize(bg[i] + 1);
for (int i = 1; i <= n; ++i)
for (int j = 0; j < s[i]; ++j) f[b[i]][j % bg[b[i]]] |= g[i][j];
}
inline void solve() {
build();
for (int i = tot; i > 1; --i) {
int now = gcd(bg[i], bg[i - 1]);
for (int j = 0; j < bg[i]; ++j) {
apr[j % now] |= f[i][j];
cnt[i] += f[i][j];
}
for (int j = 0; j < bg[i - 1]; ++j) f[i - 1][j] |= apr[j % now];
for (int j = 0; j < bg[i]; ++j) apr[j % now] = 0;
}
for (int i = 0; i < bg[1]; ++i) cnt[1] += f[1][i];
for (int i = 1; i <= n; ++i) mx[i] = 1ll * cnt[b[i]] * s[i] / bg[b[i]];
}
} // namespace sub1
namespace sub2 {
inline void solve() {
for (int i = 1; i <= n; ++i) {
int cnt1 = 0, cnt2 = 0;
for (int j = 1; j <= n; ++j) {
if (i == j) continue;
if (mn[j] > mx[i])
++cnt1;
else if (mx[j] > mx[i] || (mx[j] == mx[i] && j < i))
++cnt2;
}
if (cnt1 > k1 - 1) continue;
for (int j = min(k2, min(k1 - 1 - cnt1, cnt2)); j + cnt1 + 1 >= k2; --j)
ad(ans, 1ll * C(cnt2, j) * C(cnt1, k2 - j - 1) % Mod);
}
printf("%d\n", ans);
}
} // namespace sub2
int main() {
math_init(M - 5), input();
sub1::solve(), sub2::solve();
return 0;
}
|
Consider a house plan.
Let the house be represented by an infinite horizontal strip defined by the inequality - h ≤ y ≤ h. Strictly outside the house there are two light sources at the points (0, f) and (0, - f). Windows are located in the walls, the windows are represented by segments on the lines y = h and y = - h. Also, the windows are arranged symmetrically about the line y = 0.
Your task is to find the area of the floor at the home, which will be lighted by the sources of light.
<image>
Input
The first line of the input file contains three integers n, h and f (1 ≤ n ≤ 500, 1 ≤ h ≤ 10, h < f ≤ 1000). Next, n lines contain two integers each li, ri ( - 5000 ≤ li < ri ≤ 5000), each entry indicates two segments. Endpoints of the first segment are (li, h)-(ri, h), and endpoints of the second segment are (li, - h)-(ri, - h). These segments describe location of windows. Numbers in the lines are space-separated. It is guaranteed that no two distinct segments have common points.
Output
Print the single real number — the area of the illuminated part of the floor with an absolute or relative error of no more than 10 - 4.
Examples
Input
1 1 2
-1 1
Output
10.0000000000
Input
2 2 4
-1 0
1 2
Output
23.3333333333
Note
The second sample test is shown on the figure. Green area is the desired area of the illuminated part of the floor. Violet segments indicate windows.
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500 + 5;
const double eps = 1e-10;
const int INF = 10000000;
struct point {
double x, y;
point() {}
point(double x, double y) : x(x), y(y) {}
};
point operator-(point a, point b) { return point(a.x - b.x, a.y - b.y); }
point operator+(point a, point b) { return point(a.x + b.x, a.y + b.y); }
point operator*(point a, double b) { return point(a.x * b, a.y * b); }
bool operator==(point a, point b) { return a.x == b.x && a.y == b.y; }
double cross(point a, point b) { return a.x * b.y - a.y * b.x; }
int dcmp(double a) {
if (fabs(a) < eps) return 0;
return a > 0 ? 1 : -1;
}
double h, f, ans, l, r, l1[maxn], r1[maxn], l2[maxn], r2[maxn];
bool on(point a, point b, point c) {
if ((a.x - b.x) * (a.x - c.x) <= 0 && (a.y - b.y) * (a.y - c.y) <= 0)
return true;
return false;
}
point get(point a, point b, point c, point d) {
point u = a - c;
double t = cross(d, u) / cross(b, d);
point x = a + b * t;
return x;
}
vector<point> cut(vector<point> poly, point A, point B) {
vector<point> newpoly;
int n = poly.size();
for (int i = 0; i < n; i++) {
point C = poly[i];
point D = poly[(i + 1) % n];
if (dcmp(cross(B - A, C - A)) >= 0) newpoly.push_back(C);
if (dcmp(cross(B - A, C - D)) != 0) {
point ip = get(A, B - A, C, D - C);
if (on(ip, C, D)) newpoly.push_back(ip);
}
}
return newpoly;
}
vector<point> poly;
void work() {
while (poly.size() >= 3) {
ans -= 0.5 * fabs(cross(poly[0] - poly[1], poly[2] - poly[1]));
poly.erase(poly.begin() + 1);
}
}
void pre() {
poly.clear();
poly.push_back(point(-INF, -h));
poly.push_back(point(INF, -h));
poly.push_back(point(INF, h));
poly.push_back(point(-INF, h));
}
int main() {
int n;
scanf("%d %lf %lf", &n, &h, &f);
for (int i = 0; i < n; i++) {
scanf("%lf %lf", &l, &r);
l1[i] = l, r1[i] = r, l2[i] = (f + h) / (f - h) * l,
r2[i] = (f + h) / (f - h) * r;
ans += 4 * f * h * (r - l) / (f - h);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
pre();
poly = cut(poly, point(l1[i], h), point(l2[i], -h));
poly = cut(poly, point(r2[i], -h), point(r1[i], h));
poly = cut(poly, point(l2[j], h), point(l1[j], -h));
poly = cut(poly, point(r1[j], -h), point(r2[j], h));
work();
}
printf("%.5lf\n", ans);
return 0;
}
|
Arpa is researching the Mexican wave.
There are n spectators in the stadium, labeled from 1 to n. They start the Mexican wave at time 0.
* At time 1, the first spectator stands.
* At time 2, the second spectator stands.
* ...
* At time k, the k-th spectator stands.
* At time k + 1, the (k + 1)-th spectator stands and the first spectator sits.
* At time k + 2, the (k + 2)-th spectator stands and the second spectator sits.
* ...
* At time n, the n-th spectator stands and the (n - k)-th spectator sits.
* At time n + 1, the (n + 1 - k)-th spectator sits.
* ...
* At time n + k, the n-th spectator sits.
Arpa wants to know how many spectators are standing at time t.
Input
The first line contains three integers n, k, t (1 ≤ n ≤ 109, 1 ≤ k ≤ n, 1 ≤ t < n + k).
Output
Print single integer: how many spectators are standing at time t.
Examples
Input
10 5 3
Output
3
Input
10 5 7
Output
5
Input
10 5 12
Output
3
Note
In the following a sitting spectator is represented as -, a standing spectator is represented as ^.
* At t = 0 ---------- <image> number of standing spectators = 0.
* At t = 1 ^--------- <image> number of standing spectators = 1.
* At t = 2 ^^-------- <image> number of standing spectators = 2.
* At t = 3 ^^^------- <image> number of standing spectators = 3.
* At t = 4 ^^^^------ <image> number of standing spectators = 4.
* At t = 5 ^^^^^----- <image> number of standing spectators = 5.
* At t = 6 -^^^^^---- <image> number of standing spectators = 5.
* At t = 7 --^^^^^--- <image> number of standing spectators = 5.
* At t = 8 ---^^^^^-- <image> number of standing spectators = 5.
* At t = 9 ----^^^^^- <image> number of standing spectators = 5.
* At t = 10 -----^^^^^ <image> number of standing spectators = 5.
* At t = 11 ------^^^^ <image> number of standing spectators = 4.
* At t = 12 -------^^^ <image> number of standing spectators = 3.
* At t = 13 --------^^ <image> number of standing spectators = 2.
* At t = 14 ---------^ <image> number of standing spectators = 1.
* At t = 15 ---------- <image> number of standing spectators = 0.
|
import java.util.*;
import java.io.*;
import java.math.*;
public final class Solution
{
public static void main(String[] args)
{
Reader input = new Reader();
PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
int n = input.nextInt(), k = input.nextInt(), t = input.nextInt();
if(t <= k)
out.println(t);
else if(t <= n)
out.println(k);
else
out.println(k - (t-n));
out.close();
}
public static class Reader
{
BufferedReader br;
StringTokenizer st;
public Reader()
{
br = new BufferedReader(new InputStreamReader(System.in));
}
public String next()
{
try
{
if(st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
}
catch(IOException ex)
{
ex.printStackTrace();
System.exit(1);
}
return st.nextToken();
}
public int nextInt()
{
return Integer.parseInt(next());
}
public double nextDouble()
{
return Double.parseDouble(next());
}
public long nextLong()
{
return Long.parseLong(next());
}
public String nextLine()
{
try
{
return br.readLine();
}
catch(IOException ex)
{
ex.printStackTrace();
System.exit(1);
}
return "";
}
}
}
|
You all know that the Library of Bookland is the largest library in the world. There are dozens of thousands of books in the library.
Some long and uninteresting story was removed...
The alphabet of Bookland is so large that its letters are denoted by positive integers. Each letter can be small or large, the large version of a letter x is denoted by x'. BSCII encoding, which is used everywhere in Bookland, is made in that way so that large letters are presented in the order of the numbers they are denoted by, and small letters are presented in the order of the numbers they are denoted by, but all large letters are before all small letters. For example, the following conditions hold: 2 < 3, 2' < 3', 3' < 2.
A word x1, x2, ..., xa is not lexicographically greater than y1, y2, ..., yb if one of the two following conditions holds:
* a ≤ b and x1 = y1, ..., xa = ya, i.e. the first word is the prefix of the second word;
* there is a position 1 ≤ j ≤ min(a, b), such that x1 = y1, ..., xj - 1 = yj - 1 and xj < yj, i.e. at the first position where the words differ the first word has a smaller letter than the second word has.
For example, the word "3' 7 5" is before the word "2 4' 6" in lexicographical order. It is said that sequence of words is in lexicographical order if each word is not lexicographically greater than the next word in the sequence.
Denis has a sequence of words consisting of small letters only. He wants to change some letters to large (let's call this process a capitalization) in such a way that the sequence of words is in lexicographical order. However, he soon realized that for some reason he can't change a single letter in a single word. He only can choose a letter and change all of its occurrences in all words to large letters. He can perform this operation any number of times with arbitrary letters of Bookland's alphabet.
Help Denis to choose which letters he needs to capitalize (make large) in order to make the sequence of words lexicographically ordered, or determine that it is impossible.
Note that some words can be equal.
Input
The first line contains two integers n and m (2 ≤ n ≤ 100 000, 1 ≤ m ≤ 100 000) — the number of words and the number of letters in Bookland's alphabet, respectively. The letters of Bookland's alphabet are denoted by integers from 1 to m.
Each of the next n lines contains a description of one word in format li, si, 1, si, 2, ..., si, li (1 ≤ li ≤ 100 000, 1 ≤ si, j ≤ m), where li is the length of the word, and si, j is the sequence of letters in the word. The words are given in the order Denis has them in the sequence.
It is guaranteed that the total length of all words is not greater than 100 000.
Output
In the first line print "Yes" (without quotes), if it is possible to capitalize some set of letters in such a way that the sequence of words becomes lexicographically ordered. Otherwise, print "No" (without quotes).
If the required is possible, in the second line print k — the number of letters Denis has to capitalize (make large), and in the third line print k distinct integers — these letters. Note that you don't need to minimize the value k.
You can print the letters in any order. If there are multiple answers, print any of them.
Examples
Input
4 3
1 2
1 1
3 1 3 2
2 1 1
Output
Yes
2
2 3
Input
6 5
2 1 2
2 1 2
3 1 2 3
2 1 5
2 4 4
2 4 4
Output
Yes
0
Input
4 3
4 3 2 2 1
3 1 1 3
3 2 3 3
2 3 1
Output
No
Note
In the first example after Denis makes letters 2 and 3 large, the sequence looks like the following:
* 2'
* 1
* 1 3' 2'
* 1 1
The condition 2' < 1 holds, so the first word is not lexicographically larger than the second word. The second word is the prefix of the third word, so the are in lexicographical order. As the first letters of the third and the fourth words are the same, and 3' < 1, then the third word is not lexicographically larger than the fourth word.
In the second example the words are in lexicographical order from the beginning, so Denis can do nothing.
In the third example there is no set of letters such that if Denis capitalizes them, the sequence becomes lexicographically ordered.
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 100111, inf = 1011111111;
int n, m, f[max_n], used[max_n], len[max_n];
vector<int> g[max_n], a[max_n], ans;
void dfs(int v) {
ans.push_back(v);
used[v] = 1;
f[v] = 1;
for (int to : g[v]) {
if (used[to] == 0) {
dfs(to);
}
}
}
bool cmp(int x, int y) {
if (f[x] != f[y]) {
return f[x] == 1;
}
return x < y;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%d", &len[i]);
a[i].resize(len[i]);
for (int j = 0; j < len[i]; ++j) {
scanf("%d", &a[i][j]);
}
}
for (int i = 0; i + 1 < n; ++i) {
int pos = 0;
while (pos < len[i] && pos < len[i + 1] && a[i][pos] == a[i + 1][pos]) {
++pos;
}
if (pos == len[i]) {
continue;
}
if (pos == len[i + 1]) {
printf("No\n");
return 0;
}
if (a[i][pos] < a[i + 1][pos]) {
g[a[i + 1][pos]].push_back(a[i][pos]);
} else {
f[a[i][pos]] = 1;
}
}
for (int i = 1; i <= m; ++i) {
if (f[i] && used[i] == 0) {
dfs(i);
}
}
for (int i = 0; i + 1 < n; ++i) {
int pos = 0;
while (pos < len[i] && pos < len[i + 1] && a[i][pos] == a[i + 1][pos]) {
++pos;
}
if (pos == len[i]) {
continue;
}
if (!cmp(a[i][pos], a[i + 1][pos])) {
printf("No\n");
return 0;
}
}
printf("Yes\n%d\n", ans.size());
for (int i = 0; i < ans.size(); ++i) {
printf("%d ", ans[i]);
}
printf("\n");
return 0;
}
|
Vasya writes his own library for building graphical user interface. Vasya called his creation VTK (VasyaToolKit). One of the interesting aspects of this library is that widgets are packed in each other.
A widget is some element of graphical interface. Each widget has width and height, and occupies some rectangle on the screen. Any widget in Vasya's library is of type Widget. For simplicity we will identify the widget and its type.
Types HBox and VBox are derivatives of type Widget, so they also are types Widget. Widgets HBox and VBox are special. They can store other widgets. Both those widgets can use the pack() method to pack directly in itself some other widget. Widgets of types HBox and VBox can store several other widgets, even several equal widgets — they will simply appear several times. As a result of using the method pack() only the link to the packed widget is saved, that is when the packed widget is changed, its image in the widget, into which it is packed, will also change.
We shall assume that the widget a is packed in the widget b if there exists a chain of widgets a = c1, c2, ..., ck = b, k ≥ 2, for which ci is packed directly to ci + 1 for any 1 ≤ i < k. In Vasya's library the situation when the widget a is packed in the widget a (that is, in itself) is not allowed. If you try to pack the widgets into each other in this manner immediately results in an error.
Also, the widgets HBox and VBox have parameters border and spacing, which are determined by the methods set_border() and set_spacing() respectively. By default both of these options equal 0.
<image>
The picture above shows how the widgets are packed into HBox and VBox. At that HBox and VBox automatically change their size depending on the size of packed widgets. As for HBox and VBox, they only differ in that in HBox the widgets are packed horizontally and in VBox — vertically. The parameter spacing sets the distance between adjacent widgets, and border — a frame around all packed widgets of the desired width. Packed widgets are placed exactly in the order in which the pack() method was called for them. If within HBox or VBox there are no packed widgets, their sizes are equal to 0 × 0, regardless of the options border and spacing.
The construction of all the widgets is performed using a scripting language VasyaScript. The description of the language can be found in the input data.
For the final verification of the code Vasya asks you to write a program that calculates the sizes of all the widgets on the source code in the language of VasyaScript.
Input
The first line contains an integer n — the number of instructions (1 ≤ n ≤ 100). Next n lines contain instructions in the language VasyaScript — one instruction per line. There is a list of possible instructions below.
* "Widget [name]([x],[y])" — create a new widget [name] of the type Widget possessing the width of [x] units and the height of [y] units.
* "HBox [name]" — create a new widget [name] of the type HBox.
* "VBox [name]" — create a new widget [name] of the type VBox.
* "[name1].pack([name2])" — pack the widget [name2] in the widget [name1]. At that, the widget [name1] must be of type HBox or VBox.
* "[name].set_border([x])" — set for a widget [name] the border parameter to [x] units. The widget [name] must be of type HBox or VBox.
* "[name].set_spacing([x])" — set for a widget [name] the spacing parameter to [x] units. The widget [name] must be of type HBox or VBox.
All instructions are written without spaces at the beginning and at the end of the string. The words inside the instruction are separated by exactly one space. There are no spaces directly before the numbers and directly after them.
The case matters, for example, "wiDget x" is not a correct instruction. The case of the letters is correct in the input data.
All names of the widgets consist of lowercase Latin letters and has the length from 1 to 10 characters inclusive. The names of all widgets are pairwise different. All numbers in the script are integers from 0 to 100 inclusive
It is guaranteed that the above-given script is correct, that is that all the operations with the widgets take place after the widgets are created and no widget is packed in itself. It is guaranteed that the script creates at least one widget.
Output
For each widget print on a single line its name, width and height, separated by spaces. The lines must be ordered lexicographically by a widget's name.
Please, do not use the %lld specificator to read or write 64-bit integers in C++. It is preferred to use cout stream (also you may use %I64d specificator)
Examples
Input
12
Widget me(50,40)
VBox grandpa
HBox father
grandpa.pack(father)
father.pack(me)
grandpa.set_border(10)
grandpa.set_spacing(20)
Widget brother(30,60)
father.pack(brother)
Widget friend(20,60)
Widget uncle(100,20)
grandpa.pack(uncle)
Output
brother 30 60
father 80 60
friend 20 60
grandpa 120 120
me 50 40
uncle 100 20
Input
15
Widget pack(10,10)
HBox dummy
HBox x
VBox y
y.pack(dummy)
y.set_border(5)
y.set_spacing(55)
dummy.set_border(10)
dummy.set_spacing(20)
x.set_border(10)
x.set_spacing(10)
x.pack(pack)
x.pack(dummy)
x.pack(pack)
x.set_border(0)
Output
dummy 0 0
pack 10 10
x 40 10
y 10 10
Note
In the first sample the widgets are arranged as follows:
<image>
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:160000000")
const int L = 1111;
const int N = 111;
string s;
map<string, int> M;
long long x[N];
long long y[N];
vector<int> v[N];
long long sp[N];
long long brd[N];
int t[N];
bool color[N];
int K = 0;
void dfs(int u) {
color[u] = 1;
if (t[u] == 0 || v[u].size() == 0) return;
x[u] = y[u] = brd[u] * 2;
int val = sp[u] * ((int)v[u].size() - 1);
if (t[u] == 1)
y[u] += val;
else
x[u] += val;
for (int i = 0; i < v[u].size(); ++i) {
if (!color[v[u][i]]) dfs(v[u][i]);
if (t[u] == 1) {
y[u] += y[v[u][i]];
x[u] = max(x[u], brd[u] * 2 + x[v[u][i]]);
} else {
x[u] += x[v[u][i]];
y[u] = max(y[u], brd[u] * 2 + y[v[u][i]]);
}
}
}
int main() {
int n;
scanf("%d ", &n);
for (int i = 0; i < n; ++i) {
cin >> s;
if (s[0] == 'W') {
cin >> s;
int pos = 0;
int l = s.length();
for (pos = 0; pos < l; ++pos) {
if (s[pos] == '(') {
break;
}
}
M[s.substr(0, pos)] = K;
t[K] = 0;
x[K] = 0;
y[K] = 0;
++pos;
while (s[pos] >= '0' && s[pos] <= '9') {
x[K] = x[K] * 10 + s[pos] - '0';
++pos;
}
++pos;
while (s[pos] >= '0' && s[pos] <= '9') {
y[K] = y[K] * 10 + s[pos] - '0';
++pos;
}
++K;
} else if (s[0] == 'V') {
cin >> s;
M[s] = K;
t[K] = 1;
++K;
} else if (s[0] == 'H') {
cin >> s;
M[s] = K;
t[K] = 2;
++K;
} else {
int pos = 0;
int l = s.length();
for (pos = 0; pos < l; ++pos) {
if (s[pos] == '.') {
break;
}
}
string n1 = s.substr(0, pos);
++pos;
if (s[pos] == 'p') {
string n2 = s.substr(pos + 5, l - pos - 6);
v[M[n1]].push_back(M[n2]);
} else if (s[pos + 4] == 'b') {
pos += 11;
int k = M[n1];
brd[k] = 0;
while (s[pos] >= '0' && s[pos] <= '9') {
brd[k] = brd[k] * 10 + s[pos] - '0';
++pos;
}
} else {
pos += 12;
int k = M[n1];
sp[k] = 0;
while (s[pos] >= '0' && s[pos] <= '9') {
sp[k] = sp[k] * 10 + s[pos] - '0';
++pos;
}
}
}
}
for (int i = 0; i < K; ++i) {
if (!color[i]) {
dfs(i);
}
}
for (map<string, int>::iterator i = M.begin(); i != M.end(); i++) {
cout << i->first << " " << x[i->second] << " " << y[i->second] << endl;
}
return 0;
}
|
Petya sometimes has to water his field. To water the field, Petya needs a tank with exactly V ml of water.
Petya has got N tanks, i-th of them initially containing ai ml of water. The tanks are really large, any of them can contain any amount of water (no matter how large this amount is).
Also Petya has got a scoop that can contain up to K ml of water (initially the scoop is empty). This scoop can be used to get some water from some tank, and after that pour it all into some tank (it is impossible to get water from multiple tanks without pouring it, or leave some water in the scoop when pouring it). When Petya tries to get some water from a tank, he gets min(v, K) water, where v is the current volume of water in the tank.
Is it possible to obtain a tank with exactly V ml of water using these operations? If it is possible, print a sequence of operations that allows to do it. If there are multiple ways to obtain needed amount of water in some tank, print any of them.
Input
The first line contains 3 integers: N (2 ≤ N ≤ 5000), K (1 ≤ K ≤ 5000), and V (0 ≤ V ≤ 109) — the number of tanks, the maximum volume of water the scoop can contain, and the required amount of water in some tank, respectively.
The second line contains N integers ai (0 ≤ ai ≤ 105), where ai is initial volume of water in i-th tank.
Output
If it is impossible to obtain a tank with exactly V ml of water, print NO.
Otherwise print YES in the first line, and beginning from the second line, print the sequence of operations in the following format:
Each line has to contain 3 numbers denoting a compressed operation: "cnt x y" (1 ≤ cnt ≤ 109, 1 ≤ x, y ≤ N), where x is the index of the tank where we get water, y is the index of the tank where we pour water, and cnt is the number of times we transfer water from tank x to tank y.
The number of these lines must not exceed N + 5.
Examples
Input
2 3 5
2 3
Output
YES
1 2 1
Input
2 3 4
2 3
Output
NO
Input
5 2 0
1 3 5 7 9
Output
YES
2 2 1
3 3 1
4 4 1
5 5 1
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
int n;
long long k, v;
int fnum[N], fpre[N];
long long a[N];
int main() {
scanf("%d%d%d", &n, &k, &v);
for (int i = 1; i <= n; ++i) scanf("%I64d", a + i), a[0] += a[i];
if (a[0] < v) {
printf("NO");
return 0;
}
for (int i = 0; i < k; ++i) fnum[i] = -1;
fnum[0] = 0;
fpre[a[1] % k] = 0;
for (int i = 1; i <= n; ++i)
for (int j = 0; j < k; ++j)
if (fnum[j] != -1 && fnum[j] != i && fnum[(j + a[i]) % k] == -1)
fnum[(j + a[i]) % k] = i, fpre[(j + a[i]) % k] = j;
if (fnum[v % k] == -1) {
printf("NO");
return 0;
}
printf("YES\n");
if (v % k == 0) {
for (int i = 2; i <= n; ++i)
if (a[i] > 0) printf("%I64d %d %d\n", (a[i] - 1) / k + 1, i, 1);
if (v > 0) printf("%I64d %d %d", v / k, 1, 2);
return 0;
}
int t, S = fnum[v % k];
for (int i = fpre[v % k]; i; i = fpre[i]) {
printf("%I64d %d %d\n", (a[fnum[i]] - 1) / k + 1, fnum[i], S);
a[S] += a[fnum[i]];
a[fnum[i]] = 0;
}
t = 1;
if (S == 1) t = 2;
if (a[S] > v) {
printf("%I64d %d %d\n", (a[S] - v) / k, S, t);
} else if (a[S] < v) {
for (int i = 1; i <= n; ++i)
if (a[i] && i != S && i != t) {
printf("%I64d %d %d\n", (a[i] - 1) / k + 1, i, t);
}
printf("%I64d %d %d\n", (v - a[S]) / k, t, S);
}
return 0;
}
|
Dima is a beginner programmer. During his working process, he regularly has to repeat the following operation again and again: to remove every second element from the array. One day he has been bored with easy solutions of this problem, and he has come up with the following extravagant algorithm.
Let's consider that initially array contains n numbers from 1 to n and the number i is located in the cell with the index 2i - 1 (Indices are numbered starting from one) and other cells of the array are empty. Each step Dima selects a non-empty array cell with the maximum index and moves the number written in it to the nearest empty cell to the left of the selected one. The process continues until all n numbers will appear in the first n cells of the array. For example if n = 4, the array is changing as follows:
<image>
You have to write a program that allows you to determine what number will be in the cell with index x (1 ≤ x ≤ n) after Dima's algorithm finishes.
Input
The first line contains two integers n and q (1 ≤ n ≤ 1018, 1 ≤ q ≤ 200 000), the number of elements in the array and the number of queries for which it is needed to find the answer.
Next q lines contain integers xi (1 ≤ xi ≤ n), the indices of cells for which it is necessary to output their content after Dima's algorithm finishes.
Output
For each of q queries output one integer number, the value that will appear in the corresponding array cell after Dima's algorithm finishes.
Examples
Input
4 3
2
3
4
Output
3
2
4
Input
13 4
10
5
4
8
Output
13
3
8
9
Note
The first example is shown in the picture.
In the second example the final array is [1, 12, 2, 8, 3, 11, 4, 9, 5, 13, 6, 10, 7].
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, t;
cin >> n >> m;
while (m--) {
cin >> t;
while (t % 2 == 0) {
t = t / 2 + n;
}
cout << (t + 1) / 2 << endl;
}
return 0;
}
|
Little girl Tanya is learning how to decrease a number by one, but she does it wrong with a number consisting of two or more digits. Tanya subtracts one from a number by the following algorithm:
* if the last digit of the number is non-zero, she decreases the number by one;
* if the last digit of the number is zero, she divides the number by 10 (i.e. removes the last digit).
You are given an integer number n. Tanya will subtract one from it k times. Your task is to print the result after all k subtractions.
It is guaranteed that the result will be positive integer number.
Input
The first line of the input contains two integer numbers n and k (2 ≤ n ≤ 10^9, 1 ≤ k ≤ 50) — the number from which Tanya will subtract and the number of subtractions correspondingly.
Output
Print one integer number — the result of the decreasing n by one k times.
It is guaranteed that the result will be positive integer number.
Examples
Input
512 4
Output
50
Input
1000000000 9
Output
1
Note
The first example corresponds to the following sequence: 512 → 511 → 510 → 51 → 50.
|
a, b = input().split(' ')
a=int(a)
for i in range(int(b)):
if (a%10 != 0):
a -= 1
else:
a /= 10
print(int(a))
|
For a vector \vec{v} = (x, y), define |v| = √{x^2 + y^2}.
Allen had a bit too much to drink at the bar, which is at the origin. There are n vectors \vec{v_1}, \vec{v_2}, ⋅⋅⋅, \vec{v_n}. Allen will make n moves. As Allen's sense of direction is impaired, during the i-th move he will either move in the direction \vec{v_i} or -\vec{v_i}. In other words, if his position is currently p = (x, y), he will either move to p + \vec{v_i} or p - \vec{v_i}.
Allen doesn't want to wander too far from home (which happens to also be the bar). You need to help him figure out a sequence of moves (a sequence of signs for the vectors) such that his final position p satisfies |p| ≤ 1.5 ⋅ 10^6 so that he can stay safe.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of moves.
Each of the following lines contains two space-separated integers x_i and y_i, meaning that \vec{v_i} = (x_i, y_i). We have that |v_i| ≤ 10^6 for all i.
Output
Output a single line containing n integers c_1, c_2, ⋅⋅⋅, c_n, each of which is either 1 or -1. Your solution is correct if the value of p = ∑_{i = 1}^n c_i \vec{v_i}, satisfies |p| ≤ 1.5 ⋅ 10^6.
It can be shown that a solution always exists under the given constraints.
Examples
Input
3
999999 0
0 999999
999999 0
Output
1 1 -1
Input
1
-824590 246031
Output
1
Input
8
-67761 603277
640586 -396671
46147 -122580
569609 -2112
400 914208
131792 309779
-850150 -486293
5272 721899
Output
1 1 1 1 1 1 1 -1
|
#include <bits/stdc++.h>
using namespace std;
struct LLI {
public:
int x;
int y;
int inx;
LLI(int X = 0, int Y = 0, int INX = 0) {
x = X;
y = Y;
inx = INX;
}
};
int n, i, j;
LLI now;
LLI p[100001];
bool out[100001];
bool OUT[100001];
inline long long dist(LLI a) {
long long X = ((long long)(a.x));
long long Y = ((long long)(a.y));
return ((X * X) + (Y * Y));
}
inline LLI Plus(LLI a, LLI b) { return LLI(a.x + b.x, a.y + b.y); }
inline LLI Minus(LLI a, LLI b) { return LLI(a.x - b.x, a.y - b.y); }
int main() {
scanf("%d", &n);
for (i = 0; i != n; i++) {
scanf("%d%d", &p[i].x, &p[i].y);
p[i].inx = i;
if (p[i].x < 0 || (p[i].x == 0 && p[i].y < 0)) {
p[i].x *= (-1);
p[i].y *= (-1);
out[i] = true;
}
}
now = LLI(0, 0, 0);
do {
for (i = 0; i != n; i++) OUT[i] = out[i];
now = LLI(0, 0, 0);
random_shuffle(p, p + n);
for (i = 0; i != n; i++) {
if (dist(Plus(now, p[i])) <= dist(Minus(now, p[i])))
now = Plus(now, p[i]);
else {
now = Minus(now, p[i]);
OUT[p[i].inx] = (!OUT[p[i].inx]);
}
}
} while (dist(now) > (1500000LL * 1500000LL));
for (i = 0; i != n; i++) printf("%d ", OUT[i] == true ? 1 : (-1));
printf("\n");
return 0;
}
|
Zubin is the dark messiah. He roams the streets at night, helping the poor and the innocent from evil. He's Batman.
Ghosh is Zubin's nemesis. He's the Riddler to Zubin's Batman. He delights in torturing people with his puzzles.
Tonight, Ghosh has gotten hold of yet another innocent victim. When Zubin tries to save him, Ghosh sends him a message
Whom you seek is not here. Find him at GothamFuljhore 1st Street. The house number can be any of the length of the factorials of the numbers I'll send you next.
Now Zubin is a warrior, a hero. What he's not is too bright. Can you help him calculate the house number and help the poor victim?
EDIT
Maximum number of test cases - 500,
Number of addresses < 5*10^9
SAMPLE INPUT
5
1
5
86
23
4
SAMPLE OUTPUT
1
3
131
23
2
|
import math
t=input()
raw_input()
while t:
t-=1
n=input()
if (n==0 or n==1):
print 1
else:
print int(math.ceil((math.log(math.sqrt(2*math.pi*n))+n*math.log(n/math.e))/math.log(10)))
|
Today, King Trophies is on another rampage to destroy the small village controlled by Alex. Please help his soldiers.
At first, there are N individual soldiers, who haven't yet joined together; each of these soldiers is the leader of his/her own group. You have to handle 3 types of operations:
1) Two groups find each other, and the leader of the first group steps down.
2) A becomes leader of his group
3) Output the leader of a certain group
Input:
The first line contains the number N, the number of soldiers, and Q, the number of operations.
The next Q lines contains operations in the following format:
1 a b: Groups containing person a and person b find each other, and the leader of the group containing person a steps down, i.e., leader of group containing b becomes the leader of the merged group. If a is in b's group or vice versa ignore the operation.
2 a: a becomes the leader of his group.
3 a: Output the leader of the group containing person a.
Output:
Output the answer for each query of type 3.
Constraints:
1 ≤ N ≤ 10^5
1 ≤ Q ≤ 10^5
SAMPLE INPUT
2 2
1 1 2
3 1
SAMPLE OUTPUT
2
Explanation
Here, 2 will take over after 1 steps down.
|
def union(parents, i, j):
''' Union with under the deepest root '''
parents[i] = j
def find(parents, el):
''' Find an element and compress the sets '''
if parents[el] == el: return el
leader = find(parents, parents[el])
parents[el] = leader
return leader
def solve(n, xss):
res = []
parents = range(0, n)
for xs in xss:
if xs[0] == 1:
root_a = find(parents, xs[1] - 1)
root_b = find(parents, xs[2] - 1)
if root_a == root_b: continue
union(parents, root_a, root_b)
elif xs[0] == 2:
el = xs[1] - 1
root_a = find(parents, el)
parents[root_a] = el
parents[el] = el
else:
res.append(str(find(parents, xs[1] - 1) + 1))
return '\n'.join(res)
if __name__ == '__main__':
n, q = map(int, raw_input().split())
xss = [map(int, raw_input().split()) for _ in range(q)]
print solve(n, xss)
|
Tom gives a number N to Roy and ask him to tell the total number of even divisors of the number N. Help Roy to answer the question of Tom.
INPUT:
First line contains the number of testcases T, followed by T lines each containing an integer N.
OUTPUT:
For each testcase, print the required answer in a singlr line.
Constraints:
1 ≤ T ≤ 100
1 ≤ N ≤ 1000000000
SAMPLE INPUT
2
9
8
SAMPLE OUTPUT
0
3
|
def div(n):
return set(reduce(list.__add__,
([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))
for _ in xrange(input()):
x= div(input())
print len([1 for i in x if i%2==0])
|
Today grasshopper Jimmy Jumper is very hungry and his friend is notorious. Jimmy's friend puts an insect infront of him at a distance d. Jimmy can jump only a finite no of steps in each turn. Jimmy is initially at position 0. He can now jump 1 step to reach position 1 then jump 2 steps to reach position 3 then jump 4 steps to position 7 and so on.
Since Momu is very hungry and could not take risk of jumping but not reaching to the destination point, so you have to tell him whether he can reach to position d or not.
Input:
First line contains t test cases.
Next t lines contains an integer d.
Constraints:
1 ≤ t ≤ 10
1 ≤ d ≤ 10^9
Output:
t lines each containing "YES" if he can reach or "NO" if cannot
Test case:
Input:
3
3
15
5
Output:
YES
YES
NO
SAMPLE INPUT
3
3
15
5
SAMPLE OUTPUT
YES
YES
NO
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
#print 'Hello World!'
from math import sqrt
t=input()
while t>0:
t-=1
n=input()
a=0
b=1
while(a<n):
a+=b
b*=2
if n==a:
print"YES"
else:
print"NO"
|
From the divine land of heaven came to earth a fruit known as Magic fruit.Unfortunately the fruit was found by two friends X and Y.
After lot of fighting,they came to the conclusion that they will share the fruit if and only if when they can divide it into two even weighing parts without wasting any part of fruit. Given weight of the fruit tell them if they can share it.
Input
The first (and the only) input line contains integer number w (1 ≤ w ≤ 100) — the weight of the magic fruit.
Output
Print YES, if the boys can divide the magic fruit into two parts, each of them weighing even number of kilos; and NO in the opposite case.
SAMPLE INPUT
8
SAMPLE OUTPUT
YES
|
n=int(raw_input())
if(n==2 or n==0):
print "NO"
elif(n%2==0):
print "YES"
else:
print "NO"
|
Today Oz is playing a new game. He has an array arr[] of N distinct integers . In each turn he is will follow two actions -
1) He select a random number from arr[]. Say value of this element is X.
2) He will remove X from arr[]. if X-1 is present in arr[] then he will remove it. if X+1 is present in arr[] then he will remove it.
Oz will make turns until arr[] becomes empty. Oz loves this game so he wants to make maximum number of possible turns. Help Oz to make maximum number of possible turns.
Input :
The first line contains the number of test cases - T . Each test case consist of two lines. First line will contain a integer N - number of elements in arr[]. Second line will contain N space separated integers.
Output :
For each test case output maximum number of possible turns that Oz can make.
Constraints :
1 ≤ T ≤ 100
1 ≤ N ≤ 100
1 ≤ each element of arr[] ≤ 1000
SAMPLE INPUT
1
6
291 292 295 297 298 299
SAMPLE OUTPUT
4
Explanation
One of the possible way to make 4 turns is by choosing the following elements in each turn: 297, 299, 295, 292.
|
from math import ceil
def getCnt(n):
return int(round(float(n)/float(2)))
for t in xrange(input()):
L =input()
cnt = 0
ar = sorted(map(int,raw_input().split(' ')))
#print 'ar', ar
if not ar :
continue
elif L == 1:
print 1
continue
i = 1
seq_len = 1
while i < L:
#print i,ar[i-1],ar[i]
if ar[i] == ar[i-1]+1:
seq_len += 1
else :
#print seq_len,'adding',getCnt(seq_len)
cnt += getCnt(seq_len)
seq_len = 1
i+=1
if i == L :
#print 'seq_len',seq_len,getCnt(seq_len)
cnt += getCnt(seq_len)
print cnt
|
Professor Hatim is researching the sexual behavior of a rare species of lizard. He assumes that they feature two different genders and that they only interact with lizard of the opposite gender. Each lizard has a integer printed on their back.
Given the details of lizard interactions, decide whether the experiment supports his assumption of two genders with no homosexual bugs, or if it contains some bug interactions that falsify it. Or simply, you have to print "Suspicious lizard found!" (without quotes), if an interaction of two lizards of same gender is found in the list of interactions, otherwise print "No suspicious lizard found!" (without quotes).
Input format:
The first line contains an integer T, denoting the number of test cases.
The first line of each test case contains two integers N and M, where N denotes the number of lizards and M denotes the number of interactions.
Next M lines of each test case contains, two space separated integers, say x and y , denoting the interaction between lizard no. x and lizard no. y.
Note: Integers on the back of lizards are numbered from 1 to N.
Output format:
For each test case ,print a line, saying either “No suspicious lizard found!” if the experiment is consistent with his assumption about the lizard sexual behavior, or “Suspicious lizard found!” if Professor Hatims’s assumption is definitely wrong.
Constraints:
1 ≤ T ≤ 5
2 ≤ N ≤ 2000
1 ≤ M ≤ 10^5
SAMPLE INPUT
2
3 3
1 2
2 3
1 3
4 2
1 2
3 4
SAMPLE OUTPUT
Suspicious lizards found!
No suspicious lizards found!
|
for _ in range(int(raw_input())):
n,m=map(int,raw_input().split())
a=[[] for i in range(n)]
color=[0]*n
def bipartite_visit(v,clr):
color[v]=clr
for i in range(len(a[v])):
if color[a[v][i]]==color[v]:
return 0
elif color[a[v][i]]==0:
if color[v]==1:
if not bipartite_visit(a[v][i],2):
return 0
else:
if not bipartite_visit(a[v][i],1):
return 0
return 1
def isbipartite():
for i in range(n):
if color[i]==0:
if not bipartite_visit(i,1):
return 0
return 1
for i in range(m):
u,v=map(int,raw_input().split())
u,v=u-1,v-1
a[u].append(v)
a[v].append(u)
if not isbipartite():
print "Suspicious lizards found!"
else:
print "No suspicious lizards found!"
|
Sherlock rolls a N faced die M times. He adds all the numbers he gets on all throws. What is the probability that he has a sum of K.
A N faced die has all numbers from 1 to N written on it and each has equal probability of arriving when dice is thrown.
Input
First line T, the number of testcases. Each testcase consists of M, N and K in one line.
Output
For each testcase, print required probability in scientific notation as defined follows:
Output should be of the form "x y" where x is a floating point integer less than 10 and greater than or equal to 1 and y is a integer. This notation is equivalent to x * 10^-y. x should be rounded and output till 3 decimal digits.
However, if probability is 0, output "0.000 0".
Examples:
If output is supposed to be 0.0034567, output should be "3.457 3".
If output is supposed to be 0.3034567, output should be "3.034 1".
Constraints
1 ≤ T ≤ 10
1 ≤ N, M ≤ 50
1 ≤ K ≤ 10000
SAMPLE INPUT
2
1 5 2
2 3 2
SAMPLE OUTPUT
2.000 1
1.111 1
Explanation
For first testcase, sum=1,2,3,4,5 are all equally probable. Hence probability is 0.2.
For second testcase:
(1,1), (1,2), (1,3), (2,1), (2,2), (2,3), (3,1), (3,2), (3,3) are all possible ways.
Out of these 1 has sum 2. So 1/9 is the answer.
|
import sys
f = sys.stdin
dp = [0] * (51)
for i in range(0,51) :
dp[i] = [0] * (2501)
def solve(n,m,k) :
if m == 0 and k == 0 :
return 1
if m <= 0 :
return 0
if k <= 0 :
return 0
if dp[m][k] != -1 :
return dp[m][k]
dp[m][k] = 0
for i in range(1,n+1) :
dp[m][k] += solve(n,m-1,k-i)
return dp[m][k]
t = int(f.readline())
while t:
m,n,k = [int(x) for x in f.readline().split()]
# print n , m , k
if k > n*m :
print "0.000 0"
else :
for i in range(0,m+1) :
for j in range(0,n*m+1) :
dp[i][j] = -1
ans = solve(n,m,k)
if ans == 0 :
print "0.000 0"
else :
ans = 1.0 * ans
ans = ans / pow(n,m)
c = 0
while ans*10 < 10 :
ans = ans * 10
c += 1
print "%.3f" %ans,c
t -= 1
|
There is a street by the name of colorful street in the Pretty Town. The residents of the house have decided that they will paint their houses in either Pink, Orange or Yellow color and not other. They have also decided that no two adjacent houses will have the same color. For house i, i-1 and i+1 are the neighbors and note that the first and the last house are not neighbors.
The cost of painting a house in a particular color is different. The cost of painting the first house in color yellow maybe different than what its for painting the second house in the same color.
You have to find the minimum of cost of painting the houses which satisfy the given condition.
Input Constraints
- Number of houses will contain between 1 and 20 elements, inclusive.
- Each line of input for houses will have three values for cost of coloring in each color. Each value will be between 1 and 1000.
Input Format
- The first line will contain the number of test cases - T.
- The second line will contain an integer N that will specify how many houses are there.
- Each of the following N lines will contain 3 numbers separated by space that represents the cost of painting that house in either pink, orange or yellow color.
Output Format
Print T lines showing the cost of painting the houses for each test case.
SAMPLE INPUT
1
2
11 12 13
14 15 16
SAMPLE OUTPUT
26
Explanation
The first house should be painted in pink (11), the second should be painted in orange (15). So the total cost becomes 11+15 = 26
|
import sys
def find_cost():
testcases = int(sys.stdin.readline())
output = []
for x in range(testcases):
num_of_houses = int(sys.stdin.readline())
cost_of_color = cost_table(num_of_houses)
dp = [[0 for i in range(3)] for i in range(num_of_houses)]
for i in range(3):
dp[0][i] = cost_of_color[0][i]
for i in range(1, num_of_houses):
dp[i][0] = min( dp[i-1][1] , dp[i-1][2] ) + cost_of_color[i][0]
dp[i][1] = min( dp[i-1][0] , dp[i-1][2] ) + cost_of_color[i][1]
dp[i][2] = min( dp[i-1][0] , dp[i-1][1] ) + cost_of_color[i][2]
print min(min(dp[num_of_houses-1][0], dp[num_of_houses-1][1]) , dp[num_of_houses-1][2])
return 0
def cost_table(num_of_houses):
'''creates a list of n list where n is num_of_houses'''
cost_of_color = [[0 for i in range(3)] for i in range(num_of_houses)]
for i in range(num_of_houses):
cost_of_color[i] = map(int, (sys.stdin.readline()).split())
#cost_of_color[i][0] = int(sys.stdin.readline())
#cost_of_color[i][1] = int(sys.stdin.readline())
#cost_of_color[i][2] = int(sys.stdin.readline())
return cost_of_color
find_cost()
|
Xenny had N cubes. Each cube had six faces and each face had a Latin character on each of it's sides.
Xenny's friend Asdoc had an interesting activity in mind. He gave Xenny a string S and asked him to use the cubes to form that string. Xenny being a very lazy person, just wanted to randomly roll the cubes and then arrange a subset of them, to form the string S. Xenny relied on probability to get the desired string from the characters on the cubes.
Given the character on each face of each of the cubes, find out the the number of ways in which Xenny is able to make string S using the upward facing characters.
Input:
The first line of input consists of 2 space-separated integers - N and K - the number of cubes and the length of string S respectively.
N lines follow. Each line contains 6 space-separated characters, with i^th line representing the characters on the 6 faces of the i^th cube.
Last line of input contains string S.
Output:
Output the required number of ways MOD 10^9 + 7.
Constraints:
1 ≤ N ≤ 10
1 ≤ K ≤ N
S consists of lower-case Latin characters
SAMPLE INPUT
5 4
a a a a a a
a a a a a a
b b b b b b
c c c c c c
d d d d d d
abcd
SAMPLE OUTPUT
2592
Explanation
Lets number the cubes:
1. a a a a a a
2. a a a a a a
3. b b b b b b
4. c c c c c c
5. d d d d d d
We want to form the string: "abcd"
The possible arrangements of cubes are: 1-3-4-5 and 2-3-4-5.
In arrangement 1-3-4-5, there are 6 ways to get 'a', 6 ways to get 'b', 6 ways to get 'c' and 6 ways to get 'd'.
The same number of ways are possible for the arrangement 2-3-4-5.
Hence, total number of ways = 6^4 + 6^4 = 2592.
|
MOD=1000000007
n,k =map(int, raw_input().split())
c=[]
for i in range(n):
c.append(raw_input().split())
s=raw_input()
def choose(l,chosen):
cnt=0
if l==k: return 1
for i in range(n):
if not (chosen & (1<<i)):
chosen |=1<<i
fac=0
for x in c[i]:
if x==s[l]: fac+=1
if fac:
cnt+=fac*choose(l+1,chosen)
chosen -=1<<i
return cnt
chosen=choose(0,0)
print chosen %MOD
|
There are two persons, numbered 0 and 1, and a variable x whose initial value is 0. The two persons now play a game. The game is played in N rounds. The following should be done in the i-th round (1 \leq i \leq N):
* Person S_i does one of the following:
* Replace x with x \oplus A_i, where \oplus represents bitwise XOR.
* Do nothing.
Person 0 aims to have x=0 at the end of the game, while Person 1 aims to have x \neq 0 at the end of the game.
Determine whether x becomes 0 at the end of the game when the two persons play optimally.
Solve T test cases for each input file.
Constraints
* 1 \leq T \leq 100
* 1 \leq N \leq 200
* 1 \leq A_i \leq 10^{18}
* S is a string of length N consisting of `0` and `1`.
* All numbers in input are integers.
Input
Input is given from Standard Input in the following format. The first line is as follows:
T
Then, T test cases follow. Each test case is given in the following format:
N
A_1 A_2 \cdots A_N
S
Output
For each test case, print a line containing `0` if x becomes 0 at the end of the game, and `1` otherwise.
Example
Input
3
2
1 2
10
2
1 1
10
6
2 3 4 5 6 7
111000
Output
1
0
0
|
#include <bits/stdc++.h>
using namespace std;
typedef long long i64;
const int MAX = 1e6 + 10;
const int MOD = 1e9 + 7;
const int oo = 1e9;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
#define endl '\n'
int T; cin >> T;
while(T--){
int n; cin >> n;
vector<i64> A(n);
for(int i = 0; i <n; i++)cin >> A[i];
string p;
cin >> p;
vector<i64> basis;
int ans = 0;
for(int i = n - 1; i >= 0; i--){
i64 c = A[i];
for(auto b: basis) c= min(c, c ^ b);
if(p[i] == '1'){
if(c > 0){
ans = 1;break;
}
}
else{
if(c > 0)basis.push_back(c);
}
}
cout << ans << endl;
}
}
|
We have N dice arranged in a line from left to right. The i-th die from the left shows p_i numbers from 1 to p_i with equal probability when thrown.
We will choose K adjacent dice, throw each of them independently, and compute the sum of the numbers shown. Find the maximum possible value of the expected value of this sum.
Constraints
* 1 ≤ K ≤ N ≤ 200000
* 1 ≤ p_i ≤ 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
p_1 ... p_N
Output
Print the maximum possible value of the expected value of the sum of the numbers shown.
Your output will be considered correct when its absolute or relative error from our answer is at most 10^{-6}.
Examples
Input
5 3
1 2 2 4 5
Output
7.000000000000
Input
4 1
6 6 6 6
Output
3.500000000000
Input
10 4
17 13 13 12 15 20 10 13 17 11
Output
32.000000000000
|
n, k = map(int, input().split())
p = list(map(int, input().split()))
s = sum(p[:k])
m = s
for i in range(1, n-k+1):
s = s-p[i-1]+p[i+k-1]
if s > m:
m = s
print((m+k)/2)
|
Takahashi is going to set a 3-character password.
How many possible passwords are there if each of its characters must be a digit between 1 and N (inclusive)?
Constraints
* 1 \leq N \leq 9
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of possible passwords.
Examples
Input
2
Output
8
Input
1
Output
1
|
#include<bits/stdc++.h>
using namespace std;
int a;
int main()
{
cin>>a;
cout<<a*a*a;
}
|
The beauty of a sequence a of length n is defined as a_1 \oplus \cdots \oplus a_n, where \oplus denotes the bitwise exclusive or (XOR).
You are given a sequence A of length N. Snuke will insert zero or more partitions in A to divide it into some number of non-empty contiguous subsequences.
There are 2^{N-1} possible ways to insert partitions. How many of them divide A into sequences whose beauties are all equal? Find this count modulo 10^{9}+7.
Constraints
* All values in input are integers.
* 1 \leq N \leq 5 \times 10^5
* 0 \leq A_i < 2^{20}
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \ldots A_{N}
Output
Print the answer.
Examples
Input
3
1 2 3
Output
3
Input
3
1 2 2
Output
1
Input
32
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Output
147483634
Input
24
1 2 5 3 3 6 1 1 8 8 0 3 3 4 6 6 4 0 7 2 5 4 6 2
Output
292
|
import java.util.*;
public class Main {
public static void main(String[] args) {
long MOD = (long)Math.pow(10, 9) + 7;
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[n];
for(int i = 0; i < n; i++) {
a[i] = sc.nextInt();
}
int[] b = new int[n + 1];
b[0] = 0;
for(int i = 0; i < n; i++) {
b[i + 1] = b[i] ^ a[i];
}
long ans = 0;
if(b[n] != 0) {
int p = b[n];
long[] dp1 = new long[n + 1];
long[] dp2 = new long[n + 1];
dp1[0] = 1;
dp2[0] = 0;
for(int i = 1; i < n + 1; i++) {
if(b[i] == 0) {
dp1[i] = (dp1[i - 1] + dp2[i - 1]) % MOD;
} else {
dp1[i] = dp1[i - 1];
}
if(b[i] == p) {
dp2[i] = (dp2[i - 1] + dp1[i - 1]) % MOD;
} else {
dp2[i] = dp2[i - 1];
}
}
ans = (dp2[n] - dp2[n - 1] + MOD) % MOD;
} else {
long kosuu = 0;
long[] q = new long[n + 1];
q[0] = 1;
for(int i = 1; i < n + 1; i++) {
if(b[i] == 0) {
q[i] = q[i - 1] + 1;
} else {
q[i] = q[i - 1];
}
}
kosuu = q[n - 1] - q[0];
long t = 1;
for(long i = 0; i < kosuu; i++) {
t = (t * 2) % MOD;
}
ans = t;
HashMap<Integer, ArrayList<Integer>> map = new HashMap<Integer, ArrayList<Integer>>();
for(int i = 1; i < n; i++) {
if(b[i] != 0) {
if(map.containsKey(b[i])) {
ArrayList<Integer> list = map.get(b[i]);
list.add(i);
map.put(b[i], list);
} else {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(i);
map.put(b[i], list);
}
}
}
for(int p : map.keySet()) {
ArrayList<Integer> list = map.get(p);
int x = list.size();
long[] dp1 = new long[x];
long[] dp2 = new long[x];
dp1[0] = 1;
dp2[0] = 1;
for(int i = 1; i < x; i++) {
int k = list.get(i);
int s = list.get(i - 1);
long w = q[k] - q[s];
long m = (dp1[i - 1] * w) % MOD;
dp1[i] = (dp1[i - 1] + m + dp2[i - 1]) % MOD;
dp2[i] = (m + dp2[i - 1]) % MOD;
}
ans = (ans + dp1[x - 1]) % MOD;
}
}
System.out.println(ans);
}
}
|
You are given an integer N that has exactly four digits in base ten. How many times does `2` occur in the base-ten representation of N?
Constraints
* 1000 \leq N \leq 9999
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
1222
Output
3
Input
3456
Output
0
Input
9592
Output
1
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s;
cin>>s;
int cnt = 0;
for(int i=0;i<s.length();i++){
if(s[i]=='2'){
cnt++;
}
}
cout<<cnt;
}
|
There are N people standing in a row from west to east. Each person is facing east or west. The directions of the people is given as a string S of length N. The i-th person from the west is facing east if S_i = `E`, and west if S_i = `W`.
You will appoint one of the N people as the leader, then command the rest of them to face in the direction of the leader. Here, we do not care which direction the leader is facing.
The people in the row hate to change their directions, so you would like to select the leader so that the number of people who have to change their directions is minimized. Find the minimum number of people who have to change their directions.
Constraints
* 2 \leq N \leq 3 \times 10^5
* |S| = N
* S_i is `E` or `W`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the minimum number of people who have to change their directions.
Examples
Input
5
WEEWW
Output
1
Input
12
WEWEWEEEWWWE
Output
4
Input
8
WWWWWEEE
Output
3
|
N = input()
s = input()
#累積和 前処理 Eの数を集計
count = s.count('E')
ans = count
#左端1番目からリーダーをずらしながらチェック。
for ch in s:
if ch == 'E':
count -= 1
ans = min(count,ans)
else:
count += 1
print(ans)
|
An integer X is called a Harshad number if X is divisible by f(X), where f(X) is the sum of the digits in X when written in base 10.
Given an integer N, determine whether it is a Harshad number.
Constraints
* 1?N?10^8
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print `Yes` if N is a Harshad number; print `No` otherwise.
Examples
Input
12
Output
Yes
Input
57
Output
No
Input
148
Output
No
|
#2019/09/26
N = input()
print("Yes" if int(N) % sum(map(int, N)) == 0 else "No")
|
Fennec and Snuke are playing a board game.
On the board, there are N cells numbered 1 through N, and N-1 roads, each connecting two cells. Cell a_i is adjacent to Cell b_i through the i-th road. Every cell can be reached from every other cell by repeatedly traveling to an adjacent cell. In terms of graph theory, the graph formed by the cells and the roads is a tree.
Initially, Cell 1 is painted black, and Cell N is painted white. The other cells are not yet colored. Fennec (who goes first) and Snuke (who goes second) alternately paint an uncolored cell. More specifically, each player performs the following action in her/his turn:
* Fennec: selects an uncolored cell that is adjacent to a black cell, and paints it black.
* Snuke: selects an uncolored cell that is adjacent to a white cell, and paints it white.
A player loses when she/he cannot paint a cell. Determine the winner of the game when Fennec and Snuke play optimally.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq a_i, b_i \leq N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If Fennec wins, print `Fennec`; if Snuke wins, print `Snuke`.
Examples
Input
7
3 6
1 2
3 1
7 4
5 7
1 4
Output
Fennec
Input
4
1 4
4 2
2 3
Output
Snuke
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
vector<int> mp[maxn];
int n, sz[maxn], dep[maxn], fa[maxn];
int dfs(int u, int f, int d){
dep[u] = d;
fa[u] = f;
sz[u] = 1;
for(auto &v:mp[u])if(v != f){
int ret = dfs(v, u, d + 1);
sz[u] += ret;
}
return sz[u];
}
int main(){
ios::sync_with_stdio(false);
cin >> n;
for(int i = 1; i < n; ++i){
int a, b;
cin >> a >> b;
mp[a].push_back(b);
mp[b].push_back(a);
}
dfs(1, 0, 1);
int sum = 0, len = dep[n] / 2;
for(int i = 1, p = n; i <= len; ++i){
sum = sz[p];
p = fa[p];
}
if(sum >= n - sum)
cout << "Snuke" << endl;
else
cout << "Fennec" << endl;
return 0;
}
|
Snuke has decided to play a game using cards. He has a deck consisting of N cards. On the i-th card from the top, an integer A_i is written.
He will perform the operation described below zero or more times, so that the values written on the remaining cards will be pairwise distinct. Find the maximum possible number of remaining cards. Here, N is odd, which guarantees that at least one card can be kept.
Operation: Take out three arbitrary cards from the deck. Among those three cards, eat two: one with the largest value, and another with the smallest value. Then, return the remaining one card to the deck.
Constraints
* 3 ≦ N ≦ 10^{5}
* N is odd.
* 1 ≦ A_i ≦ 10^{5}
* A_i is an integer.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 A_3 ... A_{N}
Output
Print the answer.
Examples
Input
5
1 2 1 3 7
Output
3
Input
15
1 3 5 2 1 3 2 8 8 6 2 6 11 1 1
Output
7
|
N = int(input())
A_arr = [int(x) for x in input().split()]
A_set = set(A_arr)
ans = len(A_set)
if ans%2 == 0:
ans -= 1
print(ans)
|
Two circles A, B are given on a two-dimensional plane. The coordinate of the center and radius of circle A is (x_A, y_A) and r_A respectively. The coordinate of the center and radius of circle B is (x_B, y_B) and r_B respectively. These two circles have no intersection inside. Here, we consider a set of circles S that satisfies the following conditions.
* Each circle in S touches both A and B, and does not have common points with them inside the circle.
* Any two different circles in S have no common points inside them.
Write a program that finds the maximum number of elements in S.
Constraints
* 1 \leq T \leq 50000
* -10^5 \leq x_A \leq 10^5
* -10^5 \leq y_A \leq 10^5
* -10^5 \leq x_B \leq 10^5
* -10^5 \leq y_B \leq 10^5
* 1 \leq r_A \leq 10^5
* 1 \leq r_B \leq 10^5
* {r_A}^2 + {r_B}^2 < (x_A - x_B)^2 + (y_A - y_B)^2
* All values given as input are integers.
* It is guaranteed that, when the radiuses of A and B change by 0.0005, the answer does not change.
Input
The input consists of multiple test cases and is given from Standard Input in the following format:
T
testcase_1
:
testcase_T
Each test case is given with the following format.
x_A y_A r_A x_B y_B r_B
Output
The output consists of T lines. On line i (1 \leq i \leq T), putput the maximum number of elements in S in i-th test case.
Example
Input
4
0 -3 2 0 3 2
0 0 9 8 8 2
0 0 9 10 10 5
0 0 707 1000 1000 707
Output
3
10
21
180
|
#include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x,to) for(x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
//-------------------------------------------------------
int T;
double XA,YA,RA;
double XB,YB,RB;
void solve() {
int i,j,k,l,r,x,y; string s;
cin>>T;
while(T--) {
cin>>XA>>YA>>RA;
cin>>XB>>YB>>RB;
double D=hypot(XA-XB,YA-YB);
double X=0.5/RA;
double r1=X-1/(RA+D-RB);
double r2=X-1/(RA+D+RB);
//_P("X:%.12lf %.12lf %.12lf\n",X,r1,r2);
double a = 3;
double b = -2*(r1+r2);
double c = r1*r2;
double d =b*b-4*a*c;
double x = sqrt(c);
double r3 = 0.5/x;
double r4 = 0.5/(x-r1);
double r5 = 0.5/(x-r2);
double r6 = abs(r5-r4);
//_P("%.12lf %.12lf\n",r3,r6);
double dif=(r6-r3)/2;
double at = asin(dif/(r3+dif));
_P("%d\n",(int)(atan(1)*4/at));
}
}
int main(int argc,char** argv){
string s;int i;
if(argc==1) ios::sync_with_stdio(false), cin.tie(0);
FOR(i,argc-1) s+=argv[i+1],s+='\n';
FOR(i,s.size()) ungetc(s[s.size()-1-i],stdin);
solve(); return 0;
}
|
Create a program that outputs the surface area S of a square cone with a height of h, with a square with one side x as the base. However, assume that the line segment connecting the apex and the center of the base is orthogonal to the base. Also, x and h are positive integers less than or equal to 100.
Input
Given multiple datasets. Each dataset is given in the following format:
x
h
When both x and h are 0, it indicates the end of input.
Output
Output S (real number) on one line for each data set. The output may contain an error of 0.00001 or less.
Example
Input
6
4
7
9
0
0
Output
96.000000
184.192455
|
#include <iostream>
#include <cmath>
#include <cstdio>
using namespace std;
int main() {
int x, h;
while (cin >> x >> h) {
if (x == 0 && h == 0) break;
printf("%.6lf\n", x * x + hypot(x / 2.0, h) * x * 2.0);
}
}
|
I decided to play rock-paper-scissors with a group of five good friends. Rock-paper-scissors has three hands: goo, choki, and par. If the game between goo and choki is a match between goo and choki, goo is "winning" and choki is "losing". , Par and Goo have the rule that Par is "winning" and Goo is "losing". If everyone has the same hand, or if all of Goo, Choki, and Par come out, it will be "Aiko".
Create a program that inputs the hands of five rock-paper-scissors players and outputs the wins and losses of each person. Rock-paper-scissors hands are represented by the numbers 1 for goo, 2 for choki, and 3 for par. Win / loss is represented by a number of 1, "win" is 1, "los" is 2, and "Aiko" is 3, and they are output according to the input order.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
h1
h2
h3
h4
h5
The i-th line is given the i-th hand hi (1, 2 or 3).
The number of datasets does not exceed 200.
Output
Outputs the wins and losses of 5 players for each input dataset. Output the win / loss (1, 2 or 3) of the i-th person on the i-line.
Example
Input
1
2
3
2
1
1
2
2
2
1
0
Output
3
3
3
3
3
1
2
2
2
1
|
#include<iostream>
using namespace std;
int main(){
int h[5];
int f[4];
while(1){
for(int i=0;i<4;i++) f[i]=0;
for(int i=0;i<5;i++){
cin>>h[i];
if(h[i]==0) break;
f[h[i]]=1;
}
if(h[0]==0) break;
int x[2], cnt=0;
for(int i=1;i<4;i++){
if(f[i]==1)
x[cnt++]=i;
//cout<<i<<" "<<f[i]<<endl;
}
//cout<<" "<<cnt<<" "<<x<<endl;
if(cnt==2){
if(x[0]==1&&x[1]==2){
for(int i=0;i<5;i++){
if(h[i]==1) cout<<1<<endl;
else cout<<2<<endl;
}
}
if(x[0]==1&&x[1]==3){
for(int i=0;i<5;i++){
if(h[i]==1) cout<<2<<endl;
else cout<<1<<endl;
}
}
if(x[0]==2&&x[1]==3){
for(int i=0;i<5;i++){
if(h[i]==2) cout<<1<<endl;
else cout<<2<<endl;
}
}
}else{
for(int i=0;i<5;i++) cout<<3<<endl;
}
}
return 0;
}
|
A project is underway to build a new viewing tower in Bange town called “Bange Hills Tower” whose selling point will be the gorgeous view of the entire main keep of Wakamatsu Castle from top to bottom. Therefore, the view line from the top of the tower must reach the bottom of the keep without being hindered by any of the buildings in the town.
<image>
Write a program to calculate the minimum tower height required to view the keep in its entirety based on the following information: the planned location of the tower and the heights and locations of existing buildings. Assume all the buildings, including the keep, are vertical lines without horizontal stretch. “view of the entire keep” means that the view line from the tower top can cover the keep from the bottom to the top without intersecting (contacts at the top are exempted) any of the other vertical lines (i.e., buildings).
Input
The input is given in the following format.
N t
x_1 h_1
x_2 h_2
:
x_N h_N
The first line provides the number of existing buildings N (1≤N≤1000) and the planned location of the tower t (2≤t≤105) in integers. Each of the subsequent N lines provides the information of the i-th building: location x_i (1 ≤ x_i < t) and height from the ground h_i (1 ≤ h_i ≤ 100). All position information is one-dimensional along the ground line whose origin coincides with the Keep location. No more than one building is located in the same location (i.e. if i ≠ j, then x_i ≠ x_j).
Output
Output the required height as a real number. No limits on the number of decimal places as long as the error does not exceed ± 10-3.
Example
Input
3 10
6 4
4 2
3 2
Output
6.666667
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
double t;
cin>>n>>t;
double a[n];
for(int i=0;i<n;i++){
double x,h;
cin>>x>>h;
a[i]=h/x;
if(a[i]>=a[0]){
a[0]=a[i];
}
}
printf("%lf", a[0]*t);
return 0;
}
|
You are a craftsman who makes dumplings. Now you are about to skewer the dumplings.
The dumplings are arranged in a square divided into N rows vertically and M columns horizontally. Each square contains one dumpling. Each dumpling has one of the colors red (R), green (G), and white (W). You can take dumplings from three consecutive squares in the left-to-right direction or from top to bottom, and stick exactly three dumplings on one skewer in this order.
Now you want to make as many skewers as possible with red, green and white dumplings stuck in this order. The order of sticking on the skewers must be the same as the order of removal from the squares. Also, you cannot stick more than one skewer on the same dumpling.
How many skewers can you make with dumplings?
Task
Given the color information of the dumplings placed in the square, create a program to find out how many skewers can be made with one red, one green, and one white dumpling stuck in this order.
input
Read the following input from standard input.
* On the first line, the integers N and M are written with a blank as a delimiter.
* On the i-th line (1 \ leq i \ leq N) of the following N lines, a character string of length M consisting of R, G, and W is written. The jth character (1 \ leq j \ leq M) of this character string represents the color of the dumplings of the cells in the i-th line from the top and the j-th column from the left.
output
Output the maximum number of skewers with dumplings on the standard output in one line.
Limits
All input data satisfy the following conditions.
* 1 \ leq N \ leq 3 000.
* 1 \ leq M \ leq 3 000.
Input / output example
Input example 1
3 4
RGWR
GRGG
RGWW
Output example 1
3
By sticking on a skewer as follows, you can make three skewers with dumplings.
* Take out 3 dumplings to the right from the dumplings in the 1st row from the top and the 1st column from the left, and stick them on a skewer in this order.
* Take out 3 dumplings downward from the dumplings in the 1st row from the top and the 4th column from the left, and stick them on a skewer in this order.
* Take out 3 dumplings to the right from the dumplings in the 3rd row from the top and the 1st column from the left, and stick them on a skewer in this order.
Since it is not possible to make more than 4 skewers, 3 is output.
Input example 2
4 4
RGWR
GRRG
WGGW
WWWR
Output example 2
Four
By sticking on a skewer as follows, you can make four skewers with dumplings.
* Take out 3 dumplings to the right from the dumplings in the 1st row from the top and the 1st column from the left, and stick them on a skewer in this order.
* Take out 3 dumplings from the dumplings in the 1st row from the top and the 4th row from the left, and stick them on a skewer in this order.
* Take out 3 dumplings downward from the dumplings in the 2nd row from the top and the 2nd column from the left, and stick them on a skewer in this order.
* Take out 3 dumplings downward from the dumplings in the 2nd row from the top and the 3rd row from the left, and stick them on a skewer in this order.
Since it is not possible to make more than 5 skewers, 4 is output.
Input example 3
5 5
RGRGW
GRRGW
WGGWR
RWRGW
RGWGW
Output example 3
6
Creative Commons License
Information Olympics Japan Committee work "17th Japan Information Olympics (JOI 2017/2018) Final Selection"
Example
Input
3 4
RGWR
GRGG
RGWW
Output
3
|
#include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
char s[5000][5000];
int dp[5000][2][2];
int n,m;
int solve(int x,int y){
memset(dp,0,sizeof(dp));
for(int i=y;i<m;i++){
int j=x-(i-y);
if(j<0)break;
rep(k,2)rep(l,2){
if(j+2<n&&s[j][i]=='R'&&s[j+1][i]=='G'&&s[j+2][i]=='W'&&!k&&!l){
dp[i+1][0][0]=max(dp[i+1][0][0],dp[i][k][l]+1);
}
if(i+2<m&&s[j][i]=='R'&&s[j][i+1]=='G'&&s[j][i+2]=='W'){
dp[i+1][l][1]=max(dp[i+1][l][1],dp[i][k][l]+1);
}
dp[i+1][l][0]=max(dp[i+1][l][0],dp[i][k][l]);
}
}
int Max=0;
rep(i,m+1)rep(j,2)rep(k,2)Max=max(Max,dp[i][j][k]);
return Max;
}
int main(){
scanf("%d%d",&n,&m);
rep(i,n)scanf("%s",s[i]);
int ans=0;
rep(i,n-1)ans+=solve(i,0);
rep(i,m)ans+=solve(n-1,i);
cout<<ans<<endl;
}
|
Once upon a time, there was a traveler.
He plans to travel using stagecoaches (horse wagons). His starting point and destination are fixed, but he cannot determine his route. Your job in this problem is to write a program which determines the route for him.
There are several cities in the country, and a road network connecting them. If there is a road between two cities, one can travel by a stagecoach from one of them to the other. A coach ticket is needed for a coach ride. The number of horses is specified in each of the tickets. Of course, with more horses, the coach runs faster.
At the starting point, the traveler has a number of coach tickets. By considering these tickets and the information on the road network, you should find the best possible route that takes him to the destination in the shortest time. The usage of coach tickets should be taken into account.
The following conditions are assumed.
* A coach ride takes the traveler from one city to another directly connected by a road. In other words, on each arrival to a city, he must change the coach.
* Only one ticket can be used for a coach ride between two cities directly connected by a road.
* Each ticket can be used only once.
* The time needed for a coach ride is the distance between two cities divided by the number of horses.
* The time needed for the coach change should be ignored.
Input
The input consists of multiple datasets, each in the following format. The last dataset is followed by a line containing five zeros (separated by a space).
> n m p a b
> t1 t2 ... tn
> x1 y1 z1
> x2 y2 z2
> ...
> xp yp zp
>
Every input item in a dataset is a non-negative integer. If a line contains two or more input items, they are separated by a space.
n is the number of coach tickets. You can assume that the number of tickets is between 1 and 8. m is the number of cities in the network. You can assume that the number of cities is between 2 and 30. p is the number of roads between cities, which may be zero.
a is the city index of the starting city. b is the city index of the destination city. a is not equal to b. You can assume that all city indices in a dataset (including the above two) are between 1 and m.
The second line of a dataset gives the details of coach tickets. ti is the number of horses specified in the i-th coach ticket (1<=i<=n). You can assume that the number of horses is between 1 and 10.
The following p lines give the details of roads between cities. The i-th road connects two cities with city indices xi and yi, and has a distance zi (1<=i<=p). You can assume that the distance is between 1 and 100.
No two roads connect the same pair of cities. A road never connects a city with itself. Each road can be traveled in both directions.
Output
For each dataset in the input, one line should be output as specified below. An output line should not contain extra characters such as spaces.
If the traveler can reach the destination, the time needed for the best route (a route with the shortest time) should be printed. The answer should not have an error greater than 0.001. You may output any number of digits after the decimal point, provided that the above accuracy condition is satisfied.
If the traveler cannot reach the destination, the string "`Impossible`" should be printed. One cannot reach the destination either when there are no routes leading to the destination, or when the number of tickets is not sufficient. Note that the first letter of "`Impossible`" is in uppercase, while the other letters are in lowercase.
Example
Input
3 4 3 1 4
3 1 2
1 2 10
2 3 30
3 4 20
2 4 4 2 1
3 1
2 3 3
1 3 3
4 1 2
4 2 5
2 4 3 4 1
5 5
1 2 10
2 3 10
3 4 10
1 2 0 1 2
1
8 5 10 1 5
2 7 1 8 4 5 6 3
1 2 5
2 3 4
3 4 7
4 5 3
1 3 25
2 4 23
3 5 22
1 4 45
2 5 51
1 5 99
0 0 0 0 0
Output
30.000
3.667
Impossible
Impossible
2.856
|
#include <cstdio>
#include <vector>
using namespace std;
#define INF 2000000000
#define pb push_back
int N,M,P,a,b;
int t[10];
struct edge
{
int to;
double cost;
edge(int to,double cost):to(to),cost(cost){}
};
vector<edge> g[40];
double dp[40][1<<8];
double rec(int v,int bit)
{
if(dp[v][bit]!=-1)return dp[v][bit];
double res = INF;
for(int i=0;i<g[v].size();i++)
{
int u = g[v][i].to;
double cost = g[v][i].cost;
for(int j=0;j<N;j++)
{
if(!((bit>>j)&1))
{
res=min(res,rec(u,bit|(1<<j))+cost/t[j]);
}
}
}
return dp[v][bit]=res;
}
int main()
{
while(1)
{
for(int i=0;i<40;i++)g[i].clear();
scanf("%d %d %d %d %d",&N,&M,&P,&a,&b);
if(N==0&&M==0&&P==0&&a==0&&b==0)break;
a--;b--;
for(int i=0;i<N;i++)scanf("%d",&t[i]);
for(int i=0;i<P;i++)
{
int x,y;
double z;
scanf("%d %d %lf",&x,&y,&z);
x--;y--;
g[x].pb(edge(y,z));
g[y].pb(edge(x,z));
}
for(int i=0;i<M;i++)for(int j=0;j<(1<<N);j++)dp[i][j]=-1;
dp[a][(1<<N)-1]=0;
double ans = INF;
for(int i=0;i<(1<<N);i++)ans = min(ans,rec(b,i));
if(ans == INF)printf("Impossible\n");
else printf("%f\n",ans);
}
return 0;
}
|
Given an undirected weighted graph G, you should find one of spanning trees specified as follows.
The graph G is an ordered pair (V, E), where V is a set of vertices {v1, v2, ... , vn} and E is a set of undirected edges {e1, e2, ... , em}. Each edge e ∈ E has its weight w(e).
A spanning tree T is a tree (a connected subgraph without cycles) which connects all the n vertices with n - 1 edges. The slimness of a spanning tree T is defined as the difference between the largest weight and the smallest weight among the n - 1 edges of T.
<image>
Figure 5: A graph G and the weights of the edges
For example, a graph G in Figure 5(a) has four vertices {v1, v2, v3, v4} and five undirected edges {e1, e2, e3, e4, e5}. The weights of the edges are w(e1) = 3, w(e2) = 5, w(e3) = 6, w(e4) = 6, w(e5) = 7 as shown in Figure 5(b).
<image>
Figure 6: Examples of the spanning trees of G
There are several spanning trees for G. Four of them are depicted in Figure 6(a)-(d). The spanning tree Ta in Figure 6(a) has three edges whose weights are 3, 6 and 7. The largest weight is 7 and the smallest weight is 3 so that the slimness of the tree Ta is 4. The slimnesses of spanning trees Tb , Tc and Td shown in Figure 6(b), (c) and (d) are 3, 2 and 1, respectively. You can easily see the slimness of any other spanning tree is greater than or equal to 1, thus the spanning tree Td in Figure 6(d) is one of the slimmest spanning trees whose slimness is 1.
Your job is to write a program that computes the smallest slimness.
Input
The input consists of multiple datasets, followed by a line containing two zeros separated by a space. Each dataset has the following format.
n m
a1 b1 w1
.
.
.
am bm wm
Every input item in a dataset is a non-negative integer. Items in a line are separated by a space.
n is the number of the vertices and m the number of the edges. You can assume 2 ≤ n ≤ 100 and 0 ≤ m ≤ n(n - 1)/2. ak and bk (k = 1, ... , m) are positive integers less than or equal to n, which represent the two vertices vak and vbk connected by the kth edge ek. wk is a positive integer less than or equal to 10000, which indicates the weight of ek . You can assume that the graph G = (V, E) is simple, that is, there are no self-loops (that connect the same vertex) nor parallel edges (that are two or more edges whose both ends are the same two vertices).
Output
For each dataset, if the graph has spanning trees, the smallest slimness among them should be printed. Otherwise, -1 should be printed. An output should not contain extra characters.
Example
Input
4 5
1 2 3
1 3 5
1 4 6
2 4 6
3 4 7
4 6
1 2 10
1 3 100
1 4 90
2 3 20
2 4 80
3 4 40
2 1
1 2 1
3 0
3 1
1 2 1
3 3
1 2 2
2 3 5
1 3 6
5 10
1 2 110
1 3 120
1 4 130
1 5 120
2 3 110
2 4 120
2 5 130
3 4 120
3 5 110
4 5 120
5 10
1 2 9384
1 3 887
1 4 2778
1 5 6916
2 3 7794
2 4 8336
2 5 5387
3 4 493
3 5 6650
4 5 1422
5 8
1 2 1
2 3 100
3 4 100
4 5 100
1 5 50
2 5 50
3 5 50
4 1 150
0 0
Output
1
20
0
-1
-1
1
0
1686
50
|
#include <bits/stdc++.h>
#define rep(i, a, n) for(int i = a; i < n; i++)
#define REP(i, n) rep(i, 0, n)
#define repb(i, a, b) for(int i = a; i >= b; i--)
#define all(a) a.begin(), a.end()
#define int long long
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef pair<int, int> P;
const int mod = 1000000007;
const int INF = 1e12;
int n, m;
struct edge{
int from, to, cost;
};
bool cmp(const edge& e1, const edge& e2){
// if(p1.first == p2.first) return p1.second > p2.second;
return e1.cost < e2.cost;
}
struct UF{
vector<int> par;
vector<int> sz;
UF(){}
UF(int n){
par.resize(n);
sz.resize(n, 1);
rep(i, 0, n) par[i] = i;
}
int find(int x){
if(x == par[x]) return x;
return par[x] = find(par[x]);
}
void unite(int x, int y){
x = find(x); y = find(y);
if(x == y) return;
if(sz[x] < sz[y]) swap(x, y);
sz[x] += sz[y];
par[y] = x;
}
bool same(int x, int y){
return find(x) == find(y);
}
};
signed main(){
ios::sync_with_stdio(false);
cin.tie(0);
while(cin >> n >> m){
if(n == 0 && m == 0) break;
vector<edge> es;
rep(i, 0, m){
int s, t, c;
cin >> s >> t >> c;
s--; t--;
es.push_back((edge){s, t, c});
}
sort(all(es), cmp);
int ans = INF;
rep(i, 0, m){
int MAX = -1;
UF uf(n);
rep(j, i, m){
int s = es[j].from;
int t = es[j].to;
if(uf.same(s, t) == false){
uf.unite(s, t);
chmax(MAX, es[j].cost);
}
}
// cout << i << " " << es[i].cost << " " << MAX << endl;
rep(j, 0, n){
if(uf.same(0, j) == false) MAX = -1;
}
if(MAX != -1){
// cout << i << " " << es[i].cost << " " << MAX << endl;
chmin(ans, MAX - es[i].cost);
}
}
if(ans == INF) cout << -1 << endl;
else cout << ans << endl;
}
}
|
At University A, there were many mistakes in entering IDs.
Therefore, University A decided to issue a new ID to prevent typos.
There is a way to check if the new ID is correct to prevent typos.
・ Calculate the sum of all digits.
・ However, the number of even-numbered digits is doubled, with the rightmost digit as the first digit.
-When the number becomes 10 or more by doubling, the number obtained by adding the 1st digit and the 10th digit is used as the digit number.
・ If the sum is divisible by 10, the ID is correct, otherwise it is incorrect.
As an example, check the ID 53579.
Since the sum of all digits is calculated,
5 + 3 + 5 + 7 + 9
However, since the number of even-numbered digits is doubled,
5 + 6 + 5 + 14 + 9
When the number becomes 10 or more by doubling, the number obtained by adding the ones digit and the tens digit is the digit number.
5 + 6 + 5 + (1 + 4) + 9
From the above, the total sum is 30. Since 30 is divisible by 10, 53579 is the correct ID.
Mr. B is a college student at University A and was issued a new ID, but he forgot some digits of the ID.
However, I succeeded in narrowing down some candidates as to what kind of numbers will be included in the forgotten part.
Your job is to find out how many correct combinations of B's IDs are available.
Input
The input is given in the following format.
n
ID
m
a0 a1 ... am-1
n is the number of digits in the ID.
Each digit of the ID contains a number from 0 to 9 or the letter'*' to indicate that it is a forgotten digit.
m is the number of candidate numbers in the'*'.
ai is a candidate for numbers in'*'.
Input meets the following constraints
1 ≤ n ≤ 100,000
1 ≤ m ≤ 10
0 ≤ ai ≤ 9
Number of 1 ≤'*' ≤ 7
Output
Output the answer value on one line
Examples
Input
5
5*57*
2
3 9
Output
1
Input
15
2***9*2*6*1199*
9
0 1 2 3 4 6 7 8 9
Output
478297
|
#include <stdio.h>
#include <vector>
using namespace std;
#define PB push_back
const int N=1e5+10;
int two(int n){
n<<=1;
return n/10+n%10;
}
int main(){
int a[10][2],n,m,temp;
bool f=true,mul;
vector<int> v;
char c[N];
scanf("%d",&n);
scanf("%s",c);
scanf("%d",&m);
while(m--){
scanf("%d",&temp);
v.PB(temp);
}
for(int i=0;i<10;i++)a[i][0]=a[i][1]=0;
a[0][!f]=1;
mul=!(n&1);
for(int i=0;i<n;i++){
if(c[i]=='*'){
for(int j=0;j<10;j++)a[j][f]=0;
for(int j:v){
temp=j;
if(mul)temp=two(temp);
for(int k=0;k<10;k++)a[k][f]+=a[(k+10-temp)%10][!f];
}
}
else{
temp=c[i]-'0';
if(mul)temp=two(temp);
for(int j=0;j<10;j++)a[j][f]=a[(j+10-temp)%10][!f];
}
f=!f;
mul=!mul;
}
printf("%d\n",a[0][!f]);
}
|
<!--
Problem F
-->
Flipping Colors
You are given an undirected complete graph. Every pair of the nodes in the graph is connected by an edge, colored either red or black. Each edge is associated with an integer value called penalty.
By repeating certain operations on the given graph, a "spanning tree" should be formed with only the red edges. That is, the number of red edges should be made exactly one less than the number of nodes, and all the nodes should be made connected only via red edges, directly or indirectly. If two or more such trees can be formed, one with the least sum of penalties of red edges should be chosen.
In a single operation step, you choose one of the nodes and flip the colors of all the edges connected to it: Red ones will turn to black, and black ones to red.
<image> Fig. F-1 The first dataset of Sample Input and its solution
For example, the leftmost graph of Fig. F-1 illustrates the first dataset of Sample Input. By flipping the colors of all the edges connected to the node 3, and then flipping all the edges connected to the node 2, you can form a spanning tree made of red edges as shown in the rightmost graph of the figure.
Input
The input consists of multiple datasets, each in the following format.
> n
> e1,2 e1,3 ... e1,n-1 e1,n
> e2,3 e2,4 ... e2,n
> ...
> en-1,n
The integer n (2 ≤ n ≤ 300) is the number of nodes. The nodes are numbered from 1 to n. The integer ei,k (1 ≤ |ei,k| ≤ 105) denotes the penalty and the initial color of the edge between the node i and the node k. Its absolute value |ei,k| represents the penalty of the edge. ei,k > 0 means that the edge is initially red, and ei,k < 0 means it is black.
The end of the input is indicated by a line containing a zero. The number of datasets does not exceed 50.
Output
For each dataset, print the sum of edge penalties of the red spanning tree with the least sum of edge penalties obtained by the above-described operations. If a red spanning tree can never be made by such operations, print `-1`.
Sample Input
4
3 3 1
2 6
-4
3
1 -10
100
5
-2 -2 -2 -2
-1 -1 -1
-1 -1
1
4
-4 7 6
2 3
-1
0
Output for the Sample Input
7
11
-1
9
Example
Input
4
3 3 1
2 6
-4
3
1 -10
100
5
-2 -2 -2 -2
-1 -1 -1
-1 -1
1
4
-4 7 6
2 3
-1
0
Output
7
11
-1
9
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i,n) for(int i=0,_n=(int)(n);i<_n;++i)
#define ALL(v) (v).begin(),(v).end()
#define CLR(t,v) memset(t,(v),sizeof(t))
template<class T1,class T2>ostream& operator<<(ostream& os,const pair<T1,T2>&a){return os<<"("<<a.first<<","<<a.second<< ")";}
template<class T>void pv(T a,T b){for(T i=a;i!=b;++i)cout<<(*i)<<" ";cout<<endl;}
template<class T>void chmin(T&a,const T&b){if(a>b)a=b;}
template<class T>void chmax(T&a,const T&b){if(a<b)a=b;}
int nextInt() { int x; scanf("%d", &x); return x;}
ll nextLong() { ll x; scanf("%lld", &x); return x;}
const int MAX_N = 305;
vector<int> g[MAX_N];
int e[MAX_N][MAX_N];
int flip[MAX_N];
bool vis[MAX_N];
int ans = 1001001001;
int dfs(int N, int b, int cur, int prev, int &cost) {
if (cost > ans) { throw -1; }
if (vis[cur]) { throw -1; }
vis[cur] = true;
int res = 1;
if (cur == b) {
REP(nxt, N) if (nxt != prev && e[cur][nxt] * flip[cur] * flip[nxt] > 0) {
cost += abs(e[cur][nxt]);
res += dfs(N, b, nxt, cur, cost);
}
} else {
{
int nxt = b;
if (nxt != prev && e[cur][nxt] * flip[cur] * flip[nxt] > 0) {
cost += abs(e[cur][nxt]);
res += dfs(N, b, nxt, cur, cost);
}
}
for(int nxt : g[cur]) if (nxt != prev && nxt != b && e[cur][nxt] * flip[cur] * flip[nxt] > 0) {
cost += abs(e[cur][nxt]);
res += dfs(N, b, nxt, cur, cost);
}
}
return res;
}
int main2(int N) {
CLR(e, 0);
ans = 1001001001;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
e[i][j] = e[j][i] = nextInt();
}
}
for (int a = 0; a < N; a++) {
REP(i, N) g[i].clear();
REP(i, N) flip[i] = 1;
// a の周りの辺を全て消す
for (int x = 0; x < N; x++) if (x != a) {
if (e[a][x] > 0) { flip[x] = -1; }
}
// この状態で g を作成
REP(i, N) {
vector<int> v;
REP(j, N) if (e[i][j] * flip[i] * flip[j] > 0) v.push_back(j);
g[i] = v;
}
for (int b = 0; b < N; b++) if (a != b) {
// a が葉, b が a に唯一接続している頂点
flip[b] *= -1;
try {
CLR(vis, 0);
int cost = 0;
int c = dfs(N, b, 0, -1, cost);
if (c == N) {
if (ans > cost) {
ans = cost;
}
}
} catch (int e) {}
flip[b] *= -1;
}
}
if (ans == 1001001001)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
int main() {
for (;;) {
int N = nextInt();
if (N == 0) break;
main2(N);
}
return 0;
}
|
In the Bitwise Kingdom, located somewhere in the universe, there are exactly 2N citizens living and each of them has a unique identification string that represents his or her class in the society. An identification string is a binary string of length N which consists of characters ‘0’ or ‘1’. The order of classes is defined among the citizens by the following criteria:
1. Citizens identified by a string containing a greater number of ones are ranked higher. For example, “011” indicates a higher class than “100”.
2. Among those who have identification strings with the same number of ones, citizens identified by a lexicographically greater identification string are ranked higher. For example, “110” indicates a higher class than “101”.
For example, if N = 3, there are 8 (= 23) people in the country, and their identification strings are “000”, “001”, “010”, “100”, “011”, “101”, “110”, and “111” (from the lowest class to the highest).
You are given two numbers N (1 ≤ N ≤ 60) and M (1 ≤ M ≤ 2N), and you want to resolve the identification string of the person of the M-th lowest class among 2N citizens. Can you write a program to solve this problem?
Input
The input consists of multiple datasets.
Each dataset consists of a line which contains two integers N and M in this order, separated with a single space. The input does not contain any other extra characters such as leading or trailing spaces.
The end of input is indicated by a line with two zeros. This line is not part of any datasets.
Output
For each dataset, print the identification string of the person of the M-th lowest class in one line. Your program may not omit any leading zeros in the answer.
Example
Input
3 3
3 5
0 0
Output
010
011
|
#include <string>
#include <vector>
#include <cstring>
#include <iostream>
#include <queue>
#include <map>
#include <set>
#include <algorithm>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <bitset>
#define vi vector < int >
#define mod 1000000007
#define inf 987654321
#define dinf -inf
#define lo long long int
#define S(n) scanf("%d",&n);
#define SL(n) scanf("%lld",&n);
#define P(n) printf("%d",n);
#define PL(n) printf("%lld",n);
#define spa printf(" ");
#define st(a,v) memset(a, v, sizeof (a))
#define nwl puts("");
using namespace std;
//string tostring(lo v) { ostringstream sout; sout << v; return sout.str(); }
#define two(x) (1ll << x)
#define contain(x, y) ( x & (two(y)))
lo ncr[100][100];
void genncr()
{
int i, j;
ncr[0][0]=1;
int limncr = 80;
for(i = 1; i <= limncr; i++)
for(j = 0; j <= limncr; j++)
{
if(j > i) ncr[i][j] = 0;
else if(j == i || j == 0) ncr[i][j] = 1;
else ncr[i][j] = ncr[i-1][j-1] + ncr[i-1][j];
}
}
string solve (lo n, lo p, lo m) {
if (n==0)
return "";
lo ho = ncr[n-1][p];
if (m >= ho)
return "1" + solve (n - 1, p - 1, m - ho);
return "0" + solve(n- 1, p, m);
}
int main ( ) {
genncr();
while(true) {
lo n, m;
cin >> n >> m;
if(!n&&!m)break;
m--;
string str;
for (int i = 0; i <= n; i++) {
lo k = ncr[n][i];
if (k > m) {
str = solve (n, i, m);
break;
}
m = m - k;
}
cout << str << endl;
}
}
|
ICP city has an express company whose trucks run from the crossing S to the crossing T. The president of the company is feeling upset because all the roads in the city are one-way, and are severely congested. So, he planned to improve the maximum flow (edge disjoint paths) from the crossing S to the crossing T by reversing the traffic direction on some of the roads.
Your task is writing a program to calculate the maximized flow from S to T by reversing some roads, and the list of the reversed roads.
Input
The first line of a data set contains two integers N (2 \leq N \leq 300) and M (0 \leq M \leq {\rm min} (1\,000,\ N(N-1)/2)). N is the number of crossings in the city and M is the number of roads.
The following M lines describe one-way roads in the city. The i-th line (1-based) contains two integers X_i and Y_i (1 \leq X_i, Y_i \leq N, X_i \neq Y_i). X_i is the ID number (1-based) of the starting point of the i-th road and Y_i is that of the terminal point. The last line contains two integers S and T (1 \leq S, T \leq N, S \neq T, 1-based).
The capacity of each road is 1. You can assume that i \neq j implies either X_i \neq X_j or Y_i \neq Y_j, and either X_i \neq Y_j or X_j \neq Y_i.
Output
In the first line, print the maximized flow by reversing some roads. In the second line, print the number R of the reversed roads. In each of the following R lines, print the ID number (1-based) of a reversed road. You may not print the same ID number more than once.
If there are multiple answers which would give us the same flow capacity, you can print any of them.
Examples
Input
2 1
2 1
2 1
Output
1
0
Input
2 1
1 2
2 1
Output
1
1
1
Input
3 3
3 2
1 2
3 1
1 3
Output
2
2
1
3
|
#include <cstdio>
#include <algorithm>
#include <map>
#include <queue>
#define REP(i,n) for(int i=0; i<(int)(n); i++)
#define f first
#define s second
#define mp make_pair
using namespace std;
typedef vector<vector<int> > G;
int flow(G &g, int s, int d){
int n = g.size();
int ans = 0;
while(true){
vector<int> prevs(n,-1);
queue<int> q;
bool ok = false;
prevs[s]=n;
q.push(s);
while(!q.empty()){
int now = q.front();
q.pop();
if(now == d){
ok = true;
break;
}
for(int i=0;i<n;i++){
if(g[now][i]>0){
if(prevs[i]==-1){
prevs[i]=now;
q.push(i);
}
}
}
}
if(!ok) return ans;
int f = 100000;
int pos = d;
while(pos != s){
int pos2 = prevs[pos];
f = min(f,g[pos2][pos]);
pos = pos2;
}
pos = d;
while(pos != s){
int pos2 = prevs[pos];
g[pos2][pos]-=f;
g[pos][pos2]+=f;
pos = pos2;
}
ans += f;
}
}
map<pair<int,int>, int> id;
int main(){
int n, m;
scanf("%d%d", &n, &m);
vector<vector<int> > g(n, vector<int>(n));
REP(i,m){
int a, b;
scanf("%d%d", &a, &b);
g[a-1][b-1] = 1;
g[b-1][a-1] = 1;
id[make_pair(a-1,b-1)] = i;
}
int s, t;
scanf("%d%d", &s, &t);
//REP(i,n){REP(j,n) printf("%2d ", g[i][j]); puts("");}
int ans = flow(g, s-1, t-1);
vector<int> rev;
//REP(i,n){REP(j,n) printf("%2d ", g[i][j]); puts("");}
REP(i,n) REP(j,n) if(g[i][j] == 2){
if(id.count(make_pair(i,j))) rev.push_back(id[make_pair(i,j)] + 1);
}
sort(rev.begin(), rev.end());
printf("%d\n", ans);
printf("%d\n", rev.size());
REP(i,rev.size()) printf("%d\n", rev[i]);
return 0;
}
|
Once upon a time, in a fantasy world far, far away, monsters dug caves and dungeons for adventurers. They put some obstacles in their caves so it becomes more difficult and more exciting for the adventurers to reach the goal.
One day, Emils, one of the monsters in the caves, had a question about the caves. How many patterns of a cave can they make, by changing the locations of the obstacles in it?
Here's the detail of the question. A cave consists of W × H squares. Monsters can put obstacles at some of the squares, so that adventurers can't go into them. The total number of obstacles is fixed, and there can't be two or more obstacles in one square. Adventurers enter the cave from the top-left square, and try to reach the bottom-right square. They can move from one square to any of the four adjacent squares, as long as there are no obstacles in the destination square. There must be at least one path between any two squares that don't have obstacles. There must be no obstacles in the top-left square, nor in right-bottom square. The question is, given the width W and height H of the cave, and the number S of obstacles, how many patterns of the caves the monsters can make. As the obstacles have the same look, they should not be distinguished each other.
It was a very interesting mathematical question. Emils couldn't solve this question by himself, so he told it to his colleagues instead. None of them could answer to it, though. After that, the question soon got popular among the monsters working in the caves, and finally, they became unable to sleep well as they always thought about the question.
You are requested to write a program that answers to the question.
Input
The input has a line, containing three integers W, H, and S, separated by a space. W and H are the horizontal and vertical sizes of the cave, and S is the number of obstacles to put in the cave. It is guaranteed that 2 ≤ W, H ≤ 8, and that 0 ≤ S ≤ W × H.
Output
Output the number of patterns of the cave, in a line.
Examples
Input
2 2 2
Output
0
Input
2 2 1
Output
2
|
#include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
string normalize(string s, char c, bool isLeft)
{
if(c != '#'){
if(s[0] != '#')
replace(s.rbegin(), s.rend(), s[0], c);
if(s[s.size()-1] != '#' && !isLeft)
replace(s.begin(), s.end(), s[s.size()-1], c);
}
s += c;
if(s[0] == 'A' && s.find('A', 1) == string::npos)
return "";
s = s.substr(1);
char x = 'A';
map<char, char> m;
m['#'] = '#';
for(unsigned i=0; i<s.size(); ++i){
if(m.find(s[i]) == m.end()){
m[s[i]] = x;
++ x;
}
s[i] = m[s[i]];
}
return s;
}
int main()
{
int w, h, s;
cin >> w >> h >> s;
map<pair<string, int>, long long> dp;
dp[make_pair(string(w, '#'), s)] = 1;
for(int y=0; y<h; ++y){
for(int x=0; x<w; ++x){
map<pair<string, int>, long long> next;
for(map<pair<string, int>, long long>::iterator it=dp.begin(); it!=dp.end(); ++it){
string s = it->first.first;
int wall = it->first.second;
if(wall <= (h-1-y)*w + (w-1-x)){
string t = normalize(s, 'Z', x==0);
if(t != "")
next[make_pair(t, wall)] += it->second;
}
if(wall > 0 && !(y == 0 && x == 0) && !(y == h-1 && x == w-1)){
string t = normalize(s, '#', x==0);
if(t != "")
next[make_pair(t, wall-1)] += it->second;
}
}
dp.swap(next);
}
}
long long ret = 0;
for(map<pair<string, int>, long long>::iterator it=dp.begin(); it!=dp.end(); ++it){
string s = it->first.first;
int wall = it->first.second;
if(s.find('B') == string::npos)
ret += it->second;
}
cout << ret << endl;
return 0;
}
|
Ciel, an idol whose appearance and behavior are similar to a fox, is participating in a rehearsal for the live concert which takes place in a few days. To become a top idol, a large amount of effort is required!
The live stage can be expressed as a two-dimensional surface. The live stage has N spotlights to illuminate the stage. The i-th spotlight casts a light in the range of a circle with radius r_{i}. The center of the light cast by the i-th spotlight moves along an orbital path R_{i}. R_{i} is described as a closed polygon, though R_{i} might contain self-intersections. The spotlight begins to move from the first vertex of R_{i}. All of the orbital period of each spotlight are the same. Each spotlight moves at a constant speed, and all of them return to the starting point at the same time.
In the rehearsal, Ciel has to move from the starting point to the ending point indicated on the live stage. To achieve her goal, it is not allowed to fall out from the area illuminated with the spotlight. But, she doesn't have to be illuminated with the spotlight as long as she is standing on the starting point. You may assume that she can move fast enough. Answer if it is possible for her to move to the ending point.
Input
Each input dataset is given in the following format:
N sx sy ex ey
r_{1} K_{1} x_{11} y_{11} x_{12} y_{12} ... x_{1K_{1}} y_{1K_{1}}
r_{2} K_{2} x_{21} y_{21} x_{22} y_{22} ... x_{2K_{2}} y_{2K_{2}}
:
:
r_{N} K_{N} x_{N1} y_{N1} x_{N2} y_{N2} ... x_{NK_{N}} y_{NK_{N}}
All inputs are integer. All coordinate information satisfies -10,000 \leq x, y \leq 10,000. N (1 \leq N \leq 100) indicates the number of spotlights. (sx, sy) and (ex, ey) indicate the starting point and the ending point of Ciel's path, respectively. The following N lines denote the information of each spotlight. r_{i} (1 \leq r_{i} \leq 100) indicates the radius of the spotlight. K_{i} (2 \leq K_{i} \leq 10) indicates the number of vertices in the orbital path. Then, K_{i} vertices are given. Two consecutive vertices on the same orbital path are located at different places. The spotlight moves from the first point (x_{i1}, y_{i1}) to the second point (x_{i2}, y_{i2}), then moves to the third point (x_{i3}, y_{i3}), and so on. After moving to the K_{i}-th point (x_{iK_{i}}, y_{iK_{i}}), the spotlight returns to the first point (x_{i1}, y_{i1}) and repeats again its movement.
Let d_{ij} be the closest distance between two central points of spotlight i and spotlight j. d_{ij} satisfies either of the following:
* d_{ij} > r_{i} + r_{j} + 0.000001
* d_{ij} < r_{i} + r_{j} - 0.000001
Furthermore, let d_{i} be the closest distance between a central point of spotlight i and either the starting point or the ending point. d_{i} satisfies either of the following:
* d_{i} > r_{i} + 0.000001
* d_{i} < r_{i} - 0.000001
Output
If it is possible for Ciel to move the ending point without falling out from the illuminated area, output `Yes` in one line. Otherwise, output `No`.
Sample Input 1
2 1 1 9 -1
2 2 1 1 -9 1
1 2 -1 -1 9 -1
Output for the Sample Input 1
Yes
Sample Input 2
2 1 1 9 -1
2 2 1 1 -9 1
1 2 9 -1 -1 -1
Output for the Sample Input 2
No
Sample Input 3
2 11 6 -9 1
6 4 10 5 10 0 5 0 5 5
5 4 -10 0 -10 5 -5 5 -5 0
Output for the Sample Input 3
Yes
Sample Input 4
1 1 9999 -1 0
100 2 0 0 0 10000
Output for the Sample Input 4
Yes
Example
Input
2 1 1 9 -1
2 2 1 1 -9 1
1 2 -1 -1 9 -1
Output
Yes
|
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define rep(i,n) repl(i,0,n)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcountll
struct UnionFind{
vector<int> v;
UnionFind(int n) : v(n, -1) {}
void init(){ for(int i = 0;i < (int)v.size();i++)v[i]=-1; }
int find(int x) { return v[x] < 0 ? x : v[x] = find(v[x]); }
bool unite(int x, int y) {
x = find(x); y = find(y);
if (x == y) return false;
if (-v[x] < -v[y]) swap(x, y);
v[x] += v[y]; v[y] = x;
return true;
}
bool root(int x) { return v[x] < 0; }
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return -v[find(x)]; }
};
typedef long double D;
typedef complex<D> P;
#define X real()
#define Y imag()
D dot(P a,P b){ return (conj(a)*b).X; }
const D eps=1e-9;
const D inf=1e12;
const D PI=acos(-1);
struct L : public vector<P> { // line and segment
L(const P& a,const P &b){
push_back(a);
push_back(b);
}
};
int N;
int sx,sy,tx,ty;
D R[110];
int sz[110];
D tot[110];
D st[110][21];
vector<P> cents[110];
int main(){
cin>>N>>sx>>sy>>tx>>ty;
rep(i,N){
cin>>R[i];
cin>>sz[i];
rep(j,sz[i]){
int x,y;
cin>>x>>y;
cents[i].push_back(P(x,y));
}
rep(j,sz[i])tot[i]+=abs(cents[i][j]-cents[i][(j+1)%sz[i]]);
st[i][0]=0;
repl(j,1,sz[i]){
D len=abs(cents[i][j]-cents[i][j-1]);
st[i][j]=st[i][j-1]+(len/tot[i]);
}
}
sz[N]=1; cents[N].push_back(P(sx,sy));
sz[N+1]=1; cents[N+1].push_back(P(tx,ty));
UnionFind uf(N+2);
rep(i,N+2){
rep(j,i){
if(i==N+1&&j==N)continue;
rep(crti,sz[i]){
int nxti=(crti+1)%sz[i];
D ist=st[i][crti],ied=(nxti==0?1.0:st[i][nxti]);
rep(crtj,sz[j]){
int nxtj=(crtj+1)%sz[j];
D jst=st[j][crtj],jed=(nxtj==0?1.0:st[j][nxtj]);
D l=max(ist,jst),r=min(ied,jed);
D ub=pow(R[i]+R[j],2);
if(l>r)continue;
P inidelta=(cents[i][crti]-(ist/(ied-ist))*(cents[i][nxti]-cents[i][crti]))-(cents[j][crtj]-(jst/(jed-jst))*(cents[j][nxtj]-cents[j][crtj]));
P vdelta=((cents[i][nxti]-cents[i][crti])/(ied-ist))-((cents[j][nxtj]-cents[j][crtj])/(jed-jst));
D A=norm(vdelta), B=2.0*dot(inidelta,vdelta), C=norm(inidelta);
if(abs(A)<eps){
if(C<=ub)uf.unite(i,j);
continue;
}
if(A*l*l+B*l+C<=ub||A*r*r+B*r+C<=ub)uf.unite(i,j);
D x=-B/(2.0*A);
if(l<=x&&x<=r&&A*x*x+B*x+C<=ub)uf.unite(i,j);
}
}
}
}
if(uf.same(N,N+1))cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
}
|
F: Exactly --Kitsuchiri -
problem
Chisato Aizu, who is in the second year of Wakagamatsu High School, feels sorry if the sequence is not "tight".
According to Mr. Aizu, a "tight" sequence is a sequence that is even in length and symmetrical. That is, for a sequence S of length N (N is an even number), the sequence S is "exactly" if the following conditions are satisfied.
S_1 = S_N, S_2 = S_ {N − 1}, ..., S_ {N / 2} = S_ {N − N / 2 + 1}
The teacher in charge of mathematics in the second year group was asked by Mr. Aizu to "please be precise" and had to recreate the sequence used in the class.
The teacher is struggling to make the sequence "tight" by applying a number of queries that add the number x to each of the l-th to r-th elements of the sequence, but it doesn't seem to work.
Your job as a brilliant programmer in the second year group is to create a program that checks if the sequence that the teacher is recreating is "tight" before the teacher despairs.
Input format
The input consists of the following format.
N
S_1 ... S_N
Q
q_1_1
...
q_Q
Q is the total number of queries, and for 1 \ ≤ i \ ≤ Q, each q_i gives l, r, and x in order, separated by a single space.
It also satisfies the following constraints.
* 2 \ ≤ N \ ≤ 500,000.
* N is an even number.
* 1 For \ ≤ j \ ≤ N, -100,000,000 \ ≤ S_j \ ≤ 100,000,000.
* Each element T_ {i, j} in the sequence after applying each i-th query satisfies -100,000,000 \ ≤ T_ {i, j} \ ≤ 100,000,000.
* 1 \ ≤ Q \ ≤ 100,000.
* 1 \ ≤ l \ ≤ r \ ≤ N.
* −1,000 \ ≤ x \ ≤ 1,000.
Output format
Output "1" if the sequence after processing up to query i is "exact", otherwise output "0" to the i-th row.
Input example 1
Ten
0 1 2 3 4 4 3 2 1 0
7
2 6 0
2 4 5
7 9 10
2 4 5
3 8 100
4 6 1000
7 7 1000
Output example 1
1
0
0
1
1
0
1
Input example 2
Ten
4 4 4 4 4 4 4 4 6 4
Five
9 9 -2
1 10 1000
1 10 -1000
3 8 100
5 6 1
Output example 2
1
1
1
1
1
Example
Input
10
0 1 2 3 4 4 3 2 1 0
7
2 6 0
2 4 5
7 9 10
2 4 5
3 8 100
4 6 1000
7 7 1000
Output
1
0
0
1
1
0
1
|
#include<iostream>
#include<vector>
#include<cassert>
#include<string>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<tuple>
#include<numeric>
using namespace std;
typedef pair<int,int> pii;
typedef long long ll;
typedef ll int__;
#define rep(i,j) for(int__ i=0;i<(int__)(j);i++)
#define repeat(i,j,k) for(int__ i=(j);i<(int__)(k);i++)
#define all(v) v.begin(),v.end()
const ll INF = 1LL << 60;
template<typename T>
ostream& operator << (ostream &os , const vector<T> &v){
rep(i,v.size()) os << v[i] << (i!=v.size()-1 ? " " : "\n"); return os;
}
template<typename T>
istream& operator >> (istream &is , vector<T> &v){
rep(i,v.size()) is >> v[i]; return is;
}
#ifdef DEBUG
void debug(){ cerr << endl; }
#endif
template<class F,class...R>
void debug(const F &car,const R&... cdr){
#ifdef DEBUG
cerr << car << " "; debug(cdr...);
#endif
}
#include<functional>
using Index = int;
template<typename Data>
class SegmentTree{
public:
int N;
vector<Data> data;
vector<Data> sum;
function< Data(Data,Data) > selector;
Data default_val;
SegmentTree(int n, function< Data(Data,Data) > selector,Data default_val)
:selector(selector),default_val(default_val){
N = n;
n = 1;
while(n < N) n *= 2;
//data.resize(2 * n - 1, default_val);
data.resize(2 * n - 1, 0);
sum.resize(2 * n - 1, 0);
}
// ??????[a,b) ??? add val
void add(Index a, Index b, Data val){
debug("[", a, b, ") += ", val);
add(a, b, val, 0, 0, N);
}
// [a,b) ????????¨???
Data query(Index a, Index b){
assert( a < b );
assert( 0 <= a and b <= N );
//debug("query [", a, b, ") is", search(a, b, 0, 0, N));
return search(a, b, 0, 0, N);
}
private:
//[a,b)???????°????,k???????????´???,[l,r)????????????????????????
Data search(Index a, Index b, Index k, Index l, Index r){
if( r <= a or b <= l ) return default_val; // ?????????
if( a <= l and r <= b ) return data[k]; // ?????????
else { // ????????????
Index m = (l + r) / 2;
Data vl = search(a, b, k * 2 + 1, l, m);
Data vr = search(a, b, k * 2 + 2, m, r);
debug("search [", a, b, ") is", selector(vl, vr));
return selector(vl, vr) + sum[k];
}
}
//??????[a, b)??????????????????????????????????°?????????????
// k : ???????????????(??¨???)index
// [l, r): k?????????????????????
void add(Index a, Index b, Data x, Index k, Index l, Index r){
if( a <= l and r <= b){
data[k] += x;
sum[k] += x;
} else if(l < b and a < r){ //???????????£???????????????
Index m = (l + r) / 2;
Index lc = k * 2 + 1;
Index rc = k * 2 + 2;
add(a, b, x, lc, l, m);
add(a, b, x, rc, m, r);
data[k] = selector( data[lc], data[rc]) + sum[k];
}
}
};
void debug_out(SegmentTree<ll> &st){
rep(i, st.N){
debug("ST[",i,"] = ", st.query(i,i+1));
}
}
bool solve(){
int N; cin >> N;
N /= 2;
SegmentTree<ll> lminq(N, [](ll a, ll b){ return min(a, b); }, INF);
SegmentTree<ll> lmaxq(N, [](ll a, ll b){ return max(a, b); }, -INF);
rep(i, N*2){
int s; cin >> s;
if(i >= N) s *= -1;
int idx = i < N ? i : N - i%N -1;
lminq.add(idx, idx + 1, s);
lmaxq.add(idx, idx + 1, s);
}
int Q; cin >> Q;
rep(i, Q){
int l, r, x; cin >> l >> r >> x;
l--; r--;
int ll = l < N ? l : N - l%N -1;
int rr = r < N ? r : N - r%N -1;
if(ll > rr){
swap(ll, rr);
x *= -1;
} else if(l == r and l >= N){
x *= -1;
}
if(l == r or ll != rr){
if( l < N and N <= r) rr--;
lminq.add(ll, rr + 1, x);
lmaxq.add(ll, rr + 1, x);
}
cout << ( lminq.query(0, N) == 0 and lmaxq.query(0, N) == 0 ) << endl;
}
return false;
}
int main()
{
ios::sync_with_stdio(false);
while(solve());
return 0;
}
|
Fox Jiro is one of the staffs of the ACM-ICPC 2018 Asia Yokohama Regional Contest and is responsible for designing the network for the venue of the contest. His network consists of $N$ computers, which are connected by $M$ cables. The $i$-th cable connects the $a_i$-th computer and the $b_i$-th computer, and it carries data in both directions. Your team will use the $S$-th computer in the contest, and a judge server is the $T$-th computer.
He decided to adjust the routing algorithm of the network to maximize the performance of the contestants through the magical power of prime numbers. In this algorithm, a packet (a unit of data carried by the network) is sent from your computer to the judge server passing through the cables a prime number of times if possible. If it is impossible, the contestants cannot benefit by the magical power of prime numbers. To accomplish this target, a packet is allowed to pass through the same cable multiple times.
You decided to write a program to calculate the minimum number of times a packet from $S$ to $T$ needed to pass through the cables. If the number of times a packet passes through the cables cannot be a prime number, print $-1$.
Input
The input consists of a single test case, formatted as follows.
$N$ $M$ $S$ $T$
$a_1$ $b_1$
$\vdots$
$a_M$ $b_M$
The first line consists of four integers $N, M, S,$ and $T$ ($2 \leq N \leq 10^5, 1 \leq M \leq 10^5, 1 \leq S, T \leq N, S \ne T$). The $i$-th line of the following $M$ lines consists of two integers $a_i$ and $b_i$ ($1 \leq a_i < b_i \leq N$), which means the $i$-th cables connects the $a_i$-th computer and the $b_i$-th computer in the network. You can assume that the network satisfies the following conditions.
* The network has no multi-edge, i.e.,$(a_i, b_i) \ne (a_j, b_j)$ for all $i,j$ ($1 \leq i < j \leq M$).
* The packets from $N$ computers are reachable to $T$ by passing through some number of cables. The number is not necessarily a prime.
Output
If there are ways such that the number of times a packet sent from $S$ to $T$ passes through the cables is a prime number, print the minimum prime number of times in one line. Otherwise, print $-1$.
Examples
Input
5 5 1 5
1 2
1 4
2 3
3 4
3 5
Output
3
Input
5 4 1 5
1 2
2 3
3 4
4 5
Output
-1
Input
2 1 1 2
1 2
Output
3
Input
3 3 1 2
1 2
1 3
2 3
Output
2
|
//#pragma GCC optimize ("O3")
//#pragma GCC target ("avx")
#include <stdio.h>
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <queue>
#include <cstdio>
#include <ctime>
#include <assert.h>
#include <chrono>
#include <random>
#include <numeric>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
using namespace std;
typedef long long int ll;
typedef unsigned long long ull;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
return (ull)rng() % B;
}
double dist(double x,double y){
return sqrt(x*x+y*y);
}
vector<int> g[100100];
int d[100100];
int dd[100100];
bool is_not_prime[1000100];
int main(){
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n,m,s,t; cin >> n >> m >> s >> t;
for(int i=0;i<n;i++){
d[i]=dd[i]=1e9;
}
s--; t--;
d[s]=0;
dd[t]=0;
while(m--){
int x,y; cin >> x >> y;
x--; y--;
g[x].push_back(y);
g[y].push_back(x);
}
for(int to:g[s]){
for(int toto:g[to]){
if(toto==t){
printf("2\n");
return 0;
}
}
}
queue<int> q;
q.push(s);
while(q.size()){
int p=q.front(); q.pop();
for(int to:g[p]){
if(d[to]!=1e9)continue;
d[to]=d[p]+1;
q.push(to);
}
}
q.push(t);
while(q.size()){
int p=q.front(); q.pop();
for(int to:g[p]){
if(dd[to]!=1e9)continue;
dd[to]=dd[p]+1;
q.push(to);
}
}
const int N=1000100;
vector<int> prime;
for(int i=2;i<N;i++){
if(!is_not_prime[i]){
if(i!=2)prime.push_back(i);
for(int j=i+i;j<N;j+=i){
is_not_prime[j]=true;
}
}
}
if(d[t]%2){
printf("%d\n",*lower_bound(prime.begin(), prime.end(),d[t]));
return 0;
}
else{
int res=1e9;
for(int i=0;i<n;i++){
for(int to:g[i]){
if((d[i]+1+dd[to])%2){
res=min(res,*lower_bound(prime.begin(), prime.end(),d[i]+dd[to]+1));
}
}
}
if(res==1e9)res=-1;
printf("%d\n",res);
}
}
|
Problem
Ghosts line up in a straight line from left to right with $ N $ people.
At first, the $ i $ th ghost from the left is facing left if $ U_i $ is'L', and facing right if it is'R'.
They are so timid that I don't want to see scary ghosts as much as possible.
You can instruct each ghost to look back.
It's scary to look back, so once the $ i $ th ghost looks back, it creates a fear of $ A_i $.
When the ghost looking to the left looks back, it turns to the right.
When the ghost looking to the right looks back, it turns to the left.
For $ i <j $, if the $ i $ th ghost is pointing to the right and the $ j $ th ghost is pointing to the left, then the $ i $ th ghost and the $ j $ th ghost are pointing to the left. Is defined as facing each other.
The following constraints are given in $ M $.
The $ S_i $ th ghost is scared of the $ T_i $ th ghost.
In the final state, if the $ S_i $ th ghost and the $ T_i $ th ghost face each other, a fear level of $ B_i $ will occur.
Find the minimum value of the total fear that occurs when you give the optimal instructions.
Constraints
The input satisfies the following conditions.
* $ 1 \ le N \ le 500 $
* $ 0 \ le M \ le \ min (N \ times (N-1), 1000) $
* $ | U | = N $
* $ U_i = $'L' or'R'
* $ 1 \ le A_i \ le 1000 $
* $ 1 \ le B_i \ le 1000 $
* $ 1 \ le S_i, T_i \ le N $
* $ (S_i, T_i) \ ne (S_j, T_j), $ if $ i \ ne j $
* $ S_i \ ne T_i $
Input
The input is given in the following format.
$ N $ $ M $
$ U $
$ A_1 $ $ A_2 $ $ ... $ $ A_N $
$ S_1 $ $ T_1 $ $ B_1 $
$ S_2 $ $ T_2 $ $ B_2 $
$ \ vdots $
$ S_M $ $ T_M $ $ B_M $
All inputs are given as integers.
Output
Output the minimum value of the total fear level.
Examples
Input
3 1
RRL
5 5 1
3 1 10
Output
1
Input
5 5
RLRLL
9 5 1 3 10
1 3 5
2 4 9
4 2 16
1 5 2
3 5 10
Output
8
|
#include<iostream>
#include<algorithm>
using namespace std;
//Dinic O(EV^2)
#include<algorithm>
#include<utility>
#include<vector>
#include<queue>
#include<limits>
template<typename T>
struct MF{
vector<vector<pair<pair<int,int>,T> > >G;
vector<int>level,iter;
MF(int n_=0):G(n_),level(n_),iter(n_){}
void add_edge(int from,int to,T cap)
{
G[from].push_back(make_pair(
make_pair(to,G[to].size()),cap
));
G[to].push_back(make_pair(
make_pair(from,G[from].size()-1),0
));
}
T dfs(int u,int t,T f)
{
if(u==t)return f;
for(;iter[u]<G[u].size();iter[u]++)
{
pair<pair<int,int>,T>&e=G[u][iter[u]];
if(e.second>0&&level[u]<level[e.first.first])
{
T d=dfs(e.first.first,t,min(f,e.second));
if(d>0)
{
e.second-=d;
G[e.first.first][e.first.second].second+=d;
return d;
}
}
}
return 0;
}
T max_flow(int s,int t)
{
T ret=0;
for(;;)
{
fill(level.begin(),level.end(),-1);
queue<int>P;
level[s]=0;
P.push(s);
while(!P.empty())
{
int u=P.front();P.pop();
for(pair<pair<int,int>,T>&e:G[u])
{
if(e.second>0&&level[e.first.first]<0)
{
level[e.first.first]=level[u]+1;
P.push(e.first.first);
}
}
}
if(level[t]<0)return ret;
fill(iter.begin(),iter.end(),0);
for(T f;(f=dfs(s,t,numeric_limits<T>::max()))>0;)ret+=f;
}
}
};
int n,m;
string u;
int main()
{
cin>>n>>m>>u;
MF<long long>mf(n+2);
for(int i=0;i<n;i++)
{
long long a;cin>>a;
if(u[i]=='L')
{
mf.add_edge(0,i+1,0);
mf.add_edge(i+1,n+1,a);
}
else
{
mf.add_edge(0,i+1,a);
mf.add_edge(i+1,n+1,0);
}
}
for(int i=0;i<m;i++)
{
int s,t;
long long b;
cin>>s>>t>>b;
if(s<t)mf.add_edge(s,t,b);
else mf.add_edge(t,s,b);
}
cout<<mf.max_flow(0,n+1)<<endl;
}
|
For a given polygon g, computes the area of the polygon.
g is represented by a sequence of points p1, p2,..., pn where line segments connecting pi and pi+1 (1 ≤ i ≤ n-1) are sides of g. The line segment connecting pn and p1 is also a side of the polygon.
Note that the polygon is not necessarily convex.
Constraints
* 3 ≤ n ≤ 100
* -10000 ≤ xi, yi ≤ 10000
* No point will occur more than once.
* Two sides can intersect only at a common endpoint.
Input
The input consists of coordinates of the points p1,..., pn in the following format:
n
x1 y1
x2 y2
:
xn yn
The first integer n is the number of points. The coordinate of a point pi is given by two integers xi and yi. The coordinates of points are given in the order of counter-clockwise visit of them.
Output
Print the area of the polygon in a line. The area should be printed with one digit to the right of the decimal point.
Examples
Input
3
0 0
2 2
-1 1
Output
2.0
Input
4
0 0
1 1
1 2
0 2
Output
1.5
|
#include <iostream>
#include <cmath>
#include <complex>
#include <tuple>
#include <vector>
using namespace std;
using vec = complex<double>;
using line = pair<vec,vec>;
using polygon = vector<vec>;
const double eps = 0.0000001;
double inner_product(vec u,vec v){
return real(u*conj(v));
}
double cross_product(vec u,vec v){
return imag(conj(u)*v);
}
vec projection(line l,vec p){//p???l???????°???±
vec s=l.first, t=l.second;
double k = inner_product(t-s,p-s)/inner_product(t-s,t-s);
return (1.0-k)*s+k*t;
}
vec reflection(line l,vec p){
return 2.0*projection(l,p)-p;
}
int ccw(vec& a, vec& b, vec& c){
vec ab = b-a, ac = c-a;
double o = cross_product(ab,ac);
if(o>0) return 1; //CCW
if(o<0) return -1; //CW
if(inner_product(ab,ac)<0){
return 2; //C-A-B
}else{
if(inner_product(ab,ab)<inner_product(ac,ac)){
return -2; //A-B-C
}else{
return 0; //A-C-B
}
}
}
bool isIntersect(line l0, line l1){
int s = ccw(l0.first,l0.second,l1.first)*ccw(l0.first,l0.second,l1.second);
if(s!=0&&s!=-1&&s!=-4) return false;
s=ccw(l1.first,l1.second,l0.first)*ccw(l1.first,l1.second,l0.second);
if(s!=0&&s!=-1&&s!=-4) return false;
else return true;
}
vec interSection(line l0, line l1){
vec s0, t0, s1, t1;
tie(s0,t0)=l0; tie(s1,t1)=l1;
double k = cross_product(t1-s1,s1-s0)/cross_product(t1-s1,t0-s0);
return s0+(t0-s0)*k;
}
double segLength(line l){
return abs(l.first-l.second);
}
double distLine2point(line l, vec p){
return abs(cross_product(l.second-l.first,p-l.first))/abs(l.second-l.first);
}
double distSeg2Point(line l, vec p){
vec x = projection(l,p);
double L = segLength(l);
if(abs(x-l.first)<L&&abs(x-l.second)<L){
return abs(x-p);
}else{
return min(abs(l.first-p),abs(l.second-p));
}
}
double distSeg2Seg(line l1, line l2){
if(isIntersect(l1,l2)) return 0;
double ret = 1e20;
ret = min(ret,distSeg2Point(l1,l2.first));
ret = min(ret,distSeg2Point(l1,l2.second));
swap(l1,l2);
ret = min(ret,distSeg2Point(l1,l2.first));
ret = min(ret,distSeg2Point(l1,l2.second));
return ret;
}
double area(polygon& g){
double S=0;
int n=g.size();
for(int i=0;i<n;i++){
S+=cross_product(g[i],g[(i+1)%n]);
}
S/=2;
return S;
}
//???????????§???????????????
int main(){
int n;
cin >> n;
polygon g;
while(n--){
int x,y;
cin>>x>>y;
g.emplace_back(x,y);
}
g.push_back(g.front());
cout.precision(1);
cout << fixed;
cout << area(g) << endl;
return 0;
}
|
Write a program which reads a sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and rotate specified elements by a list of the following operation:
* rotate($b, m, e$): For each integer $k$ ($0 \leq k < (e - b)$), move element $b + k$ to the place of element $b + ((k + (e - m)) \mod (e - b))$.
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b_i \leq m_i < e_i \leq n$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ...,\; a_{n-1}$
$q$
$b_1 \; m_1 \; e_1$
$b_2 \; m_2 \; e_2$
:
$b_{q} \; m_{q} \; e_{q}$
In the first line, $n$ (the number of elements in $A$) is given. In the second line, $a_i$ (each element in $A$) are given. In the third line, the number of queries $q$ is given and each query is given by three integers $b_i \; m_i \; e_i$ in the following $q$ lines.
Output
Print all elements of $A$ in a line after performing the given operations. Put a single space character between adjacency elements and a newline at the end of the last element.
Example
Input
11
1 2 3 4 5 6 7 8 9 10 11
1
2 6 9
Output
1 2 7 8 9 3 4 5 6 10 11
|
#include<bits/stdc++.h>
using namespace std ;
int main()
{
int n;
cin >> n ;
int v[n];
int i;
for(i=0;i<n;i++)
{
cin >> v[i] ;
}
int q ;
cin >> q ;
while(q--)
{
int a,b,c;
cin >> a >>b>>c;
rotate(v+a,v+b,v+c);
}
for(i=0;i<n;i++)
{
if(i) cout << ' ' ;
cout << v[i] ;
}
cout << endl ;
}
|
One day Chini while digging his ancestral farmland found the 2 boxes. He opened the 1st box, it was empty while in the second, there was 3 piles of gold coins. Whenever he chooses a pile of Y coins (y ≥ 1) from 2nd box, the coins in the 1st box increases by Y but only one gold coin gets reduced from the pile in the 2nd box. He can choose one pile at a
time. He repeats the operation N times. Each pile will contain coins between 1 and 50, inclusive, initially.
Find the maximum gold coins he can take with him.
Input
The first line of input consists of T, the number of test cases. Exactly t test cases follow.
Second line of input consists of number of coins in the three piles respectively, separated by space. Third line of input consist of a single integer N.
Output
Single line consisting of maximum coins he can take.
Constraints
1<=T<=1001<=N<=150
Example
Input:
1
3 7 6
3
Output:
19
Explanation
The three numbers are (3, 7, 6). One possible optimal strategy is as follows:
Chini chooses 7. he gains 7 points, and the numbers become (3, 6, 6). Chini chooses 6. he gains 6 points, and the numbers become (3, 6, 5). Chini chooses 6. he gains 6 points, and the numbers become (3, 5, 5).
|
def index(a):
m=0
ind=0
for i in range(len(a)):
if a[i]>m:
m=a[i]
ind=i
return ind
t=input()
while(t>0):
t-=1
a=map(int,raw_input().split())
n=input()
count=0
for i in range(n):
k=index(a)
if a[k]>=1:
count+=a[k]
a[k]-=1
else:break
print count
|
You have a list of N numbers. You are deleting D numbers from the list. Print the minimum sum that can be obtained by adding the remaining numbers after deleting exactly D numbers from the list.
Input
The first line will contain an integer T representing the number of test cases. Each test case will begin with two space separated numbers, N and D, on a new line. Next line of each test case of each test case will have N space separated integers, representing the list of numbers.
Output
Print T lines of numbers representing the minimum sum in each case.
Constraints
1 ≤ T ≤ 10
1 ≤ N ≤ 20
1 ≤ D ≤ N
Example
Input:
2
5 3
1 1 1 1 1
2 1
3 4
Output:
2
3
Explanation
Example case 1. After removing 3 numbers we will be left with sum of 2.
Example case 2. After removing 1 numbers we will be left with sum of 3, the only number left
|
for i in range(input()):
test1 = map(int,raw_input().split())
test2 = map(int,raw_input().split())
test2.sort(reverse=True)
test3 = test2[test1[1]:len(test2)]
count = 0
for x in test3:
count += x
print count
|
Given three integers x, m and n. Evaluate (1 + x + x^ 2 + .. + x^ m) (mod n)
Input
First line of the input contains a single integer T representing number of test cases that follow.
For next T lines, each line contains three space separated integers x, m and n.
Output
Output exactly T lines each containing the answer to the corresponding test case.
Constraints
1 ≤ T ≤ 1000
1 ≤ x, n, m ≤ 10^16
Example
Input:
1
3 2 5
Output:
3
|
t=int(raw_input())
for _ in range(t):
x,m,n=map(int,raw_input().split())
if n==1:
print 0
elif x==1:
print (m+1)%n
else:
b = (x-1)*n
ans=pow(x,m+1,b)
ans-=1
ans%=b
ans/=x-1
print ans
|
Haku Kale now wants to loot in a global scale. For that he needs the help of some underground gang leaders. But the problem is, he does not know the name of any gang leader. After a deep research, he got the name of gang leaders in an encrypted form. After spending months in decrypting it, he found the way to decrypt the name of the leaders from the information he has gathered. But he doesn’t have time to decrypt it. So, he wants a programmer to write a program for him to decrypt those names within a second.
According to Haku Kale, “Each character of name of gang leader is hidden in different words. Those characters can be extracted from middle of those given words after arranging their letters in alphabetical order.”
Input
The first line of the input contains an integer T number of gang leaders. For each gang leader N is given which signifies the number of characters in gang leader name which are encrypted in N number of words of length W.
Output
Each line contains the name of gang leader.
Constraints
Should contain all the constraints on the input data that you may have. Format it like:
0 ≤ T ≤ 100
0 ≤ N ≤ 20
0 ≤ W ≤ 500
Example
Input:
2
3
ARCTV
ACADAPALA
ZHFGOSM
4
FJAOHVG
AAAAA
NUWRE
IAT
Output:
RAM
HARI
Explanation
Example Case 1. The name contains 3 characters as mentioned where first letter can be obtained from “ARCTV” after arranging them in alphabetical order, second letter can be obtained from “ACADAPALA” after arranging them in alphabetical order and so on.
Example Case 2. Similar to Case 1 but this time the name contains 4 characters.
|
t=input()
while t>0:
n=input()
B=[]
for i in xrange(n):
A=raw_input()
A=sorted(A)
B.append(A[len(A)/2])
print "".join(B)
t=t-1
|
Petr, Nikita G. and Nikita are the most influential music critics in Saint-Petersburg. They have recently downloaded their favorite band's new album and going to listen to it. Nikita claims that the songs of entire album should be listened strictly in the same order as they are given, because there is the secret message from the author in the songs' order. Petr, being chaotic, does not think so, hence he loves listening to songs in a random order. Petr is pretty good in convincing other people, so after a two-hours discussion Nikita accepted listening in random order(the discussion's duration was like three times longer thatn the album's one). In this context random order means following: There are N songs in the album. In the very beginning random song is chosen(here and further "random song" means that every song has equal probability to be chosen). After some song is over the next one is chosen randomly and independently of what have been played before.
Nikita G., being the only one who is not going to drop out from the university, wonders, what is the expected number of songs guys have to listen to until every song is played at least once.
Input
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first and only line of each test case contains a single integer N denoting the number of songs in the album.
Output
For each test case, output a single line containing the expected number of songs the guys will listen to. Your answer will be considered as correct if it has an absolute or relative error less than 10^−1. More formally if the expected output is A and your output is B, your output will be considered as correct if and only if|A − B| ≤ 10^−1 * max{|A|, |B|, 1}.
Constraints
1 ≤ T ≤ 100
1 ≤ N ≤ 3000
Example
Input:
3
1
2
3
Output:
1.0
3.0
5.5
Explanation
Example case 2 After playing the first song there is 1/2 chance to finish the album each time new song is played. So the expected number of songs is 2/2 + 3/4 + 4/8... = 3
|
def expectation(n):
exp = 0.0
for i in range(1, n + 1):
exp += 1.0 / float(i)
print(exp * n)
t = input()
for i in range(0, t):
n = input()
expectation(n)
|
Oh, no! Chef’s in trouble. He’s got himself stuck in a cave (we don’t know how) and is looking for a way out. The bigger problem is that he needs to get his tractor out of the cave (don't ask why Chef owns a tractor!). He currently faces a large block of height N cells and length N cells, and needs to get his tractor across this block. The block is made up of vertical columns of soil, each of which is one cell long. Each column has a continuous vertical gap, with the i^th column having its gap from the li^th cell to the hi^th cell (starting from the bottom, 0-indexing). That is, in the i^th column, there is no soil from the li^th cell to the hi^th cell (both inclusive). Chef can build additional gaps by clearing some cells of soil. His tractor has height H, and therefore, he needs to build a horizontal corridor of height H passing through all the columns. That is, some consecutive H rows must have no soil. Please see the figures in the example and explanation sections for more details.
Chef is able to clear one cell of soil by spending one unit of energy. Chef is smart, and will figure out a way to build the horizontal corridor while spending the minimum possible amount of energy. To estimate how many of his tasty dishes he will still be able to cook for you tonight, find out what is the minimum possible energy he needs to spend.
Input
First line of input contains one integer T - number of test cases. T test cases follow.
Each test case starts with two integers N and H – size of the cave and height of the tractor, respectively. In each of the next N lines are two integers li and hi, respectively indicating lowest and highest number of cell for the gap in the i^th column.
Output
One integer – minimum energy required.
Constraints
1 ≤ T ≤ 10^3
1 ≤ N ≤ 10^6
1 ≤ sum of N over all test cases ≤ 10^6
1 ≤ H ≤ N
0 ≤ li ≤ hi < N
Example
Input:
2
4 3
1 2
1 2
1 2
1 2
5 2
2 3
1 2
2 3
1 2
2 3
Output:
4
2
Explanation
In the second case, the figure describes the initial map, where white cells denote empty cells and brown cells denote soil cells.
When we removed soil in two cells as the following figure, then we can make a corridor of height 2, adn this is the optimal way to make a corridor.
|
# cook your code here
for _ in range(int(raw_input())):
n,h=map(int,raw_input().split())
a=[0]*(n+2)
for i in range(n):
l,r=map(int,raw_input().split())
a[l+1]+=1
a[r+2]-=1
for i in range(1,n+1):
a[i]=a[i]+a[i-1]
for i in range(n+1):
a[i]=a[i]+a[i-1]
print n*h-max(a[i+h]-a[i] for i in range(n-h+1))
|
You are given two strings s and t. The string s consists of lowercase Latin letters and at most one wildcard character '*', the string t consists only of lowercase Latin letters. The length of the string s equals n, the length of the string t equals m.
The wildcard character '*' in the string s (if any) can be replaced with an arbitrary sequence (possibly empty) of lowercase Latin letters. No other character of s can be replaced with anything. If it is possible to replace a wildcard character '*' in s to obtain a string t, then the string t matches the pattern s.
For example, if s="aba*aba" then the following strings match it "abaaba", "abacaba" and "abazzzaba", but the following strings do not match: "ababa", "abcaaba", "codeforces", "aba1aba", "aba?aba".
If the given string t matches the given string s, print "YES", otherwise print "NO".
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the length of the string s and the length of the string t, respectively.
The second line contains string s of length n, which consists of lowercase Latin letters and at most one wildcard character '*'.
The third line contains string t of length m, which consists only of lowercase Latin letters.
Output
Print "YES" (without quotes), if you can obtain the string t from the string s. Otherwise print "NO" (without quotes).
Examples
Input
6 10
code*s
codeforces
Output
YES
Input
6 5
vk*cup
vkcup
Output
YES
Input
1 1
v
k
Output
NO
Input
9 6
gfgf*gfgf
gfgfgf
Output
NO
Note
In the first example a wildcard character '*' can be replaced with a string "force". So the string s after this replacement is "codeforces" and the answer is "YES".
In the second example a wildcard character '*' can be replaced with an empty string. So the string s after this replacement is "vkcup" and the answer is "YES".
There is no wildcard character '*' in the third example and the strings "v" and "k" are different so the answer is "NO".
In the fourth example there is no such replacement of a wildcard character '*' that you can obtain the string t so the answer is "NO".
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long mod = (long long)1e9 + 7;
void solve() {
long long n, m;
cin >> n >> m;
string s, t;
cin >> s >> t;
long long ps1 = 0, ps2 = n - 1, pt1 = 0, pt2 = m - 1;
long long d1 = 1, d2 = 1;
while (true) {
if (d1) {
if (s[ps1] == t[pt1]) {
ps1++;
pt1++;
} else if (s[ps1] == '*') {
d1 = 0;
} else {
cout << "NO\n";
return;
}
}
if (d2) {
if (s[ps2] == t[pt2]) {
ps2--;
pt2--;
} else if (s[ps2] == '*') {
d2 = 0;
} else {
cout << "NO\n";
return;
}
}
if (ps1 >= ps2) {
break;
}
if (pt1 > pt2) {
cout << "NO\n";
return;
}
}
long long c = 0;
for (long long i = 0; i < n; i++)
if (s[i] == '*') c++;
if (c and n < m)
cout << "YES\n";
else if (n < m)
cout << "NO\n";
else if (!c and n == m)
cout << "YES\n";
else if (!c and n != m)
cout << "NO\n";
else
cout << "YES\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long t = 1;
for (long long i = 0; i < t; i++) solve();
return 0;
}
|
You are playing a strange game with Li Chen. You have a tree with n nodes drawn on a piece of paper. All nodes are unlabeled and distinguishable. Each of you independently labeled the vertices from 1 to n. Neither of you know the other's labelling of the tree.
You and Li Chen each chose a subtree (i.e., a connected subgraph) in that tree. Your subtree consists of the vertices labeled x_1, x_2, …, x_{k_1} in your labeling, Li Chen's subtree consists of the vertices labeled y_1, y_2, …, y_{k_2} in his labeling. The values of x_1, x_2, …, x_{k_1} and y_1, y_2, …, y_{k_2} are known to both of you.
<image> The picture shows two labelings of a possible tree: yours on the left and Li Chen's on the right. The selected trees are highlighted. There are two common nodes.
You want to determine whether your subtrees have at least one common vertex. Luckily, your friend Andrew knows both labelings of the tree. You can ask Andrew at most 5 questions, each of which is in one of the following two forms:
* A x: Andrew will look at vertex x in your labeling and tell you the number of this vertex in Li Chen's labeling.
* B y: Andrew will look at vertex y in Li Chen's labeling and tell you the number of this vertex in your labeling.
Determine whether the two subtrees have at least one common vertex after asking some questions. If there is at least one common vertex, determine one of your labels for any of the common vertices.
Interaction
Each test consists of several test cases.
The first line of input contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
For each testcase, your program should interact in the following format.
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the number of nodes in the tree.
Each of the next n-1 lines contains two integers a_i and b_i (1≤ a_i, b_i≤ n) — the edges of the tree, indicating an edge between node a_i and b_i according to your labeling of the nodes.
The next line contains a single integer k_1 (1 ≤ k_1 ≤ n) — the number of nodes in your subtree.
The next line contains k_1 distinct integers x_1,x_2,…,x_{k_1} (1 ≤ x_i ≤ n) — the indices of the nodes in your subtree, according to your labeling. It is guaranteed that these vertices form a subtree.
The next line contains a single integer k_2 (1 ≤ k_2 ≤ n) — the number of nodes in Li Chen's subtree.
The next line contains k_2 distinct integers y_1, y_2, …, y_{k_2} (1 ≤ y_i ≤ n) — the indices (according to Li Chen's labeling) of the nodes in Li Chen's subtree. It is guaranteed that these vertices form a subtree according to Li Chen's labelling of the tree's nodes.
Test cases will be provided one by one, so you must complete interacting with the previous test (i.e. by printing out a common node or -1 if there is not such node) to start receiving the next one.
You can ask the Andrew two different types of questions.
* You can print "A x" (1 ≤ x ≤ n). Andrew will look at vertex x in your labeling and respond to you with the number of this vertex in Li Chen's labeling.
* You can print "B y" (1 ≤ y ≤ n). Andrew will look at vertex y in Li Chen's labeling and respond to you with the number of this vertex in your labeling.
You may only ask at most 5 questions per tree.
When you are ready to answer, print "C s", where s is your label of a vertex that is common to both subtrees, or -1, if no such vertex exists. Printing the answer does not count as a question. Remember to flush your answer to start receiving the next test case.
After printing a question do not forget to print end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
If the judge responds with -1, it means that you asked more queries than allowed, or asked an invalid query. Your program should immediately terminate (for example, by calling exit(0)). You will receive Wrong Answer; it means that you asked more queries than allowed, or asked an invalid query. If you ignore this, you can get other verdicts since your program will continue to read from a closed stream.
Hack Format
To hack, use the following format. Note that you can only hack with one test case.
The first line should contain a single integer t (t=1).
The second line should contain a single integer n (1 ≤ n ≤ 1 000).
The third line should contain n integers p_1, p_2, …, p_n (1≤ p_i≤ n) — a permutation of 1 to n. This encodes the labels that Li Chen chose for his tree. In particular, Li Chen chose label p_i for the node you labeled i.
Each of the next n-1 lines should contain two integers a_i and b_i (1≤ a_i, b_i≤ n). These edges should form a tree.
The next line should contain a single integer k_1 (1 ≤ k_1 ≤ n).
The next line should contain k_1 distinct integers x_1,x_2,…,x_{k_1} (1 ≤ x_i ≤ n). These vertices should form a subtree.
The next line should contain a single integer k_2 (1 ≤ k_2 ≤ n).
The next line should contain k_2 distinct integers y_1, y_2, …, y_{k_2} (1 ≤ y_i ≤ n). These vertices should form a subtree in Li Chen's tree according to the permutation above.
Examples
Input
1
3
1 2
2 3
1
1
1
2
2
1
Output
A 1
B 2
C 1
Input
2
6
1 2
1 3
1 4
4 5
4 6
4
1 3 4 5
3
3 5 2
3
6
1 2
1 3
1 4
4 5
4 6
3
1 2 3
3
4 1 6
5
Output
B 2
C 1
A 1
C -1
Note
For the first sample, Li Chen's hidden permutation is [2, 3, 1], and for the second, his hidden permutation is [5, 3, 2, 4, 1, 6] for both cases.
In the first sample, there is a tree with three nodes in a line. On the top, is how you labeled the tree and the subtree you chose, and the bottom is how Li Chen labeled the tree and the subtree he chose:
<image>
In the first question, you ask Andrew to look at node 1 in your labelling and tell you the label of it in Li Chen's labelling. Andrew responds with 2. At this point, you know that both of your subtrees contain the same node (i.e. node 1 according to your labeling), so you can output "C 1" and finish. However, you can also ask Andrew to look at node 2 in Li Chen's labelling and tell you the label of it in your labelling. Andrew responds with 1 (this step was given with the only reason — to show you how to ask questions).
For the second sample, there are two test cases. The first looks is the one from the statement:
<image>
We first ask "B 2", and Andrew will tell us 3. In this case, we know 3 is a common vertex, and moreover, any subtree with size 3 that contains node 3 must contain node 1 as well, so we can output either "C 1" or "C 3" as our answer.
In the second case in the second sample, the situation looks as follows:
<image>
In this case, you know that the only subtree of size 3 that doesn't contain node 1 is subtree 4,5,6. You ask Andrew for the label of node 1 in Li Chen's labelling and Andrew says 5. In this case, you know that Li Chen's subtree doesn't contain node 1, so his subtree must be consist of the nodes 4,5,6 (in your labelling), thus the two subtrees have no common nodes.
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> g;
vector<bool> isMy;
set<int> other;
vector<bool> used;
int find(int v) {
if (used[v]) return -1;
if (isMy[v]) return v;
used[v] = true;
for (int x : g[v]) {
int val = find(x);
if (val != -1) return val;
}
return -1;
}
int main() {
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
g.clear();
g.resize(n);
isMy.clear();
isMy.resize(n, false);
other.clear();
used.clear();
used.resize(n, false);
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
g[x].push_back(y);
g[y].push_back(x);
}
int k1;
cin >> k1;
for (int i = 0; i < k1; ++i) {
int x;
cin >> x;
--x;
isMy[x] = true;
}
int k2;
cin >> k2;
for (int i = 0; i < k2; ++i) {
int x;
cin >> x;
--x;
other.insert(x);
}
cout << "B " << (*other.begin()) + 1 << endl;
int start;
cin >> start;
--start;
int cand = find(start);
cout << "A " << cand + 1 << endl;
int who;
cin >> who;
--who;
if (other.count(who)) {
cout << "C " << cand + 1 << endl;
} else {
cout << "C " << -1 << endl;
}
}
return 0;
}
|
Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
a_{1} ≤ a_{2},
a_{n} ≤ a_{n-1} and
a_{i} ≤ max(a_{i-1}, a_{i+1}) for all i from 2 to n-1.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
Input
First line of input contains one integer n (2 ≤ n ≤ 10^{5}) — size of the array.
Second line of input contains n integers a_{i} — elements of array. Either a_{i} = -1 or 1 ≤ a_{i} ≤ 200. a_{i} = -1 means that i-th element can't be read.
Output
Print number of ways to restore the array modulo 998244353.
Examples
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
Note
In the first example, only possible value of a_{2} is 2.
In the second example, a_{1} = a_{2} so there are 200 different values because all restored elements should be integers between 1 and 200.
|
#include <bits/stdc++.h>
using namespace std;
const int M = 201, mod = 998244353;
int dp[M][2], ndp[M][2];
void modAdd(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
memset(dp, 0, sizeof(dp));
dp[0][1] = 1;
for (int a, i = 0; i < n; i++) {
cin >> a;
memset(ndp, 0, sizeof(ndp));
if (a == -1) {
int lessSum = (dp[0][0] + dp[0][1]) % mod;
int greaterEqualSum = 0;
for (int x = 1; x < M; x++) {
modAdd(greaterEqualSum, dp[x][1]);
}
for (int x = 1; x < M; x++) {
modAdd(greaterEqualSum, dp[x][0]);
modAdd(ndp[x][0], lessSum);
modAdd(ndp[x][1], greaterEqualSum);
modAdd(lessSum, dp[x][0]);
modAdd(lessSum, dp[x][1]);
modAdd(greaterEqualSum, mod - dp[x][0]);
modAdd(greaterEqualSum, mod - dp[x][1]);
}
} else {
for (int y = 0; y < 2; y++) {
for (int x = 0; x <= (y == 1 ? M - 1 : a); x++) {
modAdd(ndp[a][x >= a], dp[x][y]);
}
}
}
memcpy(dp, ndp, sizeof(dp));
}
int res = 0;
for (int x = 1; x < M; x++) {
modAdd(res, dp[x][1]);
}
cout << res << '\n';
}
|
King Kog got annoyed of the usual laxity of his knights — they can break into his hall without prior notice! Thus, the King decided to build a reception with a queue where each knight chooses in advance the time when he will come and how long the visit will take. The knights are served in the order of the recorded time, but each knight has to wait until the visits of all the knights before him are finished.
Princess Keabeanie wants to see her father. However, she does not want to interrupt the knights so she joins the queue. Unfortunately, the knights change their minds very often — they can join the queue or cancel their visits. Please help the princess to understand how long she will have to wait until she sees her father if she enters the queue at the specified moments of time given the records at the reception.
Input
The first line of the input contains a single integer q (1 ≤ q ≤ 3 ⋅ 10^5) — the number of events. An event can be of three types: join, cancel, or query.
* Join "+ t d" (1 ≤ t, d ≤ 10^6) — a new knight joins the queue, where t is the time when the knight will come and d is the duration of the visit.
* Cancel "- i" (1 ≤ i ≤ q) — the knight cancels the visit, where i is the number (counted starting from one) of the corresponding join event in the list of all events.
* Query "? t" (1 ≤ t ≤ 10^6) — Keabeanie asks how long she will wait if she comes at the time t.
It is guaranteed that after each event there are no two knights with the same entrance time in the queue. Cancel events refer to the previous joins that were not cancelled yet.
Keabeanie can come at the same time as some knight, but Keabeanie is very polite and she will wait for the knight to pass.
Output
For each query write a separate line with the amount of time Keabeanie will have to wait.
Example
Input
19
? 3
+ 2 2
? 3
? 4
+ 5 2
? 5
? 6
+ 1 2
? 2
? 3
? 4
? 5
? 6
? 7
? 9
- 8
? 2
? 3
? 6
Output
0
1
0
2
1
3
2
1
2
1
0
0
2
1
1
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
const int M = 1000007;
struct Node {
long long sum, suf;
Node Merge(const Node& nd) {
Node ret;
ret.sum = sum + nd.sum;
ret.suf = max(suf + nd.sum, nd.suf);
return ret;
}
};
int q;
int tt[N], dd[N];
int add[M];
Node T[M << 2];
void build(int v, int l, int r) {
if (l == r) {
T[v].sum = -1;
T[v].suf = 0;
return;
}
build(v << 1, l, ((l + r) >> 1));
build(v << 1 | 1, ((l + r) >> 1) + 1, r);
T[v] = T[v << 1].Merge(T[v << 1 | 1]);
}
void upd(int v, int l, int r, int u, int z) {
if (l == r) {
T[v].sum += 1LL * z;
T[v].suf = max(0LL, T[v].sum);
return;
}
if (u <= ((l + r) >> 1))
upd(v << 1, l, ((l + r) >> 1), u, z);
else
upd(v << 1 | 1, ((l + r) >> 1) + 1, r, u, z);
T[v] = T[v << 1].Merge(T[v << 1 | 1]);
}
Node get(int v, int l, int r, int L, int R) {
if (L == l && R == r) return T[v];
if (R <= ((l + r) >> 1))
return get(v << 1, l, ((l + r) >> 1), L, R);
else if (L > ((l + r) >> 1))
return get(v << 1 | 1, ((l + r) >> 1) + 1, r, L, R);
else {
return get(v << 1, l, ((l + r) >> 1), L, ((l + r) >> 1))
.Merge(get(v << 1 | 1, ((l + r) >> 1) + 1, r, ((l + r) >> 1) + 1, R));
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> q;
build(1, 0, M - 1);
for (int i = 1; i <= q; ++i) {
char op;
cin >> op;
if (op == '+') {
cin >> tt[i] >> dd[i];
add[tt[i]] += dd[i];
upd(1, 0, M - 1, tt[i], dd[i]);
} else if (op == '-') {
int id;
cin >> id;
add[tt[id]] -= dd[id];
upd(1, 0, M - 1, tt[id], -dd[id]);
} else {
int t;
cin >> t;
long long ans = get(1, 0, M - 1, 0, t - 1).suf;
ans += add[t];
cout << ans << '\n';
}
}
}
|
The only difference between easy and hard versions is a number of elements in the array.
You are given an array a consisting of n integers. The value of the i-th element of the array is a_i.
You are also given a set of m segments. The j-th segment is [l_j; r_j], where 1 ≤ l_j ≤ r_j ≤ n.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array a = [0, 0, 0, 0, 0] and the given segments are [1; 3] and [2; 4] then you can choose both of them and the array will become b = [-1, -2, -2, -1, 0].
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array a and obtain the array b then the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ 300) — the length of the array a and the number of segments, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^6 ≤ a_i ≤ 10^6), where a_i is the value of the i-th element of the array a.
The next m lines are contain two integers each. The j-th of them contains two integers l_j and r_j (1 ≤ l_j ≤ r_j ≤ n), where l_j and r_j are the ends of the j-th segment.
Output
In the first line of the output print one integer d — the maximum possible value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i if b is the array obtained by applying some subset of the given segments to the array a.
In the second line of the output print one integer q (0 ≤ q ≤ m) — the number of segments you apply.
In the third line print q distinct integers c_1, c_2, ..., c_q in any order (1 ≤ c_k ≤ m) — indices of segments you apply to the array a in such a way that the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i of the obtained array b is maximum possible.
If there are multiple answers, you can print any.
Examples
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
Note
In the first example the obtained array b will be [0, -4, 1, 1, 2] so the answer is 6.
In the second example the obtained array b will be [2, -3, 1, -1, 4] so the answer is 7.
In the third example you cannot do anything so the answer is 0.
|
#include <bits/stdc++.h>
using namespace std;
template <class T, size_t n>
ostream &operator<<(ostream &os, array<T, n> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class T>
ostream &operator<<(ostream &os, set<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class K, class X>
ostream &operator<<(ostream &os, map<K, X> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << H;
debug_out(T...);
}
using ii = pair<long long, long long>;
using vb = vector<bool>;
using vi = vector<long long>;
using vii = vector<ii>;
using vvi = vector<vi>;
using vvii = vector<vii>;
vi a;
class segtree {
public:
vi lazy;
vi tree;
vi li;
vi ri;
long long alloc(long long value, long long L = -1, long long R = -1) {
lazy.push_back(0);
tree.push_back(value);
li.push_back(L);
ri.push_back(R);
return tree.size() - 1;
}
void apply(long long c, long long val) {
lazy[c] += val;
tree[c] += val;
}
long long build(long long ll, long long rr) {
if (ll == rr) {
return alloc(a[ll]);
}
long long mid = (ll + rr) / 2;
long long L = build(ll, mid);
long long R = build(mid + 1, rr);
return alloc(min(tree[L], tree[R]), L, R);
}
inline void push(long long c, long long ll, long long rr) {
if (lazy[c] == 0 or ll == rr) return;
apply(li[c], lazy[c]);
apply(ri[c], lazy[c]);
lazy[c] = 0;
}
void modify(long long c, long long ll, long long rr, long long ql,
long long qr, long long val) {
if (ql <= ll and rr <= qr) {
apply(c, val);
return;
}
push(c, ll, rr);
long long mid = (ll + rr) / 2;
if (ql <= mid) modify(li[c], ll, mid, ql, qr, val);
if (qr > mid) modify(ri[c], mid + 1, rr, ql, qr, val);
tree[c] = min(tree[li[c]], tree[ri[c]]);
}
long long get(long long c, long long ll, long long rr, long long ql,
long long qr) {
if (ql <= ll and rr <= qr) {
return tree[c];
}
push(c, ll, rr);
long long mid = (ll + rr) / 2;
if (qr <= mid) return get(li[c], ll, mid, ql, qr);
if (mid < ql) return get(ri[c], mid + 1, rr, ql, qr);
return min(get(li[c], ll, mid, ql, qr), get(ri[c], mid + 1, rr, ql, qr));
}
};
inline bool in(long long x, ii q) { return q.first <= x and x <= q.second; }
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long m;
cin >> m;
a = vi(n, 0);
vii q(m);
segtree st;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
set<pair<long long, pair<long long, bool>>> qset;
const long long root = st.build(0, n - 1);
for (long long i = 0; i < m; i++) {
cin >> q[i].first >> q[i].second;
q[i].first--;
q[i].second--;
qset.insert({q[i].first, {i, true}});
st.modify(root, 0, n - 1, q[i].first, q[i].second, -1);
}
long long best = 0;
long long argmax = -1;
for (long long i = 0; i < n; i++) {
while (not qset.empty() and i == qset.begin()->first) {
long long index = qset.begin()->second.first;
bool remove = qset.begin()->second.second;
qset.erase(qset.begin());
if (remove) {
st.modify(root, 0, n - 1, q[index].first, q[index].second, +1);
qset.insert({q[index].second + 1, {index, false}});
} else {
st.modify(root, 0, n - 1, q[index].first, q[index].second, -1);
}
}
long long res = a[i] - st.get(root, 0, n - 1, 0, n - 1);
if (res > best) {
argmax = i;
best = res;
}
}
cout << best << '\n';
vi apply;
for (long long i = 0; i < m; i++) {
if (not in(argmax, q[i])) {
apply.push_back(i + 1);
}
}
cout << apply.size() << '\n';
for (long long x : apply) {
cout << x << " ";
}
cout << '\n';
}
|
Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.
The pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.
Arkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.
Find the length of the longest continuous subsegment of sushi Arkady can buy.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of pieces of sushi.
The second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.
It is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.
Output
Print a single integer — the maximum length of a valid continuous segment.
Examples
Input
7
2 2 2 1 1 2 2
Output
4
Input
6
1 2 1 2 1 2
Output
2
Input
9
2 2 1 1 1 2 2 2 2
Output
6
Note
In the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.
In the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.
In the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2].
|
import java.io.IOException;
import java.util.*;
import java.util.Map.Entry;
public class Codechef2{
static FasterScanner in = new FasterScanner();
public static void main(String[] args) throws Exception {
int n = in.nextInt();
int [] arr = in.nextIntArray(n);
ArrayList<Integer> al = new ArrayList<>();
int s=1;
for(int i=1; i<n; i++){
if(arr[i]==arr[i-1])s++;
else{
al.add(s); s=1;
}
}
al.add(s);
int ans=Integer.MIN_VALUE;
for(int i=1; i<al.size(); i++){
ans = Math.max(ans, Math.min(al.get(i), al.get(i-1)));
}
System.out.println(2*ans);
}
static class FasterScanner {
private byte[] buf = new byte[1024];
private int curChar;
private int snumChars;
public int read() {
if (snumChars == -1)
throw new InputMismatchException();
if (curChar >= snumChars) {
curChar = 0;
try {
snumChars = System.in.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (snumChars <= 0)
return -1;
}
return buf[curChar++];
}
public String nextLine() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isEndOfLine(c));
return res.toString();
}
public String nextString() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public long nextLong() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public int nextInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public int[] nextIntArray(int n) {
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = nextInt();
}
return arr;
}
public long[] nextLongArray(int n) {
long[] arr = new long[n];
for (int i = 0; i < n; i++) {
arr[i] = nextLong();
}
return arr;
}
private boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
private boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
}
}
|
You are given a set of points x_1, x_2, ..., x_n on the number line.
Two points i and j can be matched with each other if the following conditions hold:
* neither i nor j is matched with any other point;
* |x_i - x_j| ≥ z.
What is the maximum number of pairs of points you can match with each other?
Input
The first line contains two integers n and z (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ z ≤ 10^9) — the number of points and the constraint on the distance between matched points, respectively.
The second line contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9).
Output
Print one integer — the maximum number of pairs of points you can match with each other.
Examples
Input
4 2
1 3 3 7
Output
2
Input
5 5
10 9 5 8 7
Output
1
Note
In the first example, you may match point 1 with point 2 (|3 - 1| ≥ 2), and point 3 with point 4 (|7 - 3| ≥ 2).
In the second example, you may match point 1 with point 3 (|5 - 10| ≥ 5).
|
import java.util.Arrays;
import java.util.Scanner;
public class Main2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int z = scanner.nextInt();
int [] arr = new int[n+1];
for (int i = 1; i <= n; i++) {
arr[i] = scanner.nextInt();
}
int ans = 0;
Arrays.sort(arr);
int y = 2;
int p1 = 1, p2 = n/2;
while (p1 <= n/2 && p2 <= n){
if (arr[p2] - arr[p1] >= z){
ans++;
p2++;
p1++;
}else{
p2++;
}
}
System.out.println(ans);
}
}
|
This is the first subtask of problem F. The only differences between this and the second subtask are the constraints on the value of m and the time limit. You need to solve both subtasks in order to hack this one.
There are n+1 distinct colours in the universe, numbered 0 through n. There is a strip of paper m centimetres long initially painted with colour 0.
Alice took a brush and painted the strip using the following process. For each i from 1 to n, in this order, she picks two integers 0 ≤ a_i < b_i ≤ m, such that the segment [a_i, b_i] is currently painted with a single colour, and repaints it with colour i.
Alice chose the segments in such a way that each centimetre is now painted in some colour other than 0. Formally, the segment [i-1, i] is painted with colour c_i (c_i ≠ 0). Every colour other than 0 is visible on the strip.
Count the number of different pairs of sequences \\{a_i\}_{i=1}^n, \\{b_i\}_{i=1}^n that result in this configuration.
Since this number may be large, output it modulo 998244353.
Input
The first line contains a two integers n, m (1 ≤ n ≤ 500, n = m) — the number of colours excluding the colour 0 and the length of the paper, respectively.
The second line contains m space separated integers c_1, c_2, …, c_m (1 ≤ c_i ≤ n) — the colour visible on the segment [i-1, i] after the process ends. It is guaranteed that for all j between 1 and n there is an index k such that c_k = j.
Note that since in this subtask n = m, this means that c is a permutation of integers 1 through n.
Output
Output a single integer — the number of ways Alice can perform the painting, modulo 998244353.
Examples
Input
3 3
1 2 3
Output
5
Input
7 7
4 5 1 6 2 3 7
Output
165
Note
In the first example, there are 5 ways, all depicted in the figure below. Here, 0 is white, 1 is red, 2 is green and 3 is blue.
<image>
Below is an example of a painting process that is not valid, as in the second step the segment 1 3 is not single colour, and thus may not be repainted with colour 2.
<image>
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 500;
long long dp[MAXN][MAXN], a[MAXN], n, m;
long long calc(long long l, long long r) {
if (r < 0 || l < 0 || r >= n || l >= n) return 1;
long long& val = dp[l][r];
if (val != -1) return val;
if (l >= r) return val = 1;
long long mn_ind = l;
for (long long i = l; i <= r; ++i) {
if (a[i] < a[mn_ind]) mn_ind = i;
}
long long lval = 0, rval = 0;
for (long long i = l; i <= mn_ind; ++i) {
lval += calc(l, i - 1) * calc(i, mn_ind - 1) % 998244353ll;
}
for (long long i = mn_ind; i <= r; ++i) {
rval += calc(mn_ind + 1, i) * calc(i + 1, r) % 998244353ll;
}
lval %= 998244353ll;
rval %= 998244353ll;
val = lval * rval % 998244353ll;
return val;
}
void Solve() {
cin >> n >> m;
for (signed i = 0; i < (n); i++) cin >> a[i];
memset(dp, -1, sizeof(dp));
cout << calc(0, n - 1);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
Solve();
return 0;
}
|
You are given two integers b and w. You have a chessboard of size 10^9 × 10^9 with the top left cell at (1; 1), the cell (1; 1) is painted white.
Your task is to find a connected component on this chessboard that contains exactly b black cells and exactly w white cells. Two cells are called connected if they share a side (i.e. for the cell (x, y) there are at most four connected cells: (x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1)). A set of cells is called a connected component if for every pair of cells C_1 and C_2 from this set, there exists a sequence of cells c_1, c_2, ..., c_k such that c_1 = C_1, c_k = C_2, all c_i from 1 to k are belong to this set of cells and for every i ∈ [1, k - 1], cells c_i and c_{i + 1} are connected.
Obviously, it can be impossible to find such component. In this case print "NO". Otherwise, print "YES" and any suitable connected component.
You have to answer q independent queries.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^5) — the number of queries. Then q queries follow.
The only line of the query contains two integers b and w (1 ≤ b, w ≤ 10^5) — the number of black cells required and the number of white cells required.
It is guaranteed that the sum of numbers of cells does not exceed 2 ⋅ 10^5 (∑ w + ∑ b ≤ 2 ⋅ 10^5).
Output
For each query, print the answer to it.
If it is impossible to find the required component, print "NO" on the first line.
Otherwise, print "YES" on the first line. In the next b + w lines print coordinates of cells of your component in any order. There should be exactly b black cells and w white cells in your answer. The printed component should be connected.
If there are several answers, you can print any. All coordinates in the answer should be in the range [1; 10^9].
Example
Input
3
1 1
1 4
2 5
Output
YES
2 2
1 2
YES
2 3
1 3
3 3
2 2
2 4
YES
2 3
2 4
2 5
1 3
1 5
3 3
3 5
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
int b, w, s = 2;
cin >> b >> w;
swap(b, w);
if (b > w) swap(b, w), s = 3;
if (b * 3 + 1 < w) {
cout << "NO" << endl;
continue;
}
cout << "YES" << endl;
for (int i = 1; i <= b; ++i) cout << s << " " << i * 2 << endl;
for (int i = 1; i <= b; ++i, --w) cout << s << " " << i * 2 - 1 << endl;
if (w > 0) cout << s << " " << b * 2 + 1 << endl, w--;
if (w > 0)
for (int i = 1; i <= b && w > 0; ++i, w--)
cout << s + 1 << " " << i * 2 << endl;
if (w > 0)
for (int i = 1; i <= b && w > 0; ++i, --w)
cout << s - 1 << " " << i * 2 << endl;
}
return 0;
}
|
You are given a weighted tree consisting of n vertices. Recall that a tree is a connected graph without cycles. Vertices u_i and v_i are connected by an edge with weight w_i.
You are given m queries. The i-th query is given as an integer q_i. In this query you need to calculate the number of pairs of vertices (u, v) (u < v) such that the maximum weight of an edge on a simple path between u and v doesn't exceed q_i.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of vertices in the tree and the number of queries.
Each of the next n - 1 lines describes an edge of the tree. Edge i is denoted by three integers u_i, v_i and w_i — the labels of vertices it connects (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i) and the weight of the edge (1 ≤ w_i ≤ 2 ⋅ 10^5). It is guaranteed that the given edges form a tree.
The last line of the input contains m integers q_1, q_2, ..., q_m (1 ≤ q_i ≤ 2 ⋅ 10^5), where q_i is the maximum weight of an edge in the i-th query.
Output
Print m integers — the answers to the queries. The i-th value should be equal to the number of pairs of vertices (u, v) (u < v) such that the maximum weight of an edge on a simple path between u and v doesn't exceed q_i.
Queries are numbered from 1 to m in the order of the input.
Examples
Input
7 5
1 2 1
3 2 3
2 4 1
4 5 2
5 7 4
3 6 2
5 2 3 4 1
Output
21 7 15 21 3
Input
1 2
1 2
Output
0 0
Input
3 3
1 2 1
2 3 2
1 3 2
Output
1 3 3
Note
The picture shows the tree from the first example: <image>
|
#include <bits/stdc++.h>
using namespace std;
set<pair<long long, pair<long long, long long> > > st;
set<pair<long long, pair<long long, long long> > >::iterator it;
set<pair<long long, long long> > sl;
set<pair<long long, long long> >::iterator kt;
long long x[300005], y[300005], siz[300005], parent[300005], z[300005];
vector<long long> v;
vector<long long>::iterator jt;
void make_set(long long v) {
parent[v] = v;
siz[v] = 1;
}
long long find_set(long long v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
long long unionn(long long a, long long b) {
a = find_set(a);
b = find_set(b);
long long f = 0;
if (a != b) {
f = siz[a] * siz[b];
if (siz[a] < siz[b]) swap(a, b);
parent[b] = a;
siz[a] += siz[b];
}
return f;
}
void add(long long lo, long long hi, long long val) {
y[lo] += val;
y[hi + 1] -= val;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long a = 0, b = 0, c, d, e, f = 0, l, g, m, n, k, i, j, t, p, q;
cin >> n >> q;
for (i = 1; i < n; i++) {
cin >> a >> b >> c;
st.insert({c, {a, b}});
}
for (i = 0; i < q; i++) {
cin >> a;
sl.insert({a, i});
v.push_back(a);
}
sort(v.begin(), v.end());
for (i = 1; i <= n; i++) {
make_set(i);
}
it = st.begin();
while (it != st.end()) {
c = it->first;
a = it->second.first;
b = it->second.second;
d = unionn(a, b);
jt = lower_bound(v.begin(), v.end(), c);
e = jt - v.begin();
add(e, 300000, d);
it++;
}
for (i = 1; i < 200005; i++) {
y[i] += y[i - 1];
}
kt = sl.begin();
a = 0;
while (kt != sl.end()) {
z[kt->second] = y[a];
a++;
kt++;
}
for (i = 0; i < q; i++) {
cout << z[i] << ' ';
}
return 0;
}
|
This is an easier version of the problem. In this version, n ≤ 2000.
There are n distinct points in three-dimensional space numbered from 1 to n. The i-th point has coordinates (x_i, y_i, z_i). The number of points n is even.
You'd like to remove all n points using a sequence of n/2 snaps. In one snap, you can remove any two points a and b that have not been removed yet and form a perfectly balanced pair. A pair of points a and b is perfectly balanced if no other point c (that has not been removed yet) lies within the axis-aligned minimum bounding box of points a and b.
Formally, point c lies within the axis-aligned minimum bounding box of points a and b if and only if min(x_a, x_b) ≤ x_c ≤ max(x_a, x_b), min(y_a, y_b) ≤ y_c ≤ max(y_a, y_b), and min(z_a, z_b) ≤ z_c ≤ max(z_a, z_b). Note that the bounding box might be degenerate.
Find a way to remove all points in n/2 snaps.
Input
The first line contains a single integer n (2 ≤ n ≤ 2000; n is even), denoting the number of points.
Each of the next n lines contains three integers x_i, y_i, z_i (-10^8 ≤ x_i, y_i, z_i ≤ 10^8), denoting the coordinates of the i-th point.
No two points coincide.
Output
Output n/2 pairs of integers a_i, b_i (1 ≤ a_i, b_i ≤ n), denoting the indices of points removed on snap i. Every integer between 1 and n, inclusive, must appear in your output exactly once.
We can show that it is always possible to remove all points. If there are many solutions, output any of them.
Examples
Input
6
3 1 0
0 3 0
2 2 0
1 0 0
1 3 0
0 1 0
Output
3 6
5 1
2 4
Input
8
0 1 1
1 0 1
1 1 0
1 1 1
2 2 2
3 2 2
2 3 2
2 2 3
Output
4 5
1 6
2 7
3 8
Note
In the first example, here is what points and their corresponding bounding boxes look like (drawn in two dimensions for simplicity, as all points lie on z = 0 plane). Note that order of removing matters: for example, points 5 and 1 don't form a perfectly balanced pair initially, but they do after point 3 is removed.
<image>
|
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x, y, z;
int idx;
Point(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(z) {}
bool operator<(const Point& XD) const {
if (x != XD.x) return x < XD.x;
if (y != XD.y) return y < XD.y;
return z < XD.z;
}
Point operator-(const Point& a) const {
return Point(abs(a.x - x), abs(a.y - y), abs(a.z - z));
}
Point& operator=(const Point& a) {
x = a.x;
y = a.y;
z = a.z;
idx = a.idx;
return *this;
}
};
Point point[50010];
int ex[50010];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> point[i].x >> point[i].y >> point[i].z;
point[i].idx = i;
}
sort(point + 1, point + n + 1);
for (int i = 1; i <= n; i++) {
if (ex[i]) continue;
Point min_dis;
int min_idx = 0;
for (int j = i + 1; j <= n; j++) {
if (ex[j]) continue;
if (min_idx == 0) {
min_idx = j;
min_dis = point[i] - point[j];
} else {
if (point[i] - point[j] < min_dis) {
min_dis = point[i] - point[j];
min_idx = j;
}
}
}
cout << point[i].idx << ' ' << point[min_idx].idx << '\n';
ex[min_idx] = 1;
}
}
|
Hanh lives in a shared apartment. There are n people (including Hanh) living there, each has a private fridge.
n fridges are secured by several steel chains. Each steel chain connects two different fridges and is protected by a digital lock. The owner of a fridge knows passcodes of all chains connected to it. A fridge can be open only if all chains connected to it are unlocked. For example, if a fridge has no chains connected to it at all, then any of n people can open it.
<image> For exampe, in the picture there are n=4 people and 5 chains. The first person knows passcodes of two chains: 1-4 and 1-2. The fridge 1 can be open by its owner (the person 1), also two people 2 and 4 (acting together) can open it.
The weights of these fridges are a_1, a_2, …, a_n. To make a steel chain connecting fridges u and v, you have to pay a_u + a_v dollars. Note that the landlord allows you to create multiple chains connecting the same pair of fridges.
Hanh's apartment landlord asks you to create exactly m steel chains so that all fridges are private. A fridge is private if and only if, among n people living in the apartment, only the owner can open it (i.e. no other person acting alone can do it). In other words, the fridge i is not private if there exists the person j (i ≠ j) that the person j can open the fridge i.
For example, in the picture all the fridges are private. On the other hand, if there are n=2 fridges and only one chain (which connects them) then both fridges are not private (both fridges can be open not only by its owner but also by another person).
Of course, the landlord wants to minimize the total cost of all steel chains to fulfill his request. Determine whether there exists any way to make exactly m chains, and if yes, output any solution that minimizes the total cost.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 10). Then the descriptions of the test cases follow.
The first line of each test case contains two integers n, m (2 ≤ n ≤ 1000, 1 ≤ m ≤ n) — the number of people living in Hanh's apartment and the number of steel chains that the landlord requires, respectively.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^4) — weights of all fridges.
Output
For each test case:
* If there is no solution, print a single integer -1.
* Otherwise, print a single integer c — the minimum total cost. The i-th of the next m lines contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i), meaning that the i-th steel chain connects fridges u_i and v_i. An arbitrary number of chains can be between a pair of fridges.
If there are multiple answers, print any.
Example
Input
3
4 4
1 1 1 1
3 1
1 2 3
3 3
1 2 3
Output
8
1 2
4 3
3 2
4 1
-1
12
3 2
1 2
3 1
|
import java.awt.event.MouseAdapter;
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
new Main().run();
}
static int groups = 0;
static int[] fa;
static int[] sz;
static void init1(int n) {
groups = n;
fa = new int[n];
for (int i = 1; i < n; ++i) {
fa[i] = i;
}
sz = new int[n];
Arrays.fill(sz, 1);
}
static int root(int p) {
while (p != fa[p]) {
fa[p] = fa[fa[p]];
p = fa[p];
}
return p;
}
static void combine(int p, int q) {
int i = root(p);
int j = root(q);
if (i == j) {
return;
}
fa[i] = j;
if (sz[i] < sz[j]) {
fa[i] = j;
sz[j] += sz[i];
} else {
fa[j] = i;
sz[i] += sz[j];
}
groups--;
}
public static String roundS(double result, int scale) {
String fmt = String.format("%%.%df", scale);
return String.format(fmt, result);
}
int[] unique(int a[]) {
int p = 1;
for (int i = 1; i < a.length; ++i) {
if (a[i] != a[i - 1]) {
a[p++] = a[i];
}
}
return Arrays.copyOf(a, p);
}
public static int bigger(long[] a, long key) {
return bigger(a, 0, a.length, key);
}
public static int bigger(long[] a, int lo, int hi,
long key) {
while (lo < hi) {
int mid = (lo + hi) >>> 1;
if (a[mid] > key) {
hi = mid;
} else {
lo = mid + 1;
}
}
return lo;
}
int h[];
int to[];
int ne[];
long w[];
int cc = 0;
void add(int u, int v, long ww) {
to[++cc] = u;
// w[cc] = ww;
ne[cc] = h[v];
h[v] = cc;
to[++cc] = v;
// w[cc] = ww;
ne[cc] = h[u];
h[u] = cc;
}
// List<int[]> li = new ArrayList<>();
//
// void go(int j){
// d[j] = l[j] = ++N;
// int cd = 0;
// for(int i=h[j];i!=0;i= ne[i]){
// int v= to[i];
// if(d[v]==0){
// fa[v] = j;
// cd++;
// go(v);
// l[j] = Math.min(l[j],l[v]);
// if(d[j]<=l[v]){
// cut[j] = true;
// }
// if(d[j]<l[v]){
// int ma = Math.max(j,v);
// int mi = Math.min(j,v);
// li.add(new int[]{mi,ma});
// }
// }else if(fa[j]!=v){
// l[j] = Math.min(l[j],d[v]);
// }
// }
// if(fa[j]==-1&&cd==1){
// cut[j] = false;
// }
// if (l[j] == d[j]) {
// while(p>0){
// mk[stk[p-1]] = id;
// }
// id++;
// }
// }
// int mk[];
// int id= 0;
// int l[];
// boolean cut[];
// int p = 0;
// int d[];int N = 0;
// int stk[];
static class S {
int l = 0;
int r = 0;
int miss = 0;
int cnt = 0;
int c = 0;
public S(int l, int r) {
this.l = l;
this.r = r;
}
}
static S a[];
static int[] o;
static void init11(int[] f) {
o = f;
int len = o.length;
a = new S[len * 4];
build1(1, 0, len - 1);
}
static void build1(int num, int l, int r) {
S cur = new S(l, r);
if (l == r) {
cur.c = o[l];
a[num] = cur;
return;
} else {
int m = (l + r) >> 1;
int le = num << 1;
int ri = le | 1;
build1(le, l, m);
build1(ri, m + 1, r);
a[num] = cur;
pushup(num, le, ri);
}
}
static int query1(int num, int l, int r) {
if (a[num].l >= l && a[num].r <= r) {
return a[num].c;
} else {
int m = (a[num].l + a[num].r) >> 1;
int le = num << 1;
int ri = le | 1;
int mi = -1;
if (r > m) {
int res = query1(ri, l, r);
mi = Math.max(mi, res);
}
if (l <= m) {
int res = query1(le, l, r);
mi = Math.max(mi, res);
}
return mi;
}
}
static void pushup(int num, int le, int ri) {
a[num].c = Math.max(a[le].c, a[ri].c);
}
// int root[] = new int[10000];
//
// void dfs(int j) {
//
// clr[j] = 1;
//
// for (int i = h[j]; i != 0; i = ne[i]) {
// int v = to[i];
// dfs(v);
// }
// for (Object go : qr[j]) {
// int g = (int) go;
// int id1 = qs[g][0];
// int id2 = qs[g][1];
// int ck;
// if (id1 == j) {
// ck = id2;
// } else {
// ck = id1;
// }
//
// if (clr[ck] == 0) {
// continue;
// } else if (clr[ck] == 1) {
// qs[g][2] = ck;
// } else {
// qs[g][2] = root(ck);
// }
// }
// root[j] = fa[j];
//
// clr[j] = 2;
// }
int clr[];
List[] qr;
int qs[][];
int rr = 100;
LinkedList<Integer> cao;
void df(int n,LinkedList<Integer> li){
int sz = li.size();
if(sz>=rr||sz>=11) return;
int v = li.getLast();
if(v==n){
cao = new LinkedList<>(li);
rr = sz;
return;
}
List<Integer> res = new ArrayList<>(li);
Collections.reverse(res);
for(int u:res){
for(int vv:res){
if(u+vv>v&&u+vv<=n){
li.addLast(u+vv);
df(n,li);
li.removeLast();
}else if(u+vv>n){break;}
}
}
}
Random rd = new Random(1274873);
static long mul(long a, long b, long p)
{
long res=0,base=a;
while(b>0)
{
if((b&1L)>0)
res=(res+base)%p;
base=(base+base)%p;
b>>=1;
}
return res;
}
static long mod_pow(long k,long n,long p){
long res = 1L;
long temp = k%p;
while(n!=0L){
if((n&1L)==1L){
res = mul(res,temp,p);
}
temp = mul(temp,temp,p);
n = n>>1L;
}
return res%p;
}
long gen(long x){
while(true) {
long f = rd.nextLong()%x;
if (f >=1 &&f<=x-1) {
return f;
}
}
}
boolean robin_miller(long x){
if(x==1) return false;
if(x==2) return true;
if(x==3) return true;
if((x&1)==0) return false;
long y = x%6;
if(y==1||y==5){
long ck = x-1;
while((ck&1)==0) ck>>>=1;
long as[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};
for(int i=0;i<as.length;++i){
long a = as[i];
long ck1= ck;
a = mod_pow(a,ck1,x);
while(ck1<x){
y = mod_pow(a,2, x);
if (y == 1 && a != 1 && a != x - 1)
return false;
a = y;
ck1 = ck1<<1;
}
if (a != 1)
return false;
}
return true;
}else{
return false;
}
}
long inv(long a, long MOD) {
//return fpow(a, MOD-2, MOD);
return a==1?1:(long )(MOD-MOD/a)*inv(MOD%a, MOD)%MOD;
}
long C(long n,long m, long MOD) {
if(m+m>n)m=n-m;
long up=1,down=1;
for(long i=0;i<m;i++)
{
up=up*(n-i)%MOD;
down=down*(i+1)%MOD;
}
return up*inv(down, MOD)%MOD;
}
// int g[][] = {{1,2,3},{0,3,4},{0,3},{0,1,2,4},{1,3}};
// int res= 0;
// void go(int i,int a[],int x[],boolean ck[]){
// if(i==5){
// int an = 0;
// for(int j=0;i<5;++j){
// int id = a[j];
// if(ct[id]>3) continue;
// int all =0;
// for(int g:g[id]){
// all |= a[g];
// }
// if(all&(gz[id])==gz[id]){
// an++;
// }
// }
// if(an>res){
// res = an;
// }
// return;
// }
// for(int j=0;j<5;++j){
// if(!ck[j]){
// ck[j] = true;
// a[i] = x[j];
// go(i+1,a,x,ck);
// ck[j] = false;
// }
// }
//
//
// }
// x = r[0], y = r[1] , gcd(x,y) = r[2]
public static long[] ex_gcd(long a,long b){
if(b==0) {
return new long[]{1,0,a};
}
long []r = ex_gcd(b,a%b);
return new long[]{r[1], r[0]-(a/b)*r[1], r[2]};
}
void chinese_rm(long m[],long r[]){
long res[] = ex_gcd(m[0],m[1]);
long rm = r[1]-r[0];
if(rm%res[2]==0){
}
}
// void go(int i,int c,int cl[]){
// cl[i] = c;
// for(int j=h[i];j!=-1;j=ne[j]){
// int v = to[j];
// if(cl[v]==0){
// go(v,-c,cl);
// }
// }
//
// }
int go(int rt,int h[],int ne[],int to[],int pa){
int all = 3010;
for(int i=h[rt];i!=-1;i=ne[i]){
int v = to[i];
if(v==pa) continue;
int ma = 0;
for(int j=h[rt];j!=-1;j=ne[j]) {
int u = to[j];
if(u==pa) continue;
if(u!=v){
int r = 1 + go(u,h,ne,to,rt);
ma = Math.max(ma,r);
}
}
all = Math.min(all,ma);
}
if(all==3010||all==0) return 1;
return all;
}
boolean next_perm(int[] a){
int len = a.length;
for(int i=len-2,j = 0;i>=0;--i){
if(a[i]<a[i+1]){
j = len-1;
for(;a[j]<=a[i];--j);
int p = a[j];
a[j] = a[i];
a[i] = p;
j = i+1;
for(int ed = len-1;j<ed;--ed) {
p = a[ed];
a[ed] = a[j];
a[j++] = p;
}
return true;
}
}
return false;
}
int sign(double f){
if(f>=0.0){
return 1;
}
return -1;
}
int[] mul(int a[],int b[],int w){
int f[] = new int[w];
for(int i=0;i<w;++i){
for(int j= 0;j<w&&i+j<w;++j){
f[i + j] += a[i] * b[j];
}
}
for(int i=0;i<w;++i){
if(i+1<w){
f[i+1] += f[i]/10;
}
f[i] = f[i]%10;
}
return f;
}
void solve() {
int t = ni();
for(int i=0;i<t;++i){
int n = ni();
int m = ni();
int s = 0;
int a[][] = new int[n][2];
for(int j=0;j<n;++j){
a[j][0] = ni();
a[j][1] = j;
s += a[j][0]<<1;
}
if(n==2){
println(-1);continue;
}
if(m<n){
println(-1);continue;
}
Arrays.sort(a,(int x[],int y[])->{
return x[0]-y[0];
});
for(int j=0;j<m-n;++j){
s += a[j][0];
s += a[j+1][0];
}
println(s);
for (int j = 0; j < n - 1; ++j) {
println((a[j][1] + 1) + " " + (a[j + 1][1] + 1));
}
println((a[0][1] + 1) + " " + (a[n - 1][1] + 1));
for(int j=0;j<m-n;++j){
println((a[0][1] + 1) + " " + (a[1][1] + 1));
}
}
//
// for(int i=0;i<1000000;++i){
// r = mul(r,a,k);
// if(Arrays.equals(r,a)){
// println(i+1);return;
// }
// }
// println(-1);
// int n = ni();
// int p = ni();
//
// int h[] = new int[n+1];
// Arrays.fill(h,-1);
// int to[] = new int[2*n+5];
// int ne[] = new int[2*n+5];
// int ct = 0;
//
// for(int i=0;i<p;i++){
// int x = ni();
// int y = ni();
// to[ct] = x;
// ne[ct] = h[y];
// h[y] = ct++;
//
// to[ct] = y;
// ne[ct] = h[x];
// h[x] = ct++;
//
// }
//
// println(go(1,h,ne,to,-1));
// int n= ni();
// //int m = ni();
// int l = 2*n;
//
// String s[] = new String[2*n+1];
//
// long a[] = new long[2*n+1];
// for(int i=1;i<=n;++i){
// s[i] = ns();
// s[i+n] = s[i];
// a[i] = ni();
// a[i+n] = a[i];
// }
//
// long dp[][] = new long[l+1][l+1];
// long dp1[][] = new long[l+1][l+1];
//
// for(int i = l;i>=1;--i) {
//
// Arrays.fill(dp[i],-1000000000);
// Arrays.fill(dp1[i],1000000000);
// }
//
// for(int i = l;i>=1;--i) {
// dp[i][i] = a[i];
// dp1[i][i] = a[i];
// }
//
//
//
// for(int i = l;i>=1;--i) {
//
// for (int j = i+1; j <= l&&j-i+1<=n; ++j) {
//
//
// for(int e=i;e<j;++e){
// if(s[e+1].equals("t")){
// dp[i][j] = Math.max(dp[i][j], dp[i][e]+dp[e+1][j]);
// dp1[i][j] = Math.min(dp1[i][j], dp1[i][e]+dp1[e+1][j]);
// }else{
//
// long f[] = {dp[i][e]*dp[e+1][j],dp1[i][e]*dp1[e+1][j],dp[i][e]*dp1[e+1][j],dp1[i][e]*dp[e+1][j]};
//
// for(long u:f) {
// dp[i][j] = Math.max(dp[i][j], u);
// dp1[i][j] = Math.min(dp1[i][j], u);
// }
// }
//
//
// }
//
// }
// }
// long ma = -100000000;
// List<Integer> li = new ArrayList<>();
// for (int j = 1; j <= n; ++j) {
// if(dp[j][j+n-1]==ma){
// li.add(j);
// }else if(dp[j][j+n-1]>ma){
// ma = dp[j][j+n-1];
// li.clear();
// li.add(j);
// }
//
// }
// println(ma);
// for(int u:li){
// print(u+" ");
// }
// println();
// println(get(490));
// int num =1;
// while(true) {
// int n = ni();
// int m = ni();
// if(n==0&&m==0) break;
// int p[] = new int[n];
// int d[] = new int[n];
// for(int j=0;j<n;++j){
// p[j] = ni();
// d[j] = ni();
// }
// int dp[][] = new int[8001][22];
// int choose[][] = new int[8001][22];
//
// for(int v=0;v<=8000;++v){
// for(int u=0;u<=21;++u) {
// dp[v][u] = -100000;
// choose[v][u] =-1;
// }
// }
// dp[4000][0] = 0;
//
// for(int j=0;j<n;++j){
// for(int g = m-1 ;g>=0; --g){
// if(p[j] - d[j]>=0) {
// for (int v = 4000; v >= -4000; --v) {
// if (v + 4000 + p[j] - d[j] >= 0 && v + 4000 + p[j] - d[j] <= 8000 && dp[v + 4000][g] >= 0) {
// int ck1 = dp[v + 4000 + p[j] - d[j]][g + 1];
// if (ck1 < dp[v + 4000][g] + p[j] + d[j]) {
// dp[v + 4000 + p[j] - d[j]][g + 1] = dp[v + 4000][g] + p[j] + d[j];
// choose[v + 4000 + p[j] - d[j]][g + 1] = j;
// }
// }
//
// }
// }else{
// for (int v = -4000; v <= 4000; ++v) {
// if (v + 4000 + p[j] - d[j] >= 0 && v + 4000 + p[j] - d[j] <= 8000 && dp[v + 4000][g] >= 0) {
// int ck1 = dp[v + 4000 + p[j] - d[j]][g + 1];
// if (ck1 < dp[v + 4000][g] + p[j] + d[j]) {
// dp[v + 4000 + p[j] - d[j]][g + 1] = dp[v + 4000][g] + p[j] + d[j];
// choose[v + 4000 + p[j] - d[j]][g + 1] = j;
// }
// }
//
// }
//
//
//
//
//
// }
// }
// }
// int big = 0;
// int st = 0;
// boolean ok = false;
// for(int v=0;v<=4000;++v){
// int v1 = -v;
// if(dp[v+4000][m]>0){
// big = dp[v+4000][m];
// st = v+4000;
// ok = true;
// }
// if(dp[v1+4000][m]>0&&dp[v1+4000][m]>big){
// big = dp[v1+4000][m];
// st = v1+4000;
// ok = true;
// }
// if(ok){
// break;
// }
// }
// int f = 0;
// int s = 0;
// List<Integer> res = new ArrayList<>();
// while(choose[st][m]!=-1){
// int j = choose[st][m];
// res.add(j+1);
// f += p[j];
// s += d[j];
// st -= p[j]-d[j];
// m--;
// }
// Collections.sort(res);
// println("Jury #"+num);
// println("Best jury has value " + f + " for prosecution and value " + s + " for defence:");
// for(int u=0;u<res.size();++u){
// print(" ");
// print(res.get(u));
// }
// println();
// println();
// num++;
// }
// int n = ni();
// int m = ni();
//
// int dp[][] = new int[n][4];
//
// for(int i=0;i<n;++i){
// for(int j=0;j<m;++j){
// for(int c = 0;c<4;++c){
// if(c==0){
// dp[i][j][] =
// }
// }
// }
// }
}
static void pushdown(int num, int le, int ri) {
}
long gcd(long a, long b) {
return b == 0 ? a : gcd(b, a % b);
}
InputStream is;
PrintWriter out;
void run() throws Exception {
is = System.in;
out = new PrintWriter(System.out);
solve();
out.flush();
}
private byte[] inbuf = new byte[1024];
public int lenbuf = 0, ptrbuf = 0;
private int readByte() {
if (lenbuf == -1) throw new InputMismatchException();
if (ptrbuf >= lenbuf) {
ptrbuf = 0;
try {
lenbuf = is.read(inbuf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0) return -1;
}
return inbuf[ptrbuf++];
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private int skip() {
int b;
while ((b = readByte()) != -1 && isSpaceChar(b)) ;
return b;
}
private double nd() {
return Double.parseDouble(ns());
}
private char nc() {
return (char) skip();
}
private char ncc() {
int b = b = readByte();
return (char) b;
}
private String ns() {
int b = skip();
StringBuilder sb = new StringBuilder();
while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
private char[] ns(int n) {
char[] buf = new char[n];
int b = skip(), p = 0;
while (p < n && !(isSpaceChar(b))) {
buf[p++] = (char) b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
private String nline() {
int b = skip();
StringBuilder sb = new StringBuilder();
while (!isSpaceChar(b) || b == ' ') {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
private char[][] nm(int n, int m) {
char[][] a = new char[n][];
for (int i = 0; i < n; i++) a[i] = ns(m);
return a;
}
private int[] na(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = ni();
return a;
}
private long[] nal(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) a[i] = nl();
return a;
}
private int ni() {
int num = 0, b;
boolean minus = false;
while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) {
}
;
if (b == '-') {
minus = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') num = (num << 3) + (num << 1) + (b - '0');
else return minus ? -num : num;
b = readByte();
}
}
private long nl() {
long num = 0;
int b;
boolean minus = false;
while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) {
}
;
if (b == '-') {
minus = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') num = num * 10 + (b - '0');
else return minus ? -num : num;
b = readByte();
}
}
void print(Object obj) {
out.print(obj);
}
void println(Object obj) {
out.println(obj);
}
void println() {
out.println();
}
}
|
Polycarp is sad — New Year is coming in few days but there is still no snow in his city. To bring himself New Year mood, he decided to decorate his house with some garlands.
The local store introduced a new service this year, called "Build your own garland". So you can buy some red, green and blue lamps, provide them and the store workers will solder a single garland of them. The resulting garland will have all the lamps you provided put in a line. Moreover, no pair of lamps of the same color will be adjacent to each other in this garland!
For example, if you provide 3 red, 3 green and 3 blue lamps, the resulting garland can look like this: "RGBRBGBGR" ("RGB" being the red, green and blue color, respectively). Note that it's ok to have lamps of the same color on the ends of the garland.
However, if you provide, say, 1 red, 10 green and 2 blue lamps then the store workers won't be able to build any garland of them. Any garland consisting of these lamps will have at least one pair of lamps of the same color adjacent to each other. Note that the store workers should use all the lamps you provided.
So Polycarp has bought some sets of lamps and now he wants to know if the store workers can build a garland from each of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of sets of lamps Polycarp has bought.
Each of the next t lines contains three integers r, g and b (1 ≤ r, g, b ≤ 10^9) — the number of red, green and blue lamps in the set, respectively.
Output
Print t lines — for each set of lamps print "Yes" if the store workers can build a garland from them and "No" otherwise.
Example
Input
3
3 3 3
1 10 2
2 1 1
Output
Yes
No
Yes
Note
The first two sets are desribed in the statement.
The third set produces garland "RBRG", for example.
|
import java.util.*;
public class Solution
{
public static void main(String args[])
{
Scanner s= new Scanner(System.in);
int t=s.nextInt();
while(t>0)
{
int a=s.nextInt();
int b=s.nextInt();
int c=s.nextInt();
int flag=0;
if(a+b+1<c)
flag=1;
else if(b+c+1<a)
flag=1;
else if(a+c+1<b)
flag=1;
t--;
if(flag==1)
System.out.println("NO");
else
System.out.println("YES");
}
}
}
|
Guy-Manuel and Thomas are planning 144 trips around the world.
You are given a simple weighted undirected connected graph with n vertexes and m edges with the following restriction: there isn't any simple cycle (i. e. a cycle which doesn't pass through any vertex more than once) of length greater than 3 which passes through the vertex 1. The cost of a path (not necessarily simple) in this graph is defined as the [XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of weights of all edges in that path with each edge being counted as many times as the path passes through it.
But the trips with cost 0 aren't exciting.
You may choose any subset of edges incident to the vertex 1 and remove them. How many are there such subsets, that, when removed, there is not any nontrivial cycle with the cost equal to 0 which passes through the vertex 1 in the resulting graph? A cycle is called nontrivial if it passes through some edge odd number of times. As the answer can be very big, output it modulo 10^9+7.
Input
The first line contains two integers n and m (1 ≤ n,m ≤ 10^5) — the number of vertexes and edges in the graph. The i-th of the next m lines contains three integers a_i, b_i and w_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i, 0 ≤ w_i < 32) — the endpoints of the i-th edge and its weight. It's guaranteed there aren't any multiple edges, the graph is connected and there isn't any simple cycle of length greater than 3 which passes through the vertex 1.
Output
Output the answer modulo 10^9+7.
Examples
Input
6 8
1 2 0
2 3 1
2 4 3
2 6 2
3 4 8
3 5 4
5 4 5
5 6 6
Output
2
Input
7 9
1 2 0
1 3 1
2 3 9
2 4 3
2 5 4
4 5 7
3 6 6
3 7 7
6 7 8
Output
1
Input
4 4
1 2 27
1 3 1
1 4 1
3 4 0
Output
6
Note
The pictures below represent the graphs from examples. <image> In the first example, there aren't any nontrivial cycles with cost 0, so we can either remove or keep the only edge incident to the vertex 1. <image> In the second example, if we don't remove the edge 1-2, then there is a cycle 1-2-4-5-2-1 with cost 0; also if we don't remove the edge 1-3, then there is a cycle 1-3-2-4-5-2-3-1 of cost 0. The only valid subset consists of both edges. <image> In the third example, all subsets are valid except for those two in which both edges 1-3 and 1-4 are kept.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int S = 405;
struct edge {
int to, next, v;
} e[N * 2];
int head[N], tot, n, m;
int dep[N], v[N];
int vis[N], flg[N];
int nd, tr[S][35];
int trr[S][S];
map<long long, int> mp;
long long sta[S];
void add(int x, int y, int v) {
e[++tot] = (edge){y, head[x], v};
head[x] = tot;
}
int init_state(int v, long long val) {
if (mp[val]) return mp[val];
mp[val] = ++nd;
sta[nd] = val;
for (int i = (int)(0); i <= (int)(31); i++) {
long long nval = val;
if (val & (1ll << i))
tr[mp[val]][i] = 1;
else {
for (int j = (int)(0); j <= (int)(31); j++)
if (val & (1ll << j)) nval |= (1ll << (j ^ i));
tr[mp[val]][i] = init_state(i + 1, nval);
}
}
return mp[val];
}
void dfs(int x, int fa, int &S) {
dep[x] = dep[fa] + 1;
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa && !vis[e[i].to]) {
if (!dep[e[i].to]) {
v[e[i].to] = v[x] ^ e[i].v;
dfs(e[i].to, x, S);
} else if (dep[e[i].to] < dep[x]) {
S = tr[S][v[e[i].to] ^ v[x] ^ e[i].v];
}
}
}
struct oppp {
int op1, op2, op3, op4;
} op[N];
int op_top;
int f[2][S];
const int mo = 1000000007;
void UPD(int &x, int y) { (x += y) >= mo ? x -= mo : 233; }
pair<int, int> q[N];
int top, ST[N], val[N];
int main() {
nd = 1;
init_state(0, 1);
for (int i = (int)(0); i <= (int)(31); i++) tr[1][i] = 1;
for (int i = (int)(1); i <= (int)(nd); i++) trr[i][1] = trr[1][i] = 1;
for (int i = (int)(2); i <= (int)(nd); i++)
for (int j = (int)(2); j <= (int)(nd); j++) {
trr[i][j] = i;
if (sta[i] & sta[j] & ((1ll << 32) - 2))
trr[i][j] = 1;
else
for (int k = (int)(1); k <= (int)(31); k++)
if (sta[j] & (1ll << k))
if (!(sta[trr[i][j]] & (1ll << k))) trr[i][j] = tr[trr[i][j]][k];
}
scanf("%d%d", &n, &m);
for (int i = (int)(1); i <= (int)(m); i++) {
int x, y, v;
scanf("%d%d%d", &x, &y, &v);
add(x, y, v);
add(y, x, v);
}
for (int i = head[1]; i; i = e[i].next)
vis[e[i].to] = 1, q[++top] = pair<int, int>(e[i].to, e[i].v);
vis[1] = 1;
for (int i = (int)(1); i <= (int)(top); i++) {
int now = mp[1];
vis[q[i].first] = 0;
dfs(q[i].first, 0, now);
vis[q[i].first] = 1;
ST[q[i].first] = now;
val[q[i].first] = q[i].second;
}
for (int i = (int)(1); i <= (int)(top); i++)
if (!flg[q[i].first]) {
bool ok = 0;
for (int j = head[q[i].first]; j; j = e[j].next)
if (e[j].to != 1 && vis[e[j].to]) {
flg[e[j].to] = 1;
++op_top;
int tmp = trr[ST[q[i].first]][ST[e[j].to]];
op[op_top].op1 = mp[1];
op[op_top].op2 = tmp;
op[op_top].op3 = tmp;
op[op_top].op4 = tr[tmp][val[q[i].first] ^ val[e[j].to] ^ e[j].v];
ok = 1;
}
if (!ok) {
++op_top;
op[op_top].op1 = mp[1];
op[op_top].op2 = ST[q[i].first];
op[op_top].op3 = -1;
op[op_top].op4 = -1;
}
}
memset(f, 0, sizeof(f));
f[0][mp[1]] = 1;
int pre = 0, now = 1;
for (int i = (int)(1); i <= (int)(op_top); i++) {
for (int j = (int)(1); j <= (int)(nd); j++) {
if (op[i].op1 != -1) UPD(f[now][trr[j][op[i].op1]], f[pre][j]);
if (op[i].op2 != -1) UPD(f[now][trr[j][op[i].op2]], f[pre][j]);
if (op[i].op3 != -1) UPD(f[now][trr[j][op[i].op3]], f[pre][j]);
if (op[i].op4 != -1) UPD(f[now][trr[j][op[i].op4]], f[pre][j]);
f[pre][j] = 0;
}
swap(pre, now);
}
int ans = 0;
for (int i = (int)(2); i <= (int)(nd); i++) UPD(ans, f[pre][i]);
cout << ans;
}
|
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2.
|
import java.io.*;
import java.util.*;
public class Main {
public static int lower_bound(int[] A, int low, int high, int x) {
if (A[low] >= x) {
return low;
} else if (A[high] < x) {
return high + 1;
}
while (low <= high) {
int mid = (low + high) / 2;
if (A[mid] < x) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return high + 1;
}
public static int upper_bound(int[] A, int low, int high, int x) {
if (A[low] > x) {
return low;
} else if (A[high] <= x) {
return high + 1;
}
while (low <= high) {
int mid = (low + high) / 2;
if (A[mid] > x) {
high = mid - 1;
} else {
low = mid + 1;
}
}
return low;
}
public static void main(String[] args) {
InputReader in = new InputReader();
int N = in.nextInt();
int[] A = new int[N];
for (int i = 0; i < N; i++) {
A[i] = in.nextInt();
}
Arrays.sort(A);
int ans = 0;
for (int i = 24; i >= 0; i--) {
for (int j = 0; j < N - 1; j++) {
int lb, ub;
lb = lower_bound(A, j + 1, N - 1, (1 << i) - A[j]);
ub = upper_bound(A, j + 1, N - 1, (2 << i) - 1 - A[j]);
ans ^= ((Math.max(ub - lb, 0)) % 2) << i;
lb = lower_bound(A, j + 1, N - 1, (3 << i) - A[j]);
ub = upper_bound(A, j + 1, N - 1, (4 << i) - 2 - A[j]);
ans ^= ((Math.max(ub - lb, 0)) % 2) << i;
}
if (i == 0) {
break;
}
for (int j = 0; j < N; j++) {
A[j] %= 1 << i;
}
Arrays.sort(A);
}
System.out.println(ans);
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer st;
public InputReader() {
reader = new BufferedReader(new InputStreamReader(System.in));
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
st = new StringTokenizer(nextLine());
}
return st.nextToken();
}
public String nextLine() {
try {
return reader.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
public int nextInt() {
return Integer.parseInt(next());
}
}
}
|
Nastya just made a huge mistake and dropped a whole package of rice on the floor. Mom will come soon. If she sees this, then Nastya will be punished.
In total, Nastya dropped n grains. Nastya read that each grain weighs some integer number of grams from a - b to a + b, inclusive (numbers a and b are known), and the whole package of n grains weighs from c - d to c + d grams, inclusive (numbers c and d are known). The weight of the package is the sum of the weights of all n grains in it.
Help Nastya understand if this information can be correct. In other words, check whether each grain can have such a mass that the i-th grain weighs some integer number x_i (a - b ≤ x_i ≤ a + b), and in total they weigh from c - d to c + d, inclusive (c - d ≤ ∑_{i=1}^{n}{x_i} ≤ c + d).
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines contain descriptions of the test cases, each line contains 5 integers: n (1 ≤ n ≤ 1000) — the number of grains that Nastya counted and a, b, c, d (0 ≤ b < a ≤ 1000, 0 ≤ d < c ≤ 1000) — numbers that determine the possible weight of one grain of rice (from a - b to a + b) and the possible total weight of the package (from c - d to c + d).
Output
For each test case given in the input print "Yes", if the information about the weights is not inconsistent, and print "No" if n grains with masses from a - b to a + b cannot make a package with a total mass from c - d to c + d.
Example
Input
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
Output
Yes
No
Yes
No
Yes
Note
In the first test case of the example, we can assume that each grain weighs 17 grams, and a pack 119 grams, then really Nastya could collect the whole pack.
In the third test case of the example, we can assume that each grain weighs 16 grams, and a pack 128 grams, then really Nastya could collect the whole pack.
In the fifth test case of the example, we can be assumed that 3 grains of rice weigh 2, 2, and 3 grams, and a pack is 7 grams, then really Nastya could collect the whole pack.
In the second and fourth test cases of the example, we can prove that it is impossible to determine the correct weight of all grains of rice and the weight of the pack so that the weight of the pack is equal to the total weight of all collected grains.
|
def main():
T = int(input())
for t in range(T):
n,a,b,c,d = list(map(int,input().split()))
pos = True
if((a-b)*n>(c+d)):
pos = False
elif((a-b)*n < (c-d)) and ((c-d)-(a-b)*n) > 2*b*n:
pos = False
print("YES") if pos else print("NO")
if __name__ == "__main__":
main()
|
Shubham has an array a of size n, and wants to select exactly x elements from it, such that their sum is odd. These elements do not have to be consecutive. The elements of the array are not guaranteed to be distinct.
Tell him whether he can do so.
Input
The first line of the input contains a single integer t (1≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and x (1 ≤ x ≤ n ≤ 1000) — the length of the array and the number of elements you need to choose.
The next line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — elements of the array.
Output
For each test case, print "Yes" or "No" depending on whether it is possible to choose x elements such that their sum is odd.
You may print every letter in any case you want.
Example
Input
5
1 1
999
1 1
1000
2 1
51 50
2 2
51 50
3 3
101 102 103
Output
Yes
No
Yes
Yes
No
Note
For 1st case: We must select element 999, and the sum is odd.
For 2nd case: We must select element 1000, so overall sum is not odd.
For 3rd case: We can select element 51.
For 4th case: We must select both elements 50 and 51 — so overall sum is odd.
For 5th case: We must select all elements — but overall sum is not odd.
|
from sys import stdin,stdout
lis=lambda:list(map(int,input().split()))
Ma=lambda:map(int,input().split())
inte=lambda:int(input())
st=lambda:input()
import math
from collections import Counter
for i in range(inte()):
n,x=Ma()
a=lis()
o=0;e=0
for i in a:
if i%2==0:
e+=1
else:o+=1
if o==0:print("NO")
elif e==0:
if x%2==0:print("NO")
else:print("YES")
else:
if e>=x-1:
print("YES")
else:
if x==n:
if sum(a)%2==0:print("NO")
else:print("YES")
else:print("YES")
|
Note that the only difference between String Transformation 1 and String Transformation 2 is in the move Koa does. In this version the letter y Koa selects can be any letter from the first 20 lowercase letters of English alphabet (read statement for better understanding). You can make hacks in these problems independently.
Koa the Koala has two strings A and B of the same length n (|A|=|B|=n) consisting of the first 20 lowercase English alphabet letters (ie. from a to t).
In one move Koa:
1. selects some subset of positions p_1, p_2, …, p_k (k ≥ 1; 1 ≤ p_i ≤ n; p_i ≠ p_j if i ≠ j) of A such that A_{p_1} = A_{p_2} = … = A_{p_k} = x (ie. all letters on this positions are equal to some letter x).
2. selects any letter y (from the first 20 lowercase letters in English alphabet).
3. sets each letter in positions p_1, p_2, …, p_k to letter y. More formally: for each i (1 ≤ i ≤ k) Koa sets A_{p_i} = y.
Note that you can only modify letters in string A.
Koa wants to know the smallest number of moves she has to do to make strings equal to each other (A = B) or to determine that there is no way to make them equal. Help her!
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 10) — the number of test cases. Description of the test cases follows.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^5) — the length of strings A and B.
The second line of each test case contains string A (|A|=n).
The third line of each test case contains string B (|B|=n).
Both strings consists of the first 20 lowercase English alphabet letters (ie. from a to t).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case:
Print on a single line the smallest number of moves she has to do to make strings equal to each other (A = B) or -1 if there is no way to make them equal.
Example
Input
5
3
aab
bcc
4
cabc
abcb
3
abc
tsr
4
aabd
cccd
5
abcbd
bcdda
Output
2
3
3
2
4
Note
* In the 1-st test case Koa:
1. selects positions 1 and 2 and sets A_1 = A_2 = b (\color{red}{aa}b → \color{blue}{bb}b).
2. selects positions 2 and 3 and sets A_2 = A_3 = c (b\color{red}{bb} → b\color{blue}{cc}).
* In the 2-nd test case Koa:
1. selects positions 1 and 4 and sets A_1 = A_4 = a (\color{red}{c}ab\color{red}{c} → \color{blue}{a}ab\color{blue}{a}).
2. selects positions 2 and 4 and sets A_2 = A_4 = b (a\color{red}{a}b\color{red}{a} → a\color{blue}{b}b\color{blue}{b}).
3. selects position 3 and sets A_3 = c (ab\color{red}{b}b → ab\color{blue}{c}b).
* In the 3-rd test case Koa:
1. selects position 1 and sets A_1 = t (\color{red}{a}bc → \color{blue}{t}bc).
2. selects position 2 and sets A_2 = s (t\color{red}{b}c → t\color{blue}{s}c).
3. selects position 3 and sets A_3 = r (ts\color{red}{c} → ts\color{blue}{r}).
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int T, n;
char a[N], b[N];
int to[25], fa[25];
bool dag[1 << 20];
int find(int x) { return x == fa[x] ? x : find(fa[x]); }
int main() {
cin >> T;
while (T--) {
cin >> n >> (a + 1) >> (b + 1);
for (int i = (1); i <= (20); ++i) fa[i] = i, to[i] = 0;
for (int i = (1); i <= (n); ++i) {
int x = a[i] - 'a' + 1, y = b[i] - 'a' + 1;
fa[find(x)] = find(y);
if (x != y) to[x] |= (1 << y - 1);
}
int tot = 40, ans = 0;
for (int i = (1); i <= (20); ++i) tot -= (i == fa[i]);
memset(dag, 0, sizeof dag);
dag[0] = 1;
for (int mask = (0); mask <= ((1 << 20) - 1); ++mask)
if (dag[mask]) {
for (int i = (0); i <= (19); ++i)
if (!(mask >> i & 1) && ((mask & to[i + 1]) == 0))
dag[mask | (1 << i)] = true;
ans = max(ans, __builtin_popcount(mask));
}
cout << tot - ans << endl;
}
return 0;
}
|
Let a_1, …, a_n be an array of n positive integers. In one operation, you can choose an index i such that a_i = i, and remove a_i from the array (after the removal, the remaining parts are concatenated).
The weight of a is defined as the maximum number of elements you can remove.
You must answer q independent queries (x, y): after replacing the x first elements of a and the y last elements of a by n+1 (making them impossible to remove), what would be the weight of a?
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 3 ⋅ 10^5) — the length of the array and the number of queries.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — elements of the array.
The i-th of the next q lines contains two integers x and y (x, y ≥ 0 and x+y < n).
Output
Print q lines, i-th line should contain a single integer — the answer to the i-th query.
Examples
Input
13 5
2 2 3 9 5 4 6 5 7 8 3 11 13
3 1
0 0
2 4
5 0
0 12
Output
5
11
6
1
0
Input
5 2
1 4 1 2 4
0 0
1 0
Output
2
0
Note
Explanation of the first query:
After making first x = 3 and last y = 1 elements impossible to remove, a becomes [×, ×, ×, 9, 5, 4, 6, 5, 7, 8, 3, 11, ×] (we represent 14 as × for clarity).
Here is a strategy that removes 5 elements (the element removed is colored in red):
* [×, ×, ×, 9, \color{red}{5}, 4, 6, 5, 7, 8, 3, 11, ×]
* [×, ×, ×, 9, 4, 6, 5, 7, 8, 3, \color{red}{11}, ×]
* [×, ×, ×, 9, 4, \color{red}{6}, 5, 7, 8, 3, ×]
* [×, ×, ×, 9, 4, 5, 7, \color{red}{8}, 3, ×]
* [×, ×, ×, 9, 4, 5, \color{red}{7}, 3, ×]
* [×, ×, ×, 9, 4, 5, 3, ×] (final state)
It is impossible to remove more than 5 elements, hence the weight is 5.
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.StringTokenizer;
public class Task5 {
int[] tree;
int[] lazy;
int[] max;
int n;
private void push(int node) {
max[node * 2] += lazy[node];
max[node * 2 + 1] += lazy[node];
lazy[node *2] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
lazy[node] = 0;
}
private void add(int from, int to, int a, int b, int node) {
if (from <= a && b <= to) {
tree[node]++;
max[node]++;
lazy[node]++;
return;
}
push(node);
int mid = (a + b) / 2;
if (from <= mid) add(from, to, a, mid, node * 2);
if (to > mid) add(from, to, mid + 1, b, node * 2 + 1);
max[node] = Math.max(max[node * 2], max[node * 2 + 1]);
}
private int getValue(int index, int a, int b, int node) {
if (a == b) return tree[node];
int mid = (a + b) / 2;
if (index <= mid) return getValue(index, a, mid, node * 2) + tree[node];
return getValue(index, mid + 1, b, node * 2 +1) + tree[node];
}
private int getLastAtLeast(int num, int a, int b, int node, int sum) {
sum += tree[node];
if (a == b) {
if (sum >= num) return a;
else return -1;
}
push(node);
int mid = (a + b) / 2;
if (max[node *2 + 1] >= num) return getLastAtLeast(num, mid + 1, b, node * 2 + 1, sum);
return getLastAtLeast(num, a, mid, node * 2, sum);
}
public static void main(String[] args) throws IOException {
new Task5().solve();
}
private void solve() throws IOException {
BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
StringTokenizer tokenizer = new StringTokenizer(f.readLine());
n = Integer.parseInt(tokenizer.nextToken());
int q = Integer.parseInt(tokenizer.nextToken());
int[] nums = new int[n];
tokenizer = new StringTokenizer(f.readLine());
for (int i = 0; i < n; i++) {
nums[i] = Integer.parseInt(tokenizer.nextToken()) - 1;
}
tree = new int[4 * n];
max = new int[4 * n];
lazy = new int[4 * n];
ArrayList<int[]>[] queries = new ArrayList[n];
for (int i = 0; i < n; i++) queries[i] = new ArrayList<int[]>();
for (int q1 = 0; q1 < q; q1++) {
tokenizer = new StringTokenizer(f.readLine());
int a = Integer.parseInt(tokenizer.nextToken());
int b = Integer.parseInt(tokenizer.nextToken());
int[] ar = {a, q1};
queries[n - 1 - b].add(ar);
}
tree = new int[4 * n];
int[] queryRes = new int[q];
for (int i = 0; i < n; i++) {
if (nums[i] < i) {
int lastAtLeast = getLastAtLeast(i - nums[i], 0, n - 1, 1, 0);
if (lastAtLeast != -1) add(0, Math.min(lastAtLeast, i), 0, n - 1, 1);
} else if (nums[i] == i) {
add(0, i, 0, n - 1, 1);
}
for (int[] query : queries[i]) {
int res = getValue(query[0], 0, n - 1, 1);
queryRes[query[1]] = res;
}
}
for (int res : queryRes) {
out.println(res);
}
out.close();
}
private static class ArrayComparator implements Comparator<int[]> {
@Override
public int compare(int[] o1, int[] o2) {
return Integer.compare(o1[1], o2[1]);
}
}
}
|
Mr. Chanek has an orchard structured as a rooted ternary tree with N vertices numbered from 1 to N. The root of the tree is vertex 1. P_i denotes the parent of vertex i, for (2 ≤ i ≤ N). Interestingly, the height of the tree is not greater than 10. Height of a tree is defined to be the largest distance from the root to a vertex in the tree.
There exist a bush on each vertex of the tree. Initially, all bushes have fruits. Fruits will not grow on bushes that currently already have fruits. The bush at vertex i will grow fruits after A_i days since its last harvest.
Mr. Chanek will visit his orchard for Q days. In day i, he will harvest all bushes that have fruits on the subtree of vertex X_i. For each day, determine the sum of distances from every harvested bush to X_i, and the number of harvested bush that day. Harvesting a bush means collecting all fruits on the bush.
For example, if Mr. Chanek harvests all fruits on subtree of vertex X, and harvested bushes [Y_1, Y_2, ..., Y_M], the sum of distances is ∑_{i = 1}^M distance(X, Y_i)
distance(U, V) in a tree is defined to be the number of edges on the simple path from U to V.
Input
The first line contains two integers N and Q (1 ≤ N,\ Q,≤ 5 ⋅ 10^4), which denotes the number of vertices and the number of days Mr. Chanek visits the orchard.
The second line contains N integers A_i (1 ≤ A_i ≤ 5 ⋅ 10^4), which denotes the fruits growth speed on the bush at vertex i, for (1 ≤ i ≤ N).
The third line contains N-1 integers P_i (1 ≤ P_i ≤ N, P_i ≠ i), which denotes the parent of vertex i in the tree, for (2 ≤ i ≤ N). It is guaranteed that each vertex can be the parent of at most 3 other vertices. It is also guaranteed that the height of the tree is not greater than 10.
The next Q lines contain a single integer X_i (1 ≤ X_i ≤ N), which denotes the start of Mr. Chanek's visit on day i, for (1 ≤ i ≤ Q).
Output
Output Q lines, line i gives the sum of distances from the harvested bushes to X_i, and the number of harvested bushes.
Examples
Input
2 3
1 2
1
2
1
1
Output
0 1
0 1
1 2
Input
5 3
2 1 1 3 2
1 2 2 1
1
1
1
Output
6 5
3 2
4 4
Note
For the first example:
* On day 1, Mr. Chanek starts at vertex 2 and can harvest the bush at vertex 2.
* On day 2, Mr. Chanek starts at vertex 1 and only harvest from bush 1 (bush 2's fruit still has not grown yet).
* On day 3, Mr. Chanek starts at vertex 1 and harvests the fruits on bush 1 and 2. The sum of distances from every harvested bush to 1 is 1.
For the second example, Mr. Chanek always starts at vertex 1. The bushes which Mr. Chanek harvests on day one, two, and three are [1, 2, 3, 4, 5], [2, 3], [1, 2, 3, 5], respectively.
|
#include <bits/stdc++.h>
using namespace std;
int n, q, ans[50005], sum[50005], a[50005], p[50005], x[50005], cont, pos,
us[50005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 2; i <= n; i++) cin >> p[i];
for (int i = 0; i < q; i++) cin >> x[i];
for (int i = 1; i <= n; i++) {
pos = i;
cont = 1;
while (pos != 1) {
us[pos] = cont;
cont++;
pos = p[pos];
}
us[pos] = cont;
for (int j = 0; j < q; j++) {
if (us[x[j]]) {
ans[j]++;
sum[j] += us[x[j]];
j += a[i] - 1;
}
}
pos = i;
cont = 1;
while (pos != 1) {
us[pos] = 0;
cont++;
pos = p[pos];
}
us[pos] = 0;
}
for (int i = 0; i < q; i++) cout << sum[i] - ans[i] << " " << ans[i] << "\n";
return 0;
}
|
This is the easy version of the problem. The difference between the versions is in the constraints on the array elements. You can make hacks only if all versions of the problem are solved.
You are given an array [a_1, a_2, ..., a_n].
Your goal is to find the length of the longest subarray of this array such that the most frequent value in it is not unique. In other words, you are looking for a subarray such that if the most frequent value occurs f times in this subarray, then at least 2 different values should occur exactly f times.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
The first line contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ min(n, 100)) — elements of the array.
Output
You should output exactly one integer — the length of the longest subarray of the array whose most frequent value is not unique. If there is no such subarray, output 0.
Examples
Input
7
1 1 2 2 3 3 3
Output
6
Input
10
1 1 1 5 4 1 3 1 2 2
Output
7
Input
1
1
Output
0
Note
In the first sample, the subarray [1, 1, 2, 2, 3, 3] is good, but [1, 1, 2, 2, 3, 3, 3] isn't: in the latter there are 3 occurrences of number 3, and no other element appears 3 times.
|
#include <bits/stdc++.h>
std::ifstream fin("input.txt");
std::ofstream fout("output.txt");
int n, value;
int x[200005], a[200005], freq[105];
bool foundSolution;
void readInput() {
std::cin >> n;
for (int i = 0; i < n; i++) std::cin >> x[i];
}
bool sortCond(std::pair<int, int> a, std::pair<int, int> b) {
return a.first > b.first;
}
void findMostFrequent() {
for (int i = 0; i < n; i++) freq[x[i]]++;
std::vector<std::pair<int, int>> v;
for (int i = 1; i <= 100; i++) {
if (freq[i] > 0) v.push_back({freq[i], i});
}
std::sort(v.begin(), v.end(), sortCond);
if (v.size() >= 2 and v[0].first == v[1].first) {
std::cout << n << '\n';
foundSolution = true;
return;
} else
value = v[0].second;
}
int findLenght(int val1, int val2) {
for (int i = 0; i < n; i++) {
if (x[i] == val1)
a[i] = 1;
else if (x[i] == val2)
a[i] = -1;
else
a[i] = 0;
}
std::unordered_map<int, int> first;
first[0] = -1;
if (a[0] != 0) first[a[0]] = 0;
int max = 0;
for (int i = 1; i < n; i++) {
a[i] += a[i - 1];
if (first.find(a[i]) != first.end())
max = std::max(max, i - first[a[i]]);
else
first[a[i]] = i;
}
return max;
}
bool ok[105];
void solve() {
int answer = 0;
for (int i = 0; i < n; i++) {
if (x[i] == value or ok[x[i]] == true) continue;
ok[x[i]] = true;
answer = std::max(answer, findLenght(value, x[i]));
}
std::cout << answer << '\n';
}
int main() {
readInput();
findMostFrequent();
if (foundSolution == false) {
solve();
}
return 0;
}
|
Every year Santa Claus gives gifts to all children. However, each country has its own traditions, and this process takes place in different ways. For example, in Berland you need to solve the New Year's puzzle.
Polycarp got the following problem: given a grid strip of size 2 × n, some cells of it are blocked. You need to check if it is possible to tile all free cells using the 2 × 1 and 1 × 2 tiles (dominoes).
For example, if n = 5 and the strip looks like this (black cells are blocked):
<image>
Then it can be tiled, for example, using two vertical and two horizontal tiles, as in the picture below (different tiles are marked by different colors).
<image>
And if n = 3 and the strip looks like this:
<image>
It is impossible to tile free cells.
Polycarp easily solved this task and received his New Year's gift. Can you solve it?
Input
The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
Each test case is preceded by an empty line.
The first line of each test case contains two integers n and m (1 ≤ n ≤ 10^9, 1 ≤ m ≤ 2 ⋅ 10^5) — the length of the strip and the number of blocked cells on it.
Each of the next m lines contains two integers r_i, c_i (1 ≤ r_i ≤ 2, 1 ≤ c_i ≤ n) — numbers of rows and columns of blocked cells. It is guaranteed that all blocked cells are different, i.e. (r_i, c_i) ≠ (r_j, c_j), i ≠ j.
It is guaranteed that the sum of m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print on a separate line:
* "YES", if it is possible to tile all unblocked squares with the 2 × 1 and 1 × 2 tiles;
* "NO" otherwise.
You can output "YES" and "NO" in any case (for example, the strings yEs, yes, Yes and YES will be recognized as positive).
Example
Input
3
5 2
2 2
1 4
3 2
2 1
2 3
6 4
2 1
2 3
2 4
2 6
Output
YES
NO
NO
Note
The first two test cases are explained in the statement.
In the third test case the strip looks like this:
<image> It is easy to check that the unblocked squares on it can not be tiled.
|
import sys
def solve():
sys.stdin.readline()
n, m = map(int,sys.stdin.readline().split())
dudes = []
for i in range(m):
r, c = map(int,sys.stdin.readline().split())
dudes.append((c,r))
dudes.sort()
dudes.reverse()
cells = []
while dudes:
if not cells or cells[-1][0]!=dudes[-1][0]:
cells.append(dudes[-1])
else:
cells[-1] = (cells[-1][0],3)
dudes.pop()
i = 0
while i < len(cells):
ci, ri = cells[i]
if ri != 3:
if i+1==len(cells):
return False
cn, rn = cells[i+1]
if rn==3:
return False
i += 1
if (ci^cn^ri^rn)&1==0:
return False
i += 1
return True
for _ in range(int(sys.stdin.readline())):
print("YES" if solve() else "NO")
|
You have a board represented as a grid with 2 × n cells.
The first k_1 cells on the first row and first k_2 cells on the second row are colored in white. All other cells are colored in black.
You have w white dominoes (2 × 1 tiles, both cells are colored in white) and b black dominoes (2 × 1 tiles, both cells are colored in black).
You can place a white domino on the board if both board's cells are white and not occupied by any other domino. In the same way, you can place a black domino if both cells are black and not occupied by any other domino.
Can you place all w + b dominoes on the board if you can place dominoes both horizontally and vertically?
Input
The first line contains a single integer t (1 ≤ t ≤ 3000) — the number of test cases.
The first line of each test case contains three integers n, k_1 and k_2 (1 ≤ n ≤ 1000; 0 ≤ k_1, k_2 ≤ n).
The second line of each test case contains two integers w and b (0 ≤ w, b ≤ n).
Output
For each test case, print YES if it's possible to place all w + b dominoes on the board and NO, otherwise.
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as positive answer).
Example
Input
5
1 0 1
1 0
1 1 1
0 0
3 0 0
1 3
4 3 1
2 2
5 4 3
3 1
Output
NO
YES
NO
YES
YES
Note
In the first test case, n = 1, k_1 = 0 and k_2 = 1. It means that 2 × 1 board has black cell (1, 1) and white cell (2, 1). So, you can't place any white domino, since there is only one white cell.
In the second test case, the board of the same size 2 × 1, but both cell are white. Since w = 0 and b = 0, so you can place 0 + 0 = 0 dominoes on the board.
In the third test case, board 2 × 3, but fully colored in black (since k_1 = k_2 = 0), so you can't place any white domino.
In the fourth test case, cells (1, 1), (1, 2), (1, 3), and (2, 1) are white and other cells are black. You can place 2 white dominoes at positions ((1, 1), (2, 1)) and ((1, 2), (1, 3)) and 2 black dominoes at positions ((1, 4), (2, 4)) ((2, 2), (2, 3)).
|
for _ in range(int(input())):
n,k1,k2=[int(x) for x in input().split()]
w,b=[int(x) for x in input().split()]
if k1>k2:
if w<=k2+((k1-k2)//2) and b<=n-k1+((k1-k2)//2):
print("YES")
else:
print("NO")
else:
if w<=k1+((k2-k1)//2) and b<=n-k2+((k2-k1)//2):
print("YES")
else:
print("NO")
|
This is an interactive problem.
This is a hard version of the problem. The difference from the easy version is that in the hard version 1 ≤ t ≤ min(n, 10^4) and the total number of queries is limited to 6 ⋅ 10^4.
Polycarp is playing a computer game. In this game, an array consisting of zeros and ones is hidden. Polycarp wins if he guesses the position of the k-th zero from the left t times.
Polycarp can make no more than 6 ⋅ 10^4 requests totally of the following type:
* ? l r — find out the sum of all elements in positions from l to r (1 ≤ l ≤ r ≤ n) inclusive.
To make the game more interesting, each guessed zero turns into one and the game continues on the changed array. More formally, if the position of the k-th zero was x, then after Polycarp guesses this position, the x-th element of the array will be replaced from 0 to 1.
Help Polycarp win the game.
Interaction
First, your program must read two integers n and t (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ t ≤ min(n, 10^4)).
Then t lines follow, each of which contains one integer k (1 ≤ k ≤ n). It is guaranteed that at the moment of the request the array contains at least k zeros. In order to get the next value of k, you must output the answer for the previous value of k.
After that, you can make no more than 6 ⋅ 10^4 requests in total.
Use the following format to output the answer (it is not a request, it doesn't count in 6 ⋅ 10^4):
* ! x — position of the k-th zero.
Positions in the array are numbered from left to right from 1 to n inclusive.
After printing t answers, your program should exit immediately.
In this task, the interactor is not adaptive. This means that within the same test, the hidden array and the queries do not change.
In case of an incorrect query, -1 will be displayed. When this value is received, your program must immediately exit normally (for example, by calling exit(0)), otherwise, the testing system may issue an arbitrary verdict.
If the number of requests is exceeded, the verdict wrong answer will be displayed.
Your solution may get the verdict Idleness limit exceeded if you don't print anything or forget to flush the output buffer.
To flush the output buffer, you need to do the following immediately after the query output and the end-of-line character:
* fflush(stdout) or cout.flush() in C ++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see the documentation for other languages.
Hacks
Use the following format for hacks:
On the first line print the string s (1 ≤ |s| ≤ 2 ⋅ 10^5), consisting of zeros and ones, and an integer t (1 ≤ t ≤ min(|s|, 10^4)) — hidden array and number of requests, respectively. In the next t lines output the number k (1 ≤ k ≤ |s|).
The hacked solution will not have direct access to the hidden array.
Example
Input
6 2
2
2
1
1
0
1
0
Output
? 4 6
? 1 1
? 1 2
? 5 5
! 5
? 2 2
! 2
Note
In the first test, the array [1, 0, 1, 1, 0, 1] is hidden. After answering the query k=2, the array changed to [1, 0, 1, 1, 1, 1].
|
import java.util.*;
import java.io.*;
public class F1{
private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
private static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
public static void main (String[] args) throws IOException {
String nt[] = br.readLine().split(" ");
int n = Integer.parseInt(nt[0]);
int t = Integer.parseInt(nt[1]);
HashMap<Pair, Integer> map = new HashMap<>();
while(t-- > 0) {
int k = Integer.parseInt(br.readLine());
int passed = 0;
int s = 1, l = n;
int idx = -1;
while(s <= l) {
int mid = s + (l-s)/2;
Pair p = new Pair(s, mid);
if(!map.containsKey(p)) {
bw.write("? " + s + " " + mid + "\n");
bw.flush();
int sum = Integer.parseInt(br.readLine());
map.put(p, sum);
}
int length = mid-s+1;
int zeros = length - map.get(p);
if(k <= zeros) {
idx = mid;
l = mid;
map.put(p, map.get(p)+1);
if(zeros == 1 && s==l)
break;
}else {
passed += zeros;
k -= zeros;
s = mid+1;
}
}
bw.write("! " + idx + "\n");
bw.flush();
}
}
static class Pair {
int x;
int y;
public Pair(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public boolean equals(final Object o) {
if (this == o) {
return true;
}
if (!(o instanceof Pair)) {
return false;
}
final Pair pair = (Pair) o;
if (x != pair.x) {
return false;
}
if (y != pair.y) {
return false;
}
return true;
}
@Override
public int hashCode() {
int result = x;
result = 31 * result + y;
return result;
}
}
}
|
The King of Flatland will organize a knights' tournament! The winner will get half the kingdom and the favor of the princess of legendary beauty and wisdom. The final test of the applicants' courage and strength will be a fencing tournament. The tournament is held by the following rules: the participants fight one on one, the winner (or rather, the survivor) transfers to the next round.
Before the battle both participants stand at the specified points on the Ox axis with integer coordinates. Then they make moves in turn. The first participant moves first, naturally. During a move, the first participant can transfer from the point x to any integer point of the interval [x + a; x + b]. The second participant can transfer during a move to any integer point of the interval [x - b; x - a]. That is, the options for the players' moves are symmetric (note that the numbers a and b are not required to be positive, and if a ≤ 0 ≤ b, then staying in one place is a correct move). At any time the participants can be located arbitrarily relative to each other, that is, it is allowed to "jump" over the enemy in any direction. A participant wins if he uses his move to transfer to the point where his opponent is.
Of course, the princess has already chosen a husband and now she wants to make her sweetheart win the tournament. He has already reached the tournament finals and he is facing the last battle. The princess asks the tournament manager to arrange the tournament finalists in such a way that her sweetheart wins the tournament, considering that both players play optimally. However, the initial location of the participants has already been announced, and we can only pull some strings and determine which participant will be first and which one will be second. But how do we know which participant can secure the victory? Alas, the princess is not learned in the military affairs... Therefore, she asks you to determine how the battle will end considering that both opponents play optimally. Also, if the first player wins, your task is to determine his winning move.
Input
The first line contains four space-separated integers — x1, x2, a and b (x1 ≠ x2, a ≤ b, - 109 ≤ x1, x2, a, b ≤ 109) — coordinates of the points where the first and the second participant start, and the numbers that determine the players' moves, correspondingly.
Output
On the first line print the outcome of the battle as "FIRST" (without the quotes), if both players play optimally and the first player wins. Print "SECOND" (without the quotes) if the second player wins and print "DRAW" (without the quotes), if nobody is able to secure the victory.
If the first player wins, print on the next line the single integer x — the coordinate of the point where the first player should transfer to win. The indicated move should be valid, that is, it should meet the following condition: x1 + a ≤ x ≤ x1 + b. If there are several winning moves, print any of them. If the first participant can't secure the victory, then you do not have to print anything.
Examples
Input
0 2 0 4
Output
FIRST
2
Input
0 2 1 1
Output
SECOND
Input
0 2 0 1
Output
DRAW
Note
In the first sample the first player can win in one move.
In the second sample the first participant must go to point 1, where the second participant immediately goes and wins.
In the third sample changing the position isn't profitable to either participant, so nobody wins.
|
#include <bits/stdc++.h>
using namespace std;
long long x1, x2, a, b;
int main() {
cin >> x1 >> x2 >> a >> b;
long long dx = x1 - x2;
if (a <= 0 && 0 <= b) {
if (-b <= dx && dx <= -a) {
puts("FIRST");
cout << x1 - dx << endl;
} else
puts("DRAW");
return 0;
}
if (dx * a > 0) {
puts("DRAW");
return 0;
}
long long len = abs(a) + abs(b);
dx %= len;
if (dx == 0) {
puts("SECOND");
return 0;
}
if (-b <= dx && dx <= -a) {
puts("FIRST");
cout << x1 - dx << endl;
} else
puts("DRAW");
return 0;
}
|
Let's consider one interesting word game. In this game you should transform one word into another through special operations.
Let's say we have word w, let's split this word into two non-empty parts x and y so, that w = xy. A split operation is transforming word w = xy into word u = yx. For example, a split operation can transform word "wordcut" into word "cutword".
You are given two words start and end. Count in how many ways we can transform word start into word end, if we apply exactly k split operations consecutively to word start.
Two ways are considered different if the sequences of applied operations differ. Two operation sequences are different if exists such number i (1 ≤ i ≤ k), that in the i-th operation of the first sequence the word splits into parts x and y, in the i-th operation of the second sequence the word splits into parts a and b, and additionally x ≠ a holds.
Input
The first line contains a non-empty word start, the second line contains a non-empty word end. The words consist of lowercase Latin letters. The number of letters in word start equals the number of letters in word end and is at least 2 and doesn't exceed 1000 letters.
The third line contains integer k (0 ≤ k ≤ 105) — the required number of operations.
Output
Print a single number — the answer to the problem. As this number can be rather large, print it modulo 1000000007 (109 + 7).
Examples
Input
ab
ab
2
Output
1
Input
ababab
ababab
1
Output
2
Input
ab
ba
2
Output
0
Note
The sought way in the first sample is:
ab → a|b → ba → b|a → ab
In the second sample the two sought ways are:
* ababab → abab|ab → ababab
* ababab → ab|abab → ababab
|
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
from math import gcd, ceil
def prod(a, mod=10**9+7):
ans = 1
for each in a:
ans = (ans * each) % mod
return ans
def lcm(a, b): return a * b // gcd(a, b)
def binary(x, length=16):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
from collections import deque
for _ in range(int(input()) if not True else 1):
#n = int(input())
#n, k = map(int, input().split())
#a, b = map(int, input().split())
#c, d = map(int, input().split())
#a = list(map(int, input().split()))
#b = list(map(int, input().split()))
s1 = deque(k for k in input())
s2 = deque(k for k in input())
n = len(s1)
k = int(input())
if k == 0:
print(int(s1==s2))
quit()
mod = 10**9 + 7
n1pow = [1]
for i in range(696969):
n1pow += [(n1pow[-1]*(n-1)) % mod]
ans0 = 0
for i in range(1, k):
ans0 = (n1pow[i] - ans0) % mod
ans1 = 1
for i in range(1, k):
ans1 = (n1pow[i] - ans1) % mod
#print(ans0, ans1)
total = 0
for t in range(n):
if s1 == s2:
total += ans1 if t else ans0
s1.appendleft(s1.pop())
print(total % mod)
|
In problems on strings one often has to find a string with some particular properties. The problem authors were reluctant to waste time on thinking of a name for some string so they called it good. A string is good if it doesn't have palindrome substrings longer than or equal to d.
You are given string s, consisting only of lowercase English letters. Find a good string t with length |s|, consisting of lowercase English letters, which is lexicographically larger than s. Of all such strings string t must be lexicographically minimum.
We will call a non-empty string s[a ... b] = sasa + 1... sb (1 ≤ a ≤ b ≤ |s|) a substring of string s = s1s2... s|s|.
A non-empty string s = s1s2... sn is called a palindrome if for all i from 1 to n the following fulfills: si = sn - i + 1. In other words, palindrome read the same in both directions.
String x = x1x2... x|x| is lexicographically larger than string y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or there exists such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1. Characters in such strings are compared like their ASCII codes.
Input
The first line contains integer d (1 ≤ d ≤ |s|).
The second line contains a non-empty string s, its length is no more than 4·105 characters. The string consists of lowercase English letters.
Output
Print the good string that lexicographically follows s, has the same length and consists of only lowercase English letters. If such string does not exist, print "Impossible" (without the quotes).
Examples
Input
3
aaaaaaa
Output
aabbcaa
Input
3
zzyzzzz
Output
Impossible
Input
4
abbabbbabbb
Output
abbbcaaabab
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int exp(int x, int n) {
int ret = 1;
while (n) {
if (n & 1) ret = 1LL * ret * x % mod;
x = 1LL * x * x % mod;
n >>= 1;
}
return ret;
}
int inv(int x) { return exp(x, mod - 2); }
int po[400010], invp[400010];
int N, D;
string S, T;
int sum1[400010], sum2[400010], offset;
int calc1(int l, int r) {
return (sum1[r] + mod -
1LL * (l == 0 ? 0 : sum1[l - 1]) * po[r - l + 1] % mod) %
mod;
}
int calc2(int l, int r) {
return (1LL * (sum2[l] + offset) * invp[l] % mod + mod -
(1LL * (sum2[r + 1] + offset) * invp[r + 1] % mod) * po[r - l + 1] %
mod) %
mod;
}
bool chk(int x) {
if (x + 1 >= D && calc1(x - D + 1, x) == calc2(x - D + 1, x)) return true;
if (x + 1 >= D + 1 && calc1(x - D, x) == calc2(x - D, x)) return true;
return false;
}
bool f(int x) {
int t = 1;
for (int i = x; i < N; i++) {
bool ok = false;
for (int j = t ? S[i] - 'a' + 1 : 0; j < 26; j++) {
T.push_back('a' + j);
sum1[i] = 1LL * (i == 0 ? 0 : sum1[i - 1]) * 27 % mod + T[i] - 'a' + 1;
sum1[i] %= mod;
offset += 1LL * po[i] * (T[i] - 'a' + 1) % mod;
offset %= mod;
sum2[i + 1] = mod - offset;
sum2[i + 1] %= mod;
if (chk(i)) {
offset += mod - 1LL * po[i] * (T[i] - 'a' + 1) % mod;
offset %= mod;
T.pop_back();
continue;
} else {
ok = true;
t = 0;
break;
}
}
if (!ok) return false;
if (i == N - 1 && !t) return true;
}
return false;
}
int main() {
po[0] = 1;
for (int i = 1; i < 400010; i++) {
po[i] = 1LL * po[i - 1] * 27 % mod;
}
for (int i = 0; i < 400010; i++) {
invp[i] = inv(po[i]);
}
cin >> D >> S;
N = S.size();
T.clear();
int p = N;
for (int i = 0; i < N; i++) {
T.push_back(S[i]);
sum1[i] = 1LL * (i == 0 ? 0 : sum1[i - 1]) * 27 % mod + T[i] - 'a' + 1;
sum1[i] %= mod;
offset += 1LL * po[i] * (T[i] - 'a' + 1) % mod;
offset %= mod;
sum2[i + 1] = mod - offset;
sum2[i + 1] %= mod;
if (chk(i)) {
p = i;
offset += mod - 1LL * po[i] * (T[i] - 'a' + 1) % mod;
offset %= mod;
T.pop_back();
break;
}
}
for (int i = p; i >= 0; i--) {
if (f(i)) {
cout << T;
return 0;
}
if (i == 0) {
printf("Impossible");
return 0;
}
offset += mod - 1LL * po[i - 1] * (T[i - 1] - 'a' + 1) % mod;
offset %= mod;
T.pop_back();
}
}
|
You are given undirected weighted graph. Find the length of the shortest cycle which starts from the vertex 1 and passes throught all the edges at least once. Graph may contain multiply edges between a pair of vertices and loops (edges from the vertex to itself).
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 15, 0 ≤ m ≤ 2000), n is the amount of vertices, and m is the amount of edges. Following m lines contain edges as a triples x, y, w (1 ≤ x, y ≤ n, 1 ≤ w ≤ 10000), x, y are edge endpoints, and w is the edge length.
Output
Output minimal cycle length or -1 if it doesn't exists.
Examples
Input
3 3
1 2 1
2 3 1
3 1 1
Output
3
Input
3 2
1 2 3
2 3 4
Output
14
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, cnt, tot, flag, s;
int dist[20][20], deg[20], mp[20], dp[1 << 16], vis[20];
void solve() {
int i, j, k, t;
for (i = 1; i <= n; i++) dist[i][i] = 0;
for (k = 1; k <= n; k++) {
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
for (i = 1; i <= n; i++) {
if (vis[i] && dist[1][i] == 0x3f3f3f3f) {
printf("-1\n");
return;
}
}
cnt = 0;
for (i = 1; i <= n; i++) {
if (deg[i] & 1) {
mp[cnt] = i;
cnt++;
}
}
if (cnt == 0) {
printf("%d\n", tot);
return;
}
s = (1 << cnt) - 1;
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
int x, y;
for (i = 0; i <= s; i++) {
for (j = 0; j < cnt; j++) {
if (i & (1 << j)) continue;
x = j;
break;
}
for (j = x + 1; j < cnt; j++) {
if (i & (1 << j)) continue;
int ss = i;
ss |= (1 << x);
ss |= (1 << j);
dp[ss] = min(dp[ss], dp[i] + dist[mp[x]][mp[j]]);
}
}
if (dp[s] >= 0x3f3f3f3f)
printf("-1\n");
else
printf("%d\n", dp[s] + tot);
}
int main() {
int i, j, t;
while (~scanf("%d%d", &n, &m)) {
memset(dist, 0x3f, sizeof(dist));
int u, v, w;
tot = 0;
memset(deg, 0, sizeof(deg));
memset(vis, 0, sizeof(vis));
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
tot += w;
vis[u] = vis[v] = 1;
if (u == v) continue;
dist[u][v] = dist[v][u] = min(dist[u][v], w);
deg[u]++;
deg[v]++;
}
solve();
}
return 0;
}
|
One day Ms Swan bought an orange in a shop. The orange consisted of n·k segments, numbered with integers from 1 to n·k.
There were k children waiting for Ms Swan at home. The children have recently learned about the orange and they decided to divide it between them. For that each child took a piece of paper and wrote the number of the segment that he would like to get: the i-th (1 ≤ i ≤ k) child wrote the number ai (1 ≤ ai ≤ n·k). All numbers ai accidentally turned out to be different.
Now the children wonder, how to divide the orange so as to meet these conditions:
* each child gets exactly n orange segments;
* the i-th child gets the segment with number ai for sure;
* no segment goes to two children simultaneously.
Help the children, divide the orange and fulfill the requirements, described above.
Input
The first line contains two integers n, k (1 ≤ n, k ≤ 30). The second line contains k space-separated integers a1, a2, ..., ak (1 ≤ ai ≤ n·k), where ai is the number of the orange segment that the i-th child would like to get.
It is guaranteed that all numbers ai are distinct.
Output
Print exactly n·k distinct integers. The first n integers represent the indexes of the segments the first child will get, the second n integers represent the indexes of the segments the second child will get, and so on. Separate the printed numbers with whitespaces.
You can print a child's segment indexes in any order. It is guaranteed that the answer always exists. If there are multiple correct answers, print any of them.
Examples
Input
2 2
4 1
Output
2 4
1 3
Input
3 1
2
Output
3 2 1
|
#include <bits/stdc++.h>
const long long inf = 1e9;
const long double eps = 1e-6;
const long long N = 1e6;
const long long M = 1e6;
using namespace std;
void ret(string s) {
cout << s;
exit(0);
}
string s;
int a[100][100], b, ans = 0;
int mx, mn, len = 0, pos, n, k, h;
bool u[1000];
int main() {
cin >> n >> k;
pos = k - 1;
for (int i = 0; i < k; i++) {
cin >> h;
a[i][0] = h;
u[h] = true;
}
for (int i = 1; i <= n * k; i++)
if (!u[i]) {
pos++;
if (pos == k) {
pos = 0;
len++;
}
a[pos][len] = i;
}
for (int i = 0; i < k; i++) {
for (int j = 0; j < n; j++) cout << a[i][j] << " ";
cout << "\n";
}
return 0;
}
|
Emuskald was hired to design an artificial waterfall according to the latest trends in landscape architecture. A modern artificial waterfall consists of multiple horizontal panels affixed to a wide flat wall. The water flows down the top of the wall from panel to panel until it reaches the bottom of the wall.
The wall has height t and has n panels on the wall. Each panel is a horizontal segment at height hi which begins at li and ends at ri. The i-th panel connects the points (li, hi) and (ri, hi) of the plane. The top of the wall can be considered a panel connecting the points ( - 109, t) and (109, t). Similarly, the bottom of the wall can be considered a panel connecting the points ( - 109, 0) and (109, 0). No two panels share a common point.
Emuskald knows that for the waterfall to be aesthetically pleasing, it can flow from panel i to panel j (<image>) only if the following conditions hold:
1. max(li, lj) < min(ri, rj) (horizontal projections of the panels overlap);
2. hj < hi (panel j is below panel i);
3. there is no such panel k (hj < hk < hi) that the first two conditions hold for the pairs (i, k) and (k, j).
Then the flow for <image> is equal to min(ri, rj) - max(li, lj), the length of their horizontal projection overlap.
Emuskald has decided that in his waterfall the water will flow in a single path from top to bottom. If water flows to a panel (except the bottom of the wall), the water will fall further to exactly one lower panel. The total amount of water flow in the waterfall is then defined as the minimum horizontal projection overlap between two consecutive panels in the path of the waterfall. Formally:
1. the waterfall consists of a single path of panels <image>;
2. the flow of the waterfall is the minimum flow in the path <image>.
To make a truly great waterfall Emuskald must maximize this water flow, but there are too many panels and he is having a hard time planning his creation. Below is an example of a waterfall Emuskald wants:
<image>
Help Emuskald maintain his reputation and find the value of the maximum possible water flow.
Input
The first line of input contains two space-separated integers n and t (1 ≤ n ≤ 105, 2 ≤ t ≤ 109), the number of the panels excluding the top and the bottom panels, and the height of the wall. Each of the n following lines contain three space-separated integers hi, li and ri (0 < hi < t, - 109 ≤ li < ri ≤ 109), the height, left and right ends of the i-th panel segment.
It is guaranteed that no two segments share a common point.
Output
Output a single integer — the maximum possible amount of water flow in the desired waterfall.
Examples
Input
5 6
4 1 6
3 2 7
5 9 11
3 10 15
1 13 16
Output
4
Input
6 5
4 2 8
3 1 2
2 2 3
2 6 12
1 0 7
1 8 11
Output
2
Note
The first test case corresponds to the picture.
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = int(1e5) + 10;
const int oo = 1000000005;
struct line {
int h, l, r, dp;
set<int> ptr;
line() {}
line(int h, int l, int r) : h(h), l(l), r(r), dp(-1) {}
bool operator<(const line &B) const {
if (h != B.h) return h < B.h;
return r < B.r;
}
} L[MAX];
struct part {
int l, r, id;
bool operator<(const part &B) const { return l < B.l; }
};
int N, T;
set<part> S, cov;
int overlap(int lo1, int hi1, int lo2, int hi2) {
int l = max(lo1, lo2);
int r = min(hi1, hi2);
return r - l;
}
bool can(int i, part p) {
int over_seg = overlap(L[i].l, L[i].r, L[p.id].l, L[p.id].r);
int over_part = overlap(L[i].l, L[i].r, p.l, p.r);
return over_part > 0 && over_part == over_seg;
}
void process(int i, part p) {
if (overlap(L[i].l, L[i].r, p.l, p.r) <= 0) {
S.insert(p);
return;
}
if (p.l <= L[i].l && L[i].r <= p.r) {
if (p.l < L[i].l) S.insert((part){p.l, L[i].l, p.id});
if (L[i].r < p.r) S.insert((part){L[i].r, p.r, p.id});
} else if (p.l <= L[i].r && L[i].r <= p.r) {
if (L[i].r < p.r) S.insert((part){L[i].r, p.r, p.id});
} else if (p.l <= L[i].l && L[i].l <= p.r) {
if (p.l < L[i].l) S.insert((part){p.l, L[i].l, p.id});
}
}
void make_tree() {
S.insert((part){-oo, oo, 0});
for (int i = 1; i < N; i++) {
cov.clear();
int l = L[i].l, r = L[i].r;
part p = (part){l, r, i};
set<part>::iterator beg = S.upper_bound(p), end;
beg--;
set<part>::iterator it = beg;
for (; it != S.end() && it->l < r; it++) {
if (can(i, *it)) L[i].ptr.insert(it->id);
if (!(l <= it->l && it->r <= r)) cov.insert(*it);
}
end = it;
S.erase(beg, end);
for (it = cov.begin(); it != cov.end(); it++) process(i, *it);
S.insert(p);
}
}
int dfs(int v) {
int &ret = L[v].dp;
if (ret != -1) return ret;
set<int> &ptr = L[v].ptr;
if (v == 0) return ret = 2 * oo;
if (ptr.size() == 0) return ret = -2 * oo;
for (set<int>::iterator it = ptr.begin(); it != ptr.end(); it++) {
int over = overlap(L[v].l, L[v].r, L[*it].l, L[*it].r);
int dp = dfs(*it);
ret = max(ret, min(dp, over));
}
return ret;
}
int main() {
cin >> N >> T;
L[N] = line(oo, -oo, oo);
for (int i = 0; i < N; i++) {
int h, l, r;
cin >> h >> l >> r;
L[i] = line(h, l, r);
}
N++;
L[N++] = line(0, -oo, oo);
sort(L, L + N);
make_tree();
int ans = dfs(N - 1);
cout << ans << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.