input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
Polycarp is an experienced participant in Codehorses programming contests. Now he wants to become a problemsetter.
He sent to the coordinator a set of n problems. Each problem has it's quality, the quality of the i-th problem is ai (ai can be positive, negative or equal to zero). The problems are ordered by expected difficulty, but the difficulty is not related to the quality in any way. The easiest problem has index 1, the hardest problem has index n.
The coordinator's mood is equal to q now. After reading a problem, the mood changes by it's quality. It means that after the coordinator reads a problem with quality b, the value b is added to his mood. The coordinator always reads problems one by one from the easiest to the hardest, it's impossible to change the order of the problems.
If after reading some problem the coordinator's mood becomes negative, he immediately stops reading and rejects the problemset.
Polycarp wants to remove the minimum number of problems from his problemset to make the coordinator's mood non-negative at any moment of time. Polycarp is not sure about the current coordinator's mood, but he has m guesses "the current coordinator's mood q = bi".
For each of m guesses, find the minimum number of problems Polycarp needs to remove so that the coordinator's mood will always be greater or equal to 0 while he reads problems from the easiest of the remaining problems to the hardest.
Input
The first line of input contains two integers n and m (1 ≤ n ≤ 750, 1 ≤ m ≤ 200 000) — the number of problems in the problemset and the number of guesses about the current coordinator's mood.
The second line of input contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109) — the qualities of the problems in order of increasing difficulty.
The third line of input contains m integers b1, b2, ..., bm (0 ≤ bi ≤ 1015) — the guesses of the current coordinator's mood q.
Output
Print m lines, in i-th line print single integer — the answer to the problem with q = bi.
Example
Input
6 3
8 -5 -4 1 -7 4
0 7 3
Output
2
0
1
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long u;
long long a[1000];
long long d[1000];
long long minn = -1e17;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
d[i] = minn;
}
for (int i = n; i >= 0; --i) {
for (int j = n; j >= 0; --j) {
if (j == 0) {
u = minn;
} else
u = d[j - 1];
d[j] = max(min(d[j] + a[i], 0LL), u);
}
}
while (m--) {
scanf("%lld", &u);
int k = lower_bound(d, d + n + 1, -u) - d;
cout << k << endl;
}
return 0;
}
|
Bachgold problem is very easy to formulate. Given a positive integer n represent it as a sum of maximum possible number of prime numbers. One can prove that such representation exists for any integer greater than 1.
Recall that integer k is called prime if it is greater than 1 and has exactly two positive integer divisors — 1 and k.
Input
The only line of the input contains a single integer n (2 ≤ n ≤ 100 000).
Output
The first line of the output contains a single integer k — maximum possible number of primes in representation.
The second line should contain k primes with their sum equal to n. You can print them in any order. If there are several optimal solution, print any of them.
Examples
Input
5
Output
2
2 3
Input
6
Output
3
2 2 2
|
n = int(raw_input())
s = ""
t = 1
while n > 3:
s += "2 "
n -= 2
t += 1
s += str(n)
print t
print s
|
Bearland is a big square on the plane. It contains all points with coordinates not exceeding 106 by the absolute value.
There are n houses in Bearland. The i-th of them is located at the point (xi, yi). The n points are distinct, but some subsets of them may be collinear.
Bear Limak lives in the first house. He wants to destroy his house and build a new one somewhere in Bearland.
Bears don't like big changes. For every three points (houses) pi, pj and pk, the sign of their cross product (pj - pi) × (pk - pi) should be the same before and after the relocation. If it was negative/positive/zero, it should still be negative/positive/zero respectively. This condition should be satisfied for all triples of indices (i, j, k), possibly equal to each other or different than 1. Additionally, Limak isn't allowed to build the house at the point where some other house already exists (but it can be the point where his old house was).
In the formula above, we define the difference and the cross product of points (ax, ay) and (bx, by) as:
(ax, ay) - (bx, by) = (ax - bx, ay - by), (ax, ay) × (bx, by) = ax·by - ay·bx.
Consider a set of possible new placements of Limak's house. Your task is to find the area of that set of points.
Formally, let's say that Limak chooses the new placement randomly (each coordinate is chosen independently uniformly at random from the interval [ - 106, 106]). Let p denote the probability of getting the allowed placement of new house. Let S denote the area of Bearland (S = 4·1012). Your task is to find p·S.
Input
The first line of the input contains an integer T (1 ≤ T ≤ 500) — the number of test cases. The description of the test cases follows.
The first line of the description of a test case contains an integer n (3 ≤ n ≤ 200 000) — the number of houses.
The i-th of the next n lines contains two integers xi and yi ( - 106 ≤ xi, yi ≤ 106) — coordinates of the i-th house. No two houses are located at the same point in the same test case. Limak lives in the first house.
The sum of n won't exceed 200 000.
Output
Print one real value, denoting the area of the set of points that are possible new placements of Limak's house.
Your answer will be considered correct if its absolute or relative error doesn't exceed 10 - 6. More precisely, let the jury's answer be b, and your answer be a. Then your answer will be accepted if and only if <image>.
Example
Input
4
4
5 3
0 1
10 1
3 51
3
-999123 700000
-950000 123456
-950000 987654
3
2 3
10 -1
-4 6
5
1 3
5 2
6 1
4 4
-3 3
Output
250.000000000000
100000000000.000000000000
0.000000000000
6.562500000000
Note
In the sample test, there are 4 test cases.
In the first test case, there are four houses and Limak's one is in (5, 3). The set of valid new placements form a triangle with vertices in points (0, 1), (10, 1) and (3, 51), without its sides. The area of such a triangle is 250.
In the second test case, the set of valid new placements form a rectangle of width 50 000 and height 2 000 000. Don't forget that the new placement must be inside the big square that represents Bearland.
In the third test case, the three given points are collinear. Each cross product is equal to 0 and it should be 0 after the relocation as well. Hence, Limak's new house must lie on the line that goes through the given points. Since it must also be inside the big square, new possible placements are limited to some segment (excluding the two points where the other houses are). The area of any segment is 0.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7;
const long double eps = 1e-7;
int t, n, q, k, s, op, x[N], y[N], xa[N], ya[N];
struct node {
long double x, y;
} e[N], f[N];
struct vec {
long double a, b, c, d;
} w[N], g[N], h[N];
struct vat {
int x, y;
} gt[N];
inline int read() {
int num = 0;
char t = '+', g = getchar();
while (g < 48 || 57 < g) t = g, g = getchar();
while (47 < g && g < 58) num = num * 10 + g - 48, g = getchar();
if (t == '-') return -num;
return num;
}
inline bool cmp(node a, node b) { return atan2(a.y, a.x) < atan2(b.y, b.x); }
inline bool dmp(node a, node b) { return atan2(a.y, a.x) > atan2(b.y, b.x); }
inline bool tmp(vec a, vec b) {
return atan2(a.d - a.b, a.c - a.a) < atan2(b.d - b.b, b.c - b.a);
}
inline bool qmp(vat a, vat b) {
if (a.x == b.x) return a.y < b.y;
return a.x < b.x;
}
inline long double getvac(node a, node b) { return a.x * b.y - a.y * b.x; }
inline void adds(node a, node b) {
swap(a, b);
q++, w[q].a = a.x + x[1], w[q].b = a.y + y[1], w[q].c = b.x + x[1],
w[q].d = b.y + y[1];
}
inline bool eps_check(long double u) {
if (-eps <= u && u <= eps) return 1;
return 0;
}
inline bool node_check(vec u, long double x, long double y) {
node a, b;
a.x = u.c - u.a, a.y = u.d - u.b, b.x = x - u.a, b.y = y - u.b;
return (getvac(a, b) >= -eps);
}
inline node getnode(vec a, vec b) {
node z;
long double f1 = (a.d - a.b) * (b.c - b.a), f2 = (b.d - b.b) * (a.c - a.a),
f3 = (a.b - b.b) * (b.c - b.a) * (a.c - a.a);
f3 = f3 - f1 * a.a + f2 * b.a;
z.x = f3 / (f2 - f1);
if (eps_check(a.a - a.c)) swap(a, b);
z.y = (z.x - a.a) * (a.d - a.b) / (a.c - a.a) + a.b;
return z;
}
inline bool check(vec a, vec b, vec c) {
node z = getnode(b, c);
return node_check(a, z.x, z.y);
}
inline bool getvat(node a, node b) {
a.x -= b.x, a.y -= b.y, b.x = -b.x, b.y = -b.y;
return (getvac(a, b) <= eps);
}
inline bool getvas(node a, node b) {
a.x -= b.x, a.y -= b.y, b.x = -b.x, b.y = -b.y;
return (getvac(a, b) <= -eps);
}
inline int gcd(int a, int b) {
if (!b) return a;
return gcd(b, a % b);
}
int main() {
t = read();
bool og = 0;
while (t--) {
n = read(), q = 0, k = 0, op = 0;
bool fl = 0;
for (int i = 1; i <= n; i++) xa[i] = x[i] = read(), ya[i] = y[i] = read();
for (int i = 2; i <= n; i++)
x[i] = x[i] - x[1], y[i] = y[i] - y[1], e[i - 1].x = x[i],
e[i - 1].y = y[i];
n--;
for (int i = 2; i <= n + 1; i++) {
int z = gcd(abs(x[i]), abs(y[i]));
x[i] /= z, y[i] /= z;
if (x[i] < 0) x[i] = -x[i], y[i] = -y[i];
if (x[i] == 0) y[i] = 1;
if (y[i] == 0) x[i] = 1;
op++, gt[op].x = x[i], gt[op].y = y[i];
}
sort(gt + 1, gt + op + 1, qmp);
for (int i = 2; i <= op; i++)
if (gt[i - 1].x == gt[i].x && gt[i - 1].y == gt[i].y) fl = 1;
sort(e + 1, e + n + 1, cmp);
for (int i = 1; i <= n; i++) e[i + n] = e[i];
int j = 1;
for (int i = 1; i <= n; i++) {
j = max(j, i + 1);
while (j <= i + n - 2 && getvat(e[i], e[j + 1])) j++;
if (getvat(e[i], e[j])) adds(e[i], e[j]);
if (getvat(e[i], e[i + 1])) adds(e[i], e[i + 1]);
}
q++, w[q].a = -1000000, w[q].b = 1000000, w[q].c = 1000000,
w[q].d = 1000000;
q++, w[q].a = 1000000, w[q].b = 1000000, w[q].c = 1000000,
w[q].d = -1000000;
q++, w[q].a = 1000000, w[q].b = -1000000, w[q].c = -1000000,
w[q].d = -1000000;
q++, w[q].a = -1000000, w[q].b = -1000000, w[q].c = -1000000,
w[q].d = 1000000;
sort(w + 1, w + q + 1, tmp), g[1] = w[1], k = 1;
for (int i = 2; i <= q; i++) {
if (eps_check(atan2(w[i].d - w[i].b, w[i].c - w[i].a) -
atan2(g[k].d - g[k].b, g[k].c - g[k].a))) {
if (node_check(w[i], g[k].a, g[k].b)) g[k] = w[i];
} else
g[++k] = w[i];
}
int l = 1, r = 2;
for (int i = 1; i <= 2; i++) h[i] = g[i];
for (int i = 3; i <= k; i++) {
if (i == 3) {
node a, b;
a = getnode(h[1], h[2]);
b = getnode(h[2], h[1]);
}
while (r - l >= 1 && check(g[i], h[r], h[r - 1])) r--;
while (r - l >= 1 && check(g[i], h[l], h[l + 1])) l++;
h[++r] = g[i];
}
while (r - l >= 2 && check(h[l], h[r], h[r - 1])) r--;
if (r - l <= 1 || fl) {
if (!og) printf("0\n");
} else {
s = 0;
long double ans = 0;
for (int i = l; i < r; i++) f[++s] = getnode(h[i], h[i + 1]);
f[++s] = getnode(h[l], h[r]);
for (int i = 2; i <= s; i++) f[i].y -= f[1].y, f[i].x -= f[1].x;
for (int i = 2; i < s; i++) ans = ans + abs(getvac(f[i], f[i + 1])) / 2;
printf("%.9Lf\n", ans);
}
}
}
|
Zane once had a good sequence a consisting of n integers a1, a2, ..., an — but he has lost it.
A sequence is said to be good if and only if all of its integers are non-negative and do not exceed 109 in value.
<image>
However, Zane remembers having played around with his sequence by applying m operations to it.
There are two types of operations:
1. Find the maximum value of integers with indices i such that l ≤ i ≤ r, given l and r.
2. Assign d as the value of the integer with index k, given k and d.
After he finished playing, he restored his sequence to the state it was before any operations were applied. That is, sequence a was no longer affected by the applied type 2 operations. Then, he lost his sequence at some time between now and then.
Fortunately, Zane remembers all the operations and the order he applied them to his sequence, along with the distinct results of all type 1 operations. Moreover, among all good sequences that would produce the same results when the same operations are applied in the same order, he knows that his sequence a has the greatest cuteness.
We define cuteness of a sequence as the bitwise OR result of all integers in such sequence. For example, the cuteness of Zane's sequence a is a1 OR a2 OR ... OR an.
Zane understands that it might not be possible to recover exactly the lost sequence given his information, so he would be happy to get any good sequence b consisting of n integers b1, b2, ..., bn that:
1. would give the same results when the same operations are applied in the same order, and
2. has the same cuteness as that of Zane's original sequence a.
If there is such a sequence, find it. Otherwise, it means that Zane must have remembered something incorrectly, which is possible.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 3·105) — the number of integers in Zane's original sequence and the number of operations that have been applied to the sequence, respectively.
The i-th of the following m lines starts with one integer ti (<image>) — the type of the i-th operation.
If the operation is type 1 (ti = 1), then three integers li, ri, and xi follow (1 ≤ li ≤ ri ≤ n, 0 ≤ xi ≤ 109) — the leftmost index to be considered, the rightmost index to be considered, and the maximum value of all integers with indices between li and ri, inclusive, respectively.
If the operation is type 2 (ti = 2), then two integers ki and di follow (1 ≤ ki ≤ n, 0 ≤ di ≤ 109) — meaning that the integer with index ki should become di after this operation.
It is guaranteed that xi ≠ xj for all pairs (i, j) where 1 ≤ i < j ≤ m and ti = tj = 1.
The operations are given in the same order they were applied. That is, the operation that is given first was applied first, the operation that is given second was applied second, and so on.
Output
If there does not exist a valid good sequence, print "NO" (without quotation marks) in the first line.
Otherwise, print "YES" (without quotation marks) in the first line, and print n space-separated integers b1, b2, ..., bn (0 ≤ bi ≤ 109) in the second line.
If there are multiple answers, print any of them.
Examples
Input
5 4
1 1 5 19
1 2 5 1
2 5 100
1 1 5 100
Output
YES
19 0 0 0 1
Input
5 2
1 1 5 0
1 1 5 100
Output
NO
Note
In the first sample, it is easy to verify that this good sequence is valid. In particular, its cuteness is 19 OR 0 OR 0 OR 0 OR 1 = 19.
In the second sample, the two operations clearly contradict, so there is no such good sequence.
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
template <class T, class U>
inline void Max(T &a, U b) {
if (a < b) a = b;
}
template <class T, class U>
inline void Min(T &a, U b) {
if (a > b) a = b;
}
inline void add(int &a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
int pow(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = ans * (long long)a % 1000000007;
a = (long long)a * a % 1000000007;
b >>= 1;
}
return ans;
}
int ans[300010], vis[300010], a[300010];
struct MAX_tree {
int t[300010 << 2];
void build(int p, int l, int r) {
t[p] = -1;
if (l < r) {
int m = (l + r) >> 1;
build(p << 1, l, m);
build(p << 1 | 1, m + 1, r);
}
}
void build(int p, int l, int r, int a[]) {
if (l == r) t[p] = a[l];
if (l < r) {
int m = (l + r) >> 1;
build(p << 1, l, m, a);
build(p << 1 | 1, m + 1, r, a);
t[p] = max(t[p << 1], t[p << 1 | 1]);
}
}
void upd(int p, int l, int r, int first, int v) {
if (l == r) {
t[p] = v;
return;
}
int m = (l + r) >> 1;
if (first <= m)
upd(p << 1, l, m, first, v);
else
upd(p << 1 | 1, m + 1, r, first, v);
t[p] = max(t[p << 1], t[p << 1 | 1]);
}
int query(int p, int l, int r, int first, int second) {
if (l >= first && r <= second) return t[p];
int m = (l + r) >> 1, ans = -1;
if (first <= m) ans = query(p << 1, l, m, first, second);
if (second > m) Max(ans, query(p << 1 | 1, m + 1, r, first, second));
return ans;
}
} t1;
struct MIN_tree {
int t[300010 << 2];
void build(int p, int l, int r) {
t[p] = 1000000007;
if (l < r) {
int m = (l + r) >> 1;
build(p << 1, l, m);
build(p << 1 | 1, m + 1, r);
}
}
void upd(int p, int l, int r, int first, int second, int v) {
if (l >= first && r <= second) {
Min(t[p], v);
return;
}
int m = (l + r) >> 1;
if (first <= m) upd(p << 1, l, m, first, second, v);
if (second > m) upd(p << 1 | 1, m + 1, r, first, second, v);
}
int query(int p, int l, int r, int first) {
if (l == r) return t[p];
int m = (l + r) >> 1, ans = 1000000007;
if (first <= m)
ans = min(t[p], query(p << 1, l, m, first));
else
ans = min(t[p], query(p << 1 | 1, m + 1, r, first));
return ans;
}
} t2;
struct Q {
int l, r, first;
} p[300010];
int main() {
int T, i, j, k, ca = 0, m, K, n;
scanf("%d%d", &n, &m);
t1.build(1, 1, n);
t2.build(1, 1, n);
int ok = 1;
for (int i = 0; i < m; i++) {
scanf("%d", &K);
int l, r, first;
if (K == 1) {
scanf("%d%d%d", &l, &r, &first);
if (!ok) {
continue;
}
K = t1.query(1, 1, n, l, r);
if (K > first) {
ok = 0;
continue;
}
t2.upd(1, 1, n, l, r, first);
p[i] = {l, r, first};
} else {
scanf("%d%d", &k, &first);
if (!ok) {
continue;
}
if (!vis[k]) {
vis[k] = 1;
ans[k] = t2.query(1, 1, n, k);
}
t1.upd(1, 1, n, k, first);
p[i] = {k, first, -1};
}
}
if (!ok) {
puts("NO");
return 0;
}
int ss = 0;
K = 0;
int bit[33] = {0};
for (int i = 1; i < n + 1; i++)
if (!vis[i]) ans[i] = t2.query(1, 1, n, i);
for (int i = 1; i < n + 1; i++)
if (ans[i] < 1000000007) ss |= ans[i];
vector<pair<int, int> > q;
for (int i = 1; i < n + 1; i++) {
j = i;
while (j <= n && ans[j] == ans[i]) j++;
if (ans[i] == 1000000007) {
for (int k = i; k < j; k++) q.push_back({1e9, k});
} else {
for (int k = i + 1; k < j; k++) q.push_back({ans[i], k});
}
i = j - 1;
}
for (int i = 30 - 1; i >= 0; i--)
if (!(ss >> i & 1)) {
bit[i] = 1;
}
for (auto o : q) {
int first = o.second, second = o.first, ss = 0;
for (int j = 30 - 1; j >= 0; j--)
if (bit[j] && ss + (1 << j) <= second) {
bit[j] = 0;
ss += 1 << j;
}
ans[first] = ss;
}
for (int i = 1; i < n + 1; i++) a[i] = ans[i];
t1.build(1, 1, n, a);
for (int i = 0; i < m; i++) {
if (p[i].first == -1) {
t1.upd(1, 1, n, p[i].l, p[i].r);
} else {
K = t1.query(1, 1, n, p[i].l, p[i].r);
if (K != p[i].first) {
return 0 * puts("NO");
}
}
}
puts("YES");
ss = 0;
for (int i = 1; i < n + 1; i++) printf("%d ", ans[i]), ss |= ans[i];
puts("");
return 0;
}
|
After returning from the army Makes received a gift — an array a consisting of n positive integer numbers. He hadn't been solving problems for a long time, so he became interested to answer a particular question: how many triples of indices (i, j, k) (i < j < k), such that ai·aj·ak is minimum possible, are there in the array? Help him with it!
Input
The first line of input contains a positive integer number n (3 ≤ n ≤ 105) — the number of elements in array a. The second line contains n positive integer numbers ai (1 ≤ ai ≤ 109) — the elements of a given array.
Output
Print one number — the quantity of triples (i, j, k) such that i, j and k are pairwise distinct and ai·aj·ak is minimum possible.
Examples
Input
4
1 1 1 1
Output
4
Input
5
1 3 2 3 4
Output
2
Input
6
1 3 3 1 3 2
Output
1
Note
In the first example Makes always chooses three ones out of four, and the number of ways to choose them is 4.
In the second example a triple of numbers (1, 2, 3) is chosen (numbers, not indices). Since there are two ways to choose an element 3, then the answer is 2.
In the third example a triple of numbers (1, 1, 2) is chosen, and there's only one way to choose indices.
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int M = 1e5 + 3;
const int N = 4;
const int mo = 1e9 + 7;
const LL inf = 1e18 + 1;
map<int, LL> mp;
LL a[M];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
mp[x]++;
}
int cnt = 0;
int sum = 0;
for (auto &e : mp) {
a[cnt++] = e.second;
sum += e.second;
if (sum >= 3) break;
}
LL res = 0;
if (cnt == 1)
res = a[0] * (a[0] - 1) * (a[0] - 2) / 6;
else if (cnt == 2) {
if (a[0] == 1)
res = a[1] * (a[1] - 1) / 2;
else
res = a[1];
} else
res = a[2];
printf("%I64d\n", res);
return 0;
}
|
Gleb ordered pizza home. When the courier delivered the pizza, he was very upset, because several pieces of sausage lay on the crust, and he does not really like the crust.
The pizza is a circle of radius r and center at the origin. Pizza consists of the main part — circle of radius r - d with center at the origin, and crust around the main part of the width d. Pieces of sausage are also circles. The radius of the i -th piece of the sausage is ri, and the center is given as a pair (xi, yi).
Gleb asks you to help determine the number of pieces of sausage caught on the crust. A piece of sausage got on the crust, if it completely lies on the crust.
Input
First string contains two integer numbers r and d (0 ≤ d < r ≤ 500) — the radius of pizza and the width of crust.
Next line contains one integer number n — the number of pieces of sausage (1 ≤ n ≤ 105).
Each of next n lines contains three integer numbers xi, yi and ri ( - 500 ≤ xi, yi ≤ 500, 0 ≤ ri ≤ 500), where xi and yi are coordinates of the center of i-th peace of sausage, ri — radius of i-th peace of sausage.
Output
Output the number of pieces of sausage that lay on the crust.
Examples
Input
8 4
7
7 8 1
-7 3 2
0 2 1
0 -2 2
-3 -3 1
0 6 2
5 3 1
Output
2
Input
10 8
4
0 0 9
0 0 10
1 0 1
1 0 2
Output
0
Note
Below is a picture explaining the first example. Circles of green color denote pieces of sausage lying on the crust.
<image>
|
'''input
8 4
7
7 8 1
-7 3 2
0 2 1
0 -2 2
-3 -3 1
0 6 2
5 3 1
'''
r, d = map(int, input().split())
n = int(input())
c = 0
for _ in range(n):
x, y, r1 = map(int, input().split())
s = (x**2 + y**2)**0.5
if r-d <= s-r1 and s+r1 <= r:
c += 1
print(c)
|
Vadim is really keen on travelling. Recently he heard about kayaking activity near his town and became very excited about it, so he joined a party of kayakers.
Now the party is ready to start its journey, but firstly they have to choose kayaks. There are 2·n people in the group (including Vadim), and they have exactly n - 1 tandem kayaks (each of which, obviously, can carry two people) and 2 single kayaks. i-th person's weight is wi, and weight is an important matter in kayaking — if the difference between the weights of two people that sit in the same tandem kayak is too large, then it can crash. And, of course, people want to distribute their seats in kayaks in order to minimize the chances that kayaks will crash.
Formally, the instability of a single kayak is always 0, and the instability of a tandem kayak is the absolute difference between weights of the people that are in this kayak. Instability of the whole journey is the total instability of all kayaks.
Help the party to determine minimum possible total instability!
Input
The first line contains one number n (2 ≤ n ≤ 50).
The second line contains 2·n integer numbers w1, w2, ..., w2n, where wi is weight of person i (1 ≤ wi ≤ 1000).
Output
Print minimum possible total instability.
Examples
Input
2
1 2 3 4
Output
1
Input
4
1 3 4 6 3 4 100 200
Output
5
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class B {
public static void main(String[] args) {
FastScanner scan = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
int n = scan.nextInt()*2;
int[] a = scan.nextIntArray(n);
Arrays.sort(a);
int res = 0x3f3f3f3f;
for(int i = 0; i < n; i++) {
for(int j = i+1; j < n; j++) {
int[] b = new int[n-2];
int idx = 0;
for(int k = 0; k < n; k++) if(k != i && k != j) b[idx++] = a[k];
int c = 0;
for(int k = 0; k < n-2; k+=2) c += b[k+1]-b[k];
res = Math.min(res, c);
}
}
out.println(res);
out.close();
}
static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner() {
try {
br = new BufferedReader(new InputStreamReader(System.in));
st = new StringTokenizer(br.readLine());
} catch (Exception e){e.printStackTrace();}
}
public String next() {
if (st.hasMoreTokens()) return st.nextToken();
try {st = new StringTokenizer(br.readLine());}
catch (Exception e) {e.printStackTrace();}
return st.nextToken();
}
public int nextInt() {return Integer.parseInt(next());}
public long nextLong() {return Long.parseLong(next());}
public double nextDouble() {return Double.parseDouble(next());}
public String nextLine() {
String line = "";
if(st.hasMoreTokens()) line = st.nextToken();
else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
while(st.hasMoreTokens()) line += " "+st.nextToken();
return line;
}
public int[] nextIntArray(int n) {
int[] a = new int[n];
for(int i = 0; i < n; i++) a[i] = nextInt();
return a;
}
public long[] nextLongArray(int n){
long[] a = new long[n];
for(int i = 0; i < n; i++) a[i] = nextLong();
return a;
}
public double[] nextDoubleArray(int n){
double[] a = new double[n];
for(int i = 0; i < n; i++) a[i] = nextDouble();
return a;
}
public char[][] nextGrid(int n, int m){
char[][] grid = new char[n][m];
for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
return grid;
}
}
}
|
There are n points marked on the plane. The points are situated in such a way that they form a regular polygon (marked points are its vertices, and they are numbered in counter-clockwise order). You can draw n - 1 segments, each connecting any two marked points, in such a way that all points have to be connected with each other (directly or indirectly).
But there are some restrictions. Firstly, some pairs of points cannot be connected directly and have to be connected undirectly. Secondly, the segments you draw must not intersect in any point apart from the marked points (that is, if any two segments intersect and their intersection is not a marked point, then the picture you have drawn is invalid).
How many ways are there to connect all vertices with n - 1 segments? Two ways are considered different iff there exist some pair of points such that a segment is drawn between them in the first way of connection, but it is not drawn between these points in the second one. Since the answer might be large, output it modulo 109 + 7.
Input
The first line contains one number n (3 ≤ n ≤ 500) — the number of marked points.
Then n lines follow, each containing n elements. ai, j (j-th element of line i) is equal to 1 iff you can connect points i and j directly (otherwise ai, j = 0). It is guaranteed that for any pair of points ai, j = aj, i, and for any point ai, i = 0.
Output
Print the number of ways to connect points modulo 109 + 7.
Examples
Input
3
0 0 1
0 0 1
1 1 0
Output
1
Input
4
0 1 1 1
1 0 1 1
1 1 0 1
1 1 1 0
Output
12
Input
3
0 0 0
0 0 1
0 1 0
Output
0
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7, n, a[505][505], f[505][505], g[505][505];
int main() {
scanf("%lld", &n);
for (register int i = 1; i <= n; i++) {
for (register int j = 1; j <= n; j++) {
scanf("%lld", &a[i][j]);
}
}
for (register int i = 1; i <= n; i++) {
f[i][i] = 1;
}
for (register int len = 2; len <= n; len++) {
for (register int l = 1; l + len - 1 <= n; l++) {
int r = l + len - 1;
if (a[l][r]) {
for (register int k = l; k < r; k++) {
f[l][r] = (f[l][r] +
(f[l][k] + g[l][k]) * (f[k + 1][r] + g[k + 1][r]) % mod) %
mod;
}
}
for (register int k = l + 1; k < r; k++) {
if (a[l][k]) {
g[l][r] = (g[l][r] + f[l][k] * (g[k][r] + f[k][r]) % mod) % mod;
}
}
}
}
printf("%lld\n", (f[1][n] + g[1][n]) % mod);
return 0;
}
|
A permutation of size n is an array of size n such that each integer from 1 to n occurs exactly once in this array. An inversion in a permutation p is a pair of indices (i, j) such that i > j and ai < aj. For example, a permutation [4, 1, 3, 2] contains 4 inversions: (2, 1), (3, 1), (4, 1), (4, 3).
You are given a permutation a of size n and m queries to it. Each query is represented by two indices l and r denoting that you have to reverse the segment [l, r] of the permutation. For example, if a = [1, 2, 3, 4] and a query l = 2, r = 4 is applied, then the resulting permutation is [1, 4, 3, 2].
After each query you have to determine whether the number of inversions is odd or even.
Input
The first line contains one integer n (1 ≤ n ≤ 1500) — the size of the permutation.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ n) — the elements of the permutation. These integers are pairwise distinct.
The third line contains one integer m (1 ≤ m ≤ 2·105) — the number of queries to process.
Then m lines follow, i-th line containing two integers li, ri (1 ≤ li ≤ ri ≤ n) denoting that i-th query is to reverse a segment [li, ri] of the permutation. All queries are performed one after another.
Output
Print m lines. i-th of them must be equal to odd if the number of inversions in the permutation after i-th query is odd, and even otherwise.
Examples
Input
3
1 2 3
2
1 2
2 3
Output
odd
even
Input
4
1 2 4 3
4
1 1
1 4
1 4
2 3
Output
odd
odd
odd
even
Note
The first example:
1. after the first query a = [2, 1, 3], inversion: (2, 1);
2. after the second query a = [2, 3, 1], inversions: (3, 1), (3, 2).
The second example:
1. a = [1, 2, 4, 3], inversion: (4, 3);
2. a = [3, 4, 2, 1], inversions: (3, 1), (4, 1), (3, 2), (4, 2), (4, 3);
3. a = [1, 2, 4, 3], inversion: (4, 3);
4. a = [1, 4, 2, 3], inversions: (3, 2), (4, 2).
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1);
const double ERR = 1e-8;
const int MAXN = 1e7;
int a[2000], n;
int main(int argc, char const *argv[]) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int l, r, m;
scanf("%d", &m);
int c = 0;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (a[i] > a[j]) c++;
}
}
while (m--) {
scanf("%d%d", &l, &r);
if (l < r) {
int t = (r - l + 1);
c += (t * (t - 1) / 2) % 2;
}
if (!(c % 2))
printf("even\n");
else
printf("odd\n");
}
return 0;
}
|
In order to put away old things and welcome a fresh new year, a thorough cleaning of the house is a must.
Little Tommy finds an old polynomial and cleaned it up by taking it modulo another. But now he regrets doing this...
Given two integers p and k, find a polynomial f(x) with non-negative integer coefficients strictly less than k, whose remainder is p when divided by (x + k). That is, f(x) = q(x)·(x + k) + p, where q(x) is a polynomial (not necessarily with integer coefficients).
Input
The only line of input contains two space-separated integers p and k (1 ≤ p ≤ 1018, 2 ≤ k ≤ 2 000).
Output
If the polynomial does not exist, print a single integer -1, or output two lines otherwise.
In the first line print a non-negative integer d — the number of coefficients in the polynomial.
In the second line print d space-separated integers a0, a1, ..., ad - 1, describing a polynomial <image> fulfilling the given requirements. Your output should satisfy 0 ≤ ai < k for all 0 ≤ i ≤ d - 1, and ad - 1 ≠ 0.
If there are many possible solutions, print any of them.
Examples
Input
46 2
Output
7
0 1 0 0 1 1 1
Input
2018 214
Output
3
92 205 1
Note
In the first example, f(x) = x6 + x5 + x4 + x = (x5 - x4 + 3x3 - 6x2 + 12x - 23)·(x + 2) + 46.
In the second example, f(x) = x2 + 205x + 92 = (x - 9)·(x + 214) + 2018.
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
string sep;
for (const auto &x : v) os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
template <typename T>
void output_vector(const vector<T> &v, bool add_one = false, int start = -1,
int end = -1) {
if (start < 0) start = 0;
if (end < 0) end = v.size();
for (int i = start; i < end; i++)
cout << v[i] + (add_one ? 1 : 0) << (i < end - 1 ? ' ' : '\n');
}
int main() {
int64_t P, K;
cin >> P >> K;
vector<int64_t> A;
do {
int64_t remainder = (P % K + K) % K;
A.push_back(remainder);
P -= remainder;
P /= -K;
} while (P != 0);
cout << A.size() << '\n';
output_vector(A);
}
|
Petya likes horse racing very much. Horses numbered from l to r take part in the races. Petya wants to evaluate the probability of victory; for some reason, to do that he needs to know the amount of nearly lucky horses' numbers. A nearly lucky number is an integer number that has at least two lucky digits the distance between which does not exceed k. Petya learned from some of his mates from Lviv that lucky digits are digits 4 and 7. The distance between the digits is the absolute difference between their positions in the number of a horse. For example, if k = 2, then numbers 412395497, 404, 4070400000070004007 are nearly lucky and numbers 4, 4123954997, 4007000040070004007 are not.
Petya prepared t intervals [li, ri] and invented number k, common for all of them. Your task is to find how many nearly happy numbers there are in each of these segments. Since the answers can be quite large, output them modulo 1000000007 (109 + 7).
Input
The first line contains two integers t and k (1 ≤ t, k ≤ 1000) — the number of segments and the distance between the numbers correspondingly. Next t lines contain pairs of integers li and ri (1 ≤ l ≤ r ≤ 101000). All numbers are given without the leading zeroes. Numbers in each line are separated by exactly one space character.
Output
Output t lines. In each line print one integer — the answer for the corresponding segment modulo 1000000007 (109 + 7).
Examples
Input
1 2
1 100
Output
4
Input
1 2
70 77
Output
2
Input
2 1
1 20
80 100
Output
0
0
Note
In the first sample, the four nearly lucky numbers are 44, 47, 74, 77.
In the second sample, only 74 and 77 are in the given segment.
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int cs, ln, q;
long long int p[2][2][1009][1009], p0[1009][1009];
bool bl0[1009][1009];
char bl[2][2][1009][1009];
char a[1009], b[1009];
long long int dppr(int i, int k) {
if (i == -1) {
if (k == 1005) return 1LL;
return 0;
}
long long int &pr = p0[i][k];
if (bl0[i][k] == 1) return pr;
bl0[i][k] = 1;
pr = 0ll;
int qk;
for (int j = 0; j <= 9; j++) {
qk = k;
if (k != 1005 && (j == 4 || j == 7)) {
if (k == 1004)
qk = i;
else if (qk - i <= q)
qk = 1005;
else
qk = i;
}
pr += dppr(i - 1, qk);
if (pr >= 1000000007LL) pr -= 1000000007LL;
}
return pr;
}
long long int qry(bool bg, bool sm, int i, int k) {
if (i == -1) {
if (k == 1005) return 1LL;
return 0;
}
long long int &pr = p[bg][sm][i][k];
if (bl[bg][sm][i][k] == cs) return pr;
bl[bg][sm][i][k] = cs;
if (bg == 1 && sm == 1) {
return pr = dppr(i, k);
}
pr = 0ll;
bool qbg, qsm;
int l, r, qk;
l = (bg == 1) ? 0 : (a[i] - '0');
r = (sm == 1) ? 9 : (b[i] - '0');
for (int j = l; j <= r; j++) {
qbg = (bg == 1) ? 1 : (j > l);
qsm = (sm == 1) ? 1 : (j < r);
qk = k;
if (k != 1005 && (j == 4 || j == 7)) {
if (k == 1004)
qk = i;
else if (qk - i <= q)
qk = 1005;
else
qk = i;
}
pr += qry(qbg, qsm, i - 1, qk);
if (pr >= 1000000007LL) pr -= 1000000007LL;
}
return pr;
}
int main() {
cs = 1;
int t, i, j, k;
scanf("%d%d", &t, &q);
while (t--) {
scanf(" %s %s", a, b);
j = strlen(a);
ln = strlen(b);
reverse(&a[0], &a[j]);
reverse(&b[0], &b[ln]);
for (i = j; i < 1003; i++) a[i] = '0';
for (i = ln; i < 1003; i++) b[i] = '0';
printf("%I64d\n", qry(0, 0, 1002, 1004));
cs++;
}
return 0;
}
|
Year 2118. Androids are in mass production for decades now, and they do all the work for humans. But androids have to go to school to be able to solve creative tasks. Just like humans before.
It turns out that high school struggles are not gone. If someone is not like others, he is bullied. Vasya-8800 is an economy-class android which is produced by a little-known company. His design is not perfect, his characteristics also could be better. So he is bullied by other androids.
One of the popular pranks on Vasya is to force him to compare x^y with y^x. Other androids can do it in milliseconds while Vasya's memory is too small to store such big numbers.
Please help Vasya! Write a fast program to compare x^y with y^x for Vasya, maybe then other androids will respect him.
Input
On the only line of input there are two integers x and y (1 ≤ x, y ≤ 10^{9}).
Output
If x^y < y^x, then print '<' (without quotes). If x^y > y^x, then print '>' (without quotes). If x^y = y^x, then print '=' (without quotes).
Examples
Input
5 8
Output
>
Input
10 3
Output
<
Input
6 6
Output
=
Note
In the first example 5^8 = 5 ⋅ 5 ⋅ 5 ⋅ 5 ⋅ 5 ⋅ 5 ⋅ 5 ⋅ 5 = 390625, and 8^5 = 8 ⋅ 8 ⋅ 8 ⋅ 8 ⋅ 8 = 32768. So you should print '>'.
In the second example 10^3 = 1000 < 3^{10} = 59049.
In the third example 6^6 = 46656 = 6^6.
|
import math
x,y=map(lambda x:math.log(int(x))/int(x),input().split())
print('<=>'[(x>=y)+(x>y)])
|
There are N (labelled 1 to N) kingdoms in a country. Our king Alexander is living in the kingdom S. We are given R distances, these distances are between two kingdoms and the distance between any two kingdom may or may not be unique.
Now Alexander wants to visit each kingdom in minimum distance possible starting from his kingdom S.
If a kingdom is unreachable the distance is assumed as -1.
INPUT:::
The first line denotes T, the number of test cases.
First line of each test case has two integers, denoting the no of kingdom "N" and the next number denotes the no of distance given between two different kingdoms "R".
The next "R" line contains three integers x,y,d, the first two numbers denoting kingdom number and the next integer denotes the distance between them.
If the distance between two kingdom say a and b is given as x then this distance will remain same if the Alexander travels from a to b or from b to a.
The last line of test case denotes the kingdom in which Alexander is living.
Note::: If there are many distances given between the same two kingdoms then it is considered that Alexander has many different ways to travel between these two kingdoms.
Output:::
For each test case print a single line containing N-1 space separated integers denoting the shortest distance of N-1 kingdoms from Alexander's Kingdom.
For unreachable kingdoms print "-1".
Constraints:::
1≤T≤10,
2≤N≤3000,
1≤R≤N×(N−1))2,
1≤x,y,S≤N,
1≤d≤350
SAMPLE INPUT
1
4 4
1 2 24
1 4 20
3 1 3
4 3 12
1
SAMPLE OUTPUT
24 3 15
|
def killdoubles(l):
i=0
a=l[i]
ll=[a]
while i<len(l):
if a!=l[i]:
a=l[i]
ll.append(a)
i+=1
return ll
def argminnonmarque(l,m):
mini=min([l[i] for i in range(len(l)) if not(m[i])])
for i in range(len(l)):
if ((l[i]==mini) & (not(m[i]))):
break
return i
def subs(a,l):
i=0
dont=False
while i<len(l):
if l[i][0]==a[0]:
if l[i][1]>a[1]:
break
dont=True
i+=1
ll=[list(k) for k in l]
if i<len(l):
ll[i]=a
elif not(dont):
ll.append(a)
return ll
def solve(n,m,r,s):
G=[[] for _ in range(n+1)]
for [i,j,w] in r:
G[i]=subs([j,w],G[i])
G[j]=subs([i,w],G[j])
infinity=1+sum([r[i][2] for i in range(m)])
for debut in [s]:
marque=[False for _ in range(n+1)]
labels=[infinity for _ in range(n+1)]
labels[debut]=0
while marque!=[True for _ in range(n+1)]:
a=argminnonmarque(labels,marque)
marque[a]=True
for [b,w] in G[a]:
if not(marque[b]):
labels[b]=min(labels[b],labels[a]+w)
for i in range(n+1):
if labels[i]==infinity:
labels[i]=-1
st=""
for i in (labels[1:s]+labels[s+1:]):
st+=str(i)+" "
return st
T=int(raw_input())
for _ in range(T):
[n,m]=map(int,raw_input().strip().split())
r=[]
for _ in range(m):
r.append(map(int,raw_input().strip().split()))
s=int(raw_input())
print(solve(n,m,r,s))
|
In McD's Burger, n hungry burger fans are ordering burgers. The ith order is placed by the ith fan at ti time and it takes di time to procees. What is the order in which the fans will get their burgers?
Input Format
On the first line you will get n, the number of orders. Then n lines will follow. On the (i+1)th line, you will get ti and di separated by a single space.
Output Format
Print the order ( as single space separated integers ) in which the burger fans get their burgers. If two fans get the burger at the same time, then print the smallest numbered order first.(remember, the fans are numbered 1 to n).
Constraints
1≤n≤103
1≤ti,di≤106
SAMPLE INPUT
5
8 1
4 2
5 6
3 1
4 3
SAMPLE OUTPUT
4 2 5 1 3
Explanation
The first order is placed at time 3 and it takes 1 unit of time to process, so the burger is sent to the customer at time 4.
The second order is placed at time 4 and it takes 2 units of time to process, the burger is sent to customer at time 6.
The third order is placed at time 4 and it takes 3 units of time to process, the burger is sent to the customer at time 7.
Similarly, the fourth and fifth orders are sent to the customer at time 9 and time 11.
So the order of delivery of burgers is, 4 2 5 1 3.
|
a=[]
T=input()
for i in xrange(T):
c,d=map(int,raw_input().split())
a.append((c+d,i))
a.sort()
for i in a:
print i[1]+1,
|
Problem :
Bajirao is on a date with his girlfriend Avni. It is a romantic night and they are
playing a game of words.
The rule of this game is that if Bajirao says a word such that no adjacent letters occurring in the word are same then he gets a kiss from her otherwise he gets a slap.
Input :
The first line consists of T the number of test cases. The next T lines are such that each line consists of a single word spoken by Bajirao.
Output
For every test case, on a new line print 'KISS' if Bajirao gets a kiss and 'SLAP' if Bajirao gets a slap.
Constraints :
1 ≤ T ≤ 100
2 ≤ Length of Word spoken by Bajirao ≤ 100
The input word will comprise only of lower case English alphabets (a-z).
Problem Setter : Shreyans
Problem Tester : Sandeep
Problem Statement : Ravi
(By IIT Kgp HackerEarth Programming Club)
SAMPLE INPUT
2
remember
occurring
SAMPLE OUTPUT
KISS
SLAP
|
t=input()
for i in range(t):
a=raw_input()
c=0
for i in range(0,len(a)-1):
if a[i]==a[i+1]:
c=1
if c==1:
print "SLAP"
else:
print "KISS"
|
Game of numbers is a game where you are given two integers (X and Y), and you have to print the number of special numbers between X and Y both inclusive.
The property of a special numbers is as follows:
A special number is not divisible by any number of the form ZZ* where (Z\; >\; 1).
Input:
T, the number of test cases. Each test case consists of two space separated integers denoting X and Y.
Output:
The required answer in one line for each test case.
Constraints:
1 ≤ T ≤ 10
1 ≤ X,Y ≤ 10 ^ 9
0 ≤ |X-Y| ≤ 10^6
SAMPLE INPUT
1
1 10
SAMPLE OUTPUT
7
Explanation
In given test case, 4,8 and 9 are not special.
|
import math
def count(x, y):
z = [1] * ( y - x + 1)
for i in range(2, int(math.sqrt(y)) + 1):
step = i ** 2
if x % step == 0: j = x
else: j = x + step - (x%step)
while(j <= y):
z[j - x] = 0
j += step
return z.count(1)
def get():
t = int(raw_input())
for i in range(t):
s = raw_input().split()
x, y = int(s[0]), int(s[1])
if x > y: x, y = y, x
print count(x, y)
if __name__=="__main__":
get()
|
Kejal have N points, with coordinates (1, 0), (2, 0), ..., (N, 0). Every point has a color, point with coordinate (i, 0) has color C[i].
Kejal have painted arcs between every pair of points with same color. Formally Kejal painted arc between points (i, 0) and (j, 0) if C[i] = C[j] and i != j, such arc has color C[i]. All the arcs are painted such way that they will reside along the positive quadrant.
Now Kejal wants to know how many pairs of arc with different color intersect?
INPUT
First line contain integer N. Next line contain integers C[1], C[2], ..., C[N].
OUTPUT
In single line output answer modulo 1000000007 (10^9 + 7).
CONSTRAINTS
1 ≤ N ≤ 100000
1 ≤ C[i] ≤ 100000
SAMPLE INPUT
6
1 2 1 2 1 2
SAMPLE OUTPUT
6
|
rr = raw_input
N = int(rr())
A = map(int, rr().split())
from collections import defaultdict as ddic
G = ddic(int)
for i in A:
G[i] += 1
#G is total count of everything
ans = 0
for i in xrange(N):
cur = ddic(int)
Ai = A[i]
for j in xrange(i+1,N):
if Ai==A[j]:
for k,v in cur.iteritems():
if k>Ai: ans += cur[k]*(G[k]-v)
cur[A[j]] += 1
print ans
|
You have just purchased a new mobile phone and you want to call all of your relatives to brag about your new phone. You have N relatives. You will talk to i^th relative for exactly Ti minutes. Each minute costs you 1 dollar . However, your relatives are generous. Hence after the conversation, they will add a recharge of Xi dollars in your mobile. Initially, you have M dollars balance in your mobile phone.
Find the minimum value of M, that you must have initially, in your phone, so that you don't run out of balance during any of the call (encounter negative balance).
Note : You can call relatives in any order. Each relative will be called exactly once.
INPUT
The first line will contain N, the number of relatives. Next N lines will have two space separated integers, "Ti Xi" (quotes for clarity), representing call duration with the i^th relative and the amount of recharge you will get from that relative after the conversation.
OUTPUT
Output a single integer M, the minimum required initial balance in your mobile phone.
CONSTRAINTS
1 ≤ N,X,T ≤ 10^5
SAMPLE INPUT
2
1 1
2 1
SAMPLE OUTPUT
2
|
n = int(raw_input())
lists = []
while n > 0:
n = n-1
lists.append(map(int,raw_input().split(" ")))
# lists.sort(lambda k : k[1]/k[0])
list2 = []
list3 = []
for x in lists:
# print x[0],x[1]
if x[1]/x[0] > 0:
list2.append(x)
else:
list3.append(x)
list2.sort(key=lambda k: k[0])
list3.sort(key = lambda k : k[1], reverse=True)
sum1 = 0
#print list2,list3
min_sum = 999999
for item in list2:
sum1 = sum1- item[0]
min_sum = min(min_sum, sum1)
sum1 = sum1 + item[1]
for item in list3:
sum1 = sum1 - item[0]
min_sum = min(min_sum, sum1)
sum1 = sum1 + item[1]
print int(abs(min_sum))
|
Panda has started learning about subsets. His professor gave him a simple task. Given a list of numbers, Panda has to choose the subset which gives the maximum product. However, the professor asked Panda only to submit the maximum product obtained by taking exactly two numbers from the list. Please help Panda in finding out the answer to this assignment.
Input Format:
The first line will contain the integer N, the length of the array. The next line contains N space separated integers.
Output Format:
For each test case, output Panda's query.
Constraints:
2 ≤ N ≤ 10^5
Subtask 1: (25 points)
0 ≤ Integers ≤ 10^9
Subtask 2: (75 points)
-10^9 ≤ Integers ≤ 10^9SAMPLE INPUT
2
2 3
SAMPLE OUTPUT
6
Explanation
The only combination possible is {2,3} whose product is 6 .
|
'''
# 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!'
n=int(raw_input())
l=[int(i) for i in raw_input().split(" ")]
l.sort()
x=l[::-1]
if x[0]>0 and x[1]>0:
print x[0]*x[1]
else:
print l[0]*l[1]
|
Bosky needs your help in completing his maths homework today. He has to solve some questions as homework from a book named Jungly Mathematics. He knows that Jungly Mathematics contains certain quadratic equations which have imaginary roots. He is not yet introduced to the concept of imaginary roots and is only concerned with the questions having real roots.
The book contains N quadratic equation of the form a[i]x^2 + b[i]x + c[i] = 0 where a[i] != 0 and i represents the index of the question.
You have to make a program which will take N, a, b and c as input and tell him how many questions he can solve out of those N questions (i.e. You have to find how many quadratic equations in the book have real roots).
Input
Input will contain a number N denoting the number of quadratic equations.
N line follow, each one consisting of three space separated integers a[i], b[i] and c[i] representing the quadratic equation a[i]x^2 + b[i]x + c[i] = 0. where [0 ≤ i < N].
Output
Print a single integer denoting the number of quadratic equations Bosky can solve.
Constraints
1 ≤ N ≤ 100
-100 ≤ a[i] , b[i], c[i] ≤ 100
SAMPLE INPUT
2
1 0 -1
1 1 1
SAMPLE OUTPUT
1
Explanation
The book contains only 2 quadratic equations:
1: x^2 - 1 = 0
2: x^2 + x +1 = 0
1st equation has two roots x = 1, -1, thus it can be solved by Bosky.
2nd equation has complex roots, hence it can't be solved by Bosky.
Therefore, Bosky can solve only 1 question from the book.
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
def can_solve(equation):
a = equation[0]
b = equation[1]
c = equation[2]
if b * b < 4 * a * c:
return False
else:
return True
if __name__ == '__main__':
cases = int(raw_input().strip())
start = 1
solved = 0
while start <= cases:
equation = [int(x) for x in raw_input().strip().split(' ')]
if can_solve(equation):
solved = solved + 1
start = start + 1
print solved
|
Your algorithm is so good at predicting the market that you now know what the share price of Mahindra & Mahindra. (M&M) will be for the next N days.
Each day, you can either buy one share of M&M, sell any number of shares of M&M that you own, or not make any transaction at all. What is the maximum profit you can obtain with an optimum trading strategy?
Input
The first line contains the number of test cases T. T test cases follow:
The first line of each test case contains a number N. The next line contains N integers, denoting the predicted price of M&M shares for the next N days.
Output
Output T lines, containing the maximum profit which can be obtained for the corresponding test case.
Constraints
1 ≤ T ≤ 10
1 ≤ N ≤ 50000
All share prices are between 1 and 100000
SAMPLE INPUT
3
3
5 3 2
3
1 2 100
4
1 3 1 2
SAMPLE OUTPUT
0
197
3
Explanation
For the 1st case, you cannot obtain any profit because the share price never rises.
For the 2nd case, you can buy one share on the first two days, and sell both of them on the third day.
For the 3rd case, you can buy one share on day 1, sell one on day 2, buy one share on day 3, and sell one share on day 4.
|
def calcprofit(stockvalues):
prof=0
m=0
for i in range(len(stockvalues)-1,-1,-1):
ai=stockvalues[i]
if m<=ai:
m=ai
prof+=m-ai
return (prof)
for iti in xrange(input()):
n=input()
l=map(int, raw_input().split())
print calcprofit(l)
|
There are N people in a group. The personality of each person is denoted by A[i] from the set A, where A[i] denotes the personality of the ith person.
Your task is to find the total persons of different personalities.
INPUT:
First line contains the total number of test cases T, for each test cases, first line denotes the total number of persons N and second line contains list of N space separated integers denoting the personality of the person.
OUTPUT:
For each test case, print the result in a single line.
Constraints:
1 ≤ T ≤ 100
1 ≤ N ≤ 100000
1 ≤ A[i] ≤ 1000000000
SAMPLE INPUT
1
5
1 2 3 4 5
SAMPLE OUTPUT
5
|
a = input()
for i in xrange(a) :
d = input();
b = [int(i) for i in raw_input().strip().split()]
c = {}
for i in xrange(d) :
c[b[i]]=i;
print len(c)
|
You are given N real values A_1, A_2, \ldots, A_N. Compute the number of pairs of indices (i, j) such that i < j and the product A_i \cdot A_j is integer.
Constraints
* 2 \leq N \leq 200\,000
* 0 < A_i < 10^4
* A_i is given with at most 9 digits after the decimal.
Input
Input is given from Standard Input in the following format.
N
A_1
A_2
\vdots
A_N
Output
Print the number of pairs with integer product A_i \cdot A_j (and i < j).
Examples
Input
5
7.5
2.4
17.000000001
17
16.000000000
Output
3
Input
11
0.9
1
1
1.25
2.30000
5
70
0.000000001
9999.999999999
0.999999999
1.000000001
Output
8
|
#include<bits/stdc++.h>
using namespace std;
int cnt[65][65],cnt2,cnt5;
long long ans,tmp;
int main(){
double x;int n;
cin>>n;
for(int i=1;i<=n;++i){
cin>>x;
tmp=llround(x*1e9);
//cout<<tmp<<endl;
cnt2=cnt5=0;
while(tmp%2==0) ++cnt2,tmp/=2;
while(tmp%5==0) ++cnt5,tmp/=5;
for(int j=0;j<=64;++j)
for(int k=0;k<=64;++k)
if(cnt2+j>=18 && cnt5+k>=18)ans+=cnt[j][k];
cnt[cnt2][cnt5]++;
}
cout<<ans;
return 0;
}
|
Given any integer x, Aoki can do the operation below.
Operation: Replace x with the absolute difference of x and K.
You are given the initial value of an integer N. Find the minimum possible value taken by N after Aoki does the operation zero or more times.
Constraints
* 0 ≤ N ≤ 10^{18}
* 1 ≤ K ≤ 10^{18}
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
Output
Print the minimum possible value taken by N after Aoki does the operation zero or more times.
Examples
Input
7 4
Output
1
Input
2 6
Output
2
Input
1000000000000000000 1
Output
0
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
long n = scan.nextLong();
long k = scan.nextLong();
long res = n % k;
System.out.println(Math.min(Math.abs(res-k),res));
}
}
|
We have a string S consisting of uppercase English letters. Additionally, an integer N will be given.
Shift each character of S by N in alphabetical order (see below), and print the resulting string.
We assume that `A` follows `Z`. For example, shifting `A` by 2 results in `C` (`A` \to `B` \to `C`), and shifting `Y` by 3 results in `B` (`Y` \to `Z` \to `A` \to `B`).
Constraints
* 0 \leq N \leq 26
* 1 \leq |S| \leq 10^4
* S consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the string resulting from shifting each character of S by N in alphabetical order.
Examples
Input
2
ABCXYZ
Output
CDEZAB
Input
0
ABCXYZ
Output
ABCXYZ
Input
13
ABCDEFGHIJKLMNOPQRSTUVWXYZ
Output
NOPQRSTUVWXYZABCDEFGHIJKLM
|
N = int(input())
S = input()
print(''.join(chr((ord(c) - ord('A') + N) % 26 + ord('A')) for c in S))
|
There is a tree with N vertices numbered 1 to N. The i-th edge in this tree connects Vertex a_i and Vertex b_i, and the color and length of that edge are c_i and d_i, respectively. Here the color of each edge is represented by an integer between 1 and N-1 (inclusive). The same integer corresponds to the same color, and different integers correspond to different colors.
Answer the following Q queries:
* Query j (1 \leq j \leq Q): assuming that the length of every edge whose color is x_j is changed to y_j, find the distance between Vertex u_j and Vertex v_j. (The changes of the lengths of edges do not affect the subsequent queries.)
Constraints
* 2 \leq N \leq 10^5
* 1 \leq Q \leq 10^5
* 1 \leq a_i, b_i \leq N
* 1 \leq c_i \leq N-1
* 1 \leq d_i \leq 10^4
* 1 \leq x_j \leq N-1
* 1 \leq y_j \leq 10^4
* 1 \leq u_j < v_j \leq N
* The given graph is a tree.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N Q
a_1 b_1 c_1 d_1
:
a_{N-1} b_{N-1} c_{N-1} d_{N-1}
x_1 y_1 u_1 v_1
:
x_Q y_Q u_Q v_Q
Output
Print Q lines. The j-th line (1 \leq j \leq Q) should contain the answer to Query j.
Example
Input
5 3
1 2 1 10
1 3 2 20
2 4 4 30
5 2 1 40
1 100 1 4
1 100 1 5
3 1000 3 4
Output
130
200
60
|
#include<bits/stdc++.h>
#define LL long long
#define MEM(x,y) memset(x,y,sizeof(x))
#define MOD(x) ((x)%mod)
#define mod 1000000007
#define pb push_back
#define STREAM_FAST ios::sync_with_stdio(false)
using namespace std;
const int maxn = 1e5 + 7;
int head[maxn];
struct node{int v, next, c, w;}e[maxn << 1];
LL ans[maxn];
struct Node
{
int id, c, y, op;
Node(int id, int c, int y, int op):id(id), c(c), y(y), op(op) {}
Node() {}
};
vector<Node>Q[maxn];
int tot = 1;
void add(int u, int v, int c, int w)
{
e[++tot] = {v, head[u], c, w};
head[u] = tot;
}
int f[maxn][20], dep[maxn];
void dfs(int u, int fa)
{
for (int i = 1; i <= 19; i++) f[u][i] = f[f[u][i - 1]][i - 1];
for (int i = head[u]; i; i = e[i].next)
{
int v = e[i].v;
if (v == fa) continue;
dep[v] = dep[u] + 1; f[v][0] = u;
dfs(v, u);
}
}
int LCA(int x, int y)
{
if (dep[x] > dep[y]) swap(x, y);
for (int i = 19; i >= 0; i--) if (dep[y] > dep[x] && dep[f[y][i]] >= dep[x]) y = f[y][i];
for (int i = 19; i >= 0; i--) if (f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
return x == y ? x : f[x][0];
}
int cnt[maxn], sum[maxn], dis = 0;
void DFS(int u, int fa)
{
for (Node qy : Q[u])
{
ans[qy.id] += qy.op * (dis - sum[qy.c] + cnt[qy.c] * qy.y);
}
for (int i = head[u]; i; i = e[i].next)
{
int v = e[i].v;
if (v == fa) continue;
cnt[e[i].c]++; sum[e[i].c] += e[i].w;
dis += e[i].w;
DFS(v, u);
cnt[e[i].c]--; sum[e[i].c] -= e[i].w;
dis -= e[i].w;
}
}
int main()
{
int n, q; scanf("%d%d", &n, &q);
for (int i = 1; i < n; i++)
{
int u, v, c, d; scanf("%d%d%d%d", &u, &v, &c, &d);
add(u, v, c, d); add(v, u, c, d);
}
dep[1] = 1;
dfs(1, -1);
for (int i = 1; i <= q; i++)
{
int u, v, x, y; scanf("%d%d%d%d", &x, &y, &u, &v);
int lca = LCA(u, v);
Q[u].pb(Node(i, x, y, 1));
Q[v].pb(Node(i, x, y, 1));
Q[lca].pb(Node(i, x, y, -2));
}
DFS(1, -1);
for (int i = 1; i <= q; i++) printf("%lld\n", ans[i]);
return 0;
}
|
There are N monsters, numbered 1, 2, ..., N.
Initially, the health of Monster i is A_i.
Below, a monster with at least 1 health is called alive.
Until there is only one alive monster, the following is repeated:
* A random alive monster attacks another random alive monster.
* As a result, the health of the monster attacked is reduced by the amount equal to the current health of the monster attacking.
Find the minimum possible final health of the last monster alive.
Constraints
* All values in input are integers.
* 2 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible final health of the last monster alive.
Examples
Input
4
2 10 8 40
Output
2
Input
4
5 13 8 1000000000
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1000000000
|
#include<iostream>
using namespace std;
int main(){
int n,a,b,c,i=1;
cin >> n;
cin >> a;
do{
cin >> b;
if(a<b){c=b;b=a;a=c;}
while(a%b){
c=b;b=a%b;a=c;
}
a=b;i++;
}while(i<n);
cout << a;
return 0;
}
|
Takahashi throws N dice, each having K sides with all integers from 1 to K. The dice are NOT pairwise distinguishable. For each i=2,3,...,2K, find the following value modulo 998244353:
* The number of combinations of N sides shown by the dice such that the sum of no two different sides is i.
Note that the dice are NOT distinguishable, that is, two combinations are considered different when there exists an integer k such that the number of dice showing k is different in those two.
Constraints
* 1 \leq K \leq 2000
* 2 \leq N \leq 2000
* K and N are integers.
Input
Input is given from Standard Input in the following format:
K N
Output
Print 2K-1 integers. The t-th of them (1\leq t\leq 2K-1) should be the answer for i=t+1.
Examples
Input
3 3
Output
7
7
4
7
7
Input
4 5
Output
36
36
20
20
20
36
36
Input
6 1000
Output
149393349
149393349
668669001
668669001
4000002
4000002
4000002
668669001
668669001
149393349
149393349
|
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long Int;
#define MOD 998244353LL;
Int cmemo[4000][4000];
Int C(Int x, Int y){
if(x < y)return 0;
Int &res = cmemo[x][y];
if(res != -1)return res;
if(y == 0 || x == y)return res = 1;
return res = (C(x-1, y) + C(x-1, y-1)) % MOD;
}
Int cnt(Int n, Int k){
if(n < 0)return 0;
return C(n+k-1, n);
}
Int solve(Int n, Int ban, Int k){
Int res = 0;
Int p = 1;
for(Int i = 1;i <= ban;i++){
res += p * C(ban, i) * cnt(n-2*i,k) % MOD;res %= MOD;
p *= -1;
}
if(res < 0)res += MOD;
return cnt(n, k) - res;
}
int cnthoge(int x, int k){
int res = 0;
for(int i = 1;i <= k;i++){
int kk = x - i;
if(0 < kk && kk <= k && kk != i)res++;
}
return res / 2;
}
int main(){
Int k, n;
for(int i = 0;i < 4000;i++)
for(int j = 0;j < 4000;j++)
cmemo[i][j] = -1;
cin >> k >> n;
for(int i = 2;i <= 2*k;i++){
Int res = 0;
if(i % 2 == 0){
res += solve(n,cnthoge(i, k), k-1);
res += solve(n-1,cnthoge(i, k), k-1);
res %= MOD;
}
else{
res += solve(n, cnthoge(i, k), k);
}
res %= MOD;
if(res < 0)res += MOD;
cout << res << endl;
}
return 0;
}
|
Find the maximum possible sum of the digits (in base 10) of a positive integer not greater than N.
Constraints
* 1\leq N \leq 10^{16}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the maximum possible sum of the digits (in base 10) of a positive integer not greater than N.
Examples
Input
100
Output
18
Input
9995
Output
35
Input
3141592653589793
Output
137
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Main m = new Main();
m.run();
}
Scanner sc = new Scanner(System.in);
void run() {
long n = sc.nextLong();
System.out.println(solve(n));
}
long solve(long n){
long x = n;
int r = 0;
long d1 = 1;
boolean isNine = true;
for(;x > 0;){
if(x >= 10 && x % 10 != 9){
isNine = false;
}
r += x % 10;
x = x / 10;
d1 *= 10;
}
d1 /= 10;
if(d1 == 1){
return n;
}
/*
System.out.println(isNine);
System.out.println(r);
System.out.println(d1);
*/
if(isNine){
return r;
}
return digitSum(d1-1 + (n/d1 - 1) * d1);
}
int digitSum(long n){
int r = 0;
for(;n > 0;){
r += n%10;
n /= 10;
}
return r;
}
}
|
There are N lines in the xy-plane. The i-th line is represented by A_ix+B_iy=C_i. Any two lines among the N+2 lines, the above N lines plus the x-axis and y-axis, cross each other at exactly one point.
For each pair 1 \leq i < j \leq N, there is a car at the cross point of the i-th and j-th lines. Even where three or more lines intersect at a point, a car is individually placed for each pair of lines. That is, there will be k(k-1)/2 cars placed at the intersection of k lines.
Those cars are already very old, and can only be moved parallel to the x-axis or y-axis.
Takahashi will hold an exhibition of antique cars at a place on the xy-plane. In order to avoid damaging the half-broken cars too much, he will select the place of the exhibition so that the total distance covered will be minimized when all the cars are moved to the place. If such a place is not uniquely determined, among the places that satisfy the condition above, the place with the minimum x-coordinate will be selected. If the place is still not uniquely determined, among the places that satisfy the two conditions above, the place with the minimum y-coordinate will be selected.
Find the place of the exhibition that will be selected.
Constraints
* 2 \leq N \leq 4 × 10^4
* 1 \leq |A_i|,|B_i| \leq 10^4(1 \leq i \leq N)
* 0 \leq |C_i| \leq 10^4(1 \leq i \leq N)
* No two given lines are parallel.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
:
A_N B_N C_N
Outputs
Print the x-coordinate and y-coordinate of the place of the exhibition that will be selected, in this order, with a space in between. The output will be judged as correct when the absolute or relative error is at most 10^{-9}.
Examples
Input
3
1 1 1
2 -1 2
-1 2 2
Output
1.000000000000000 1.000000000000000
Input
4
1 1 2
1 -1 0
3 -1 -2
1 -3 4
Output
-1.000000000000000 -1.000000000000000
Input
7
1 7 8
-2 4 9
3 -8 -5
9 2 -14
6 7 5
-8 -9 3
3 8 10
Output
-1.722222222222222 1.325000000000000
|
#include <bits/stdc++.h>
using namespace std;
#define times(n, i) uptil(0, n, i)
#define rtimes(n, i) downto((n) - 1, 0, i)
#define upto(f, t, i) for(int i##_to_ = (t), i = (f); i <= i##_to_; i++)
#define uptil(f, t, i) for(int i##_to_ = (t), i = (f); i < i##_to_; i++)
#define downto(f, t, i) for(int i##_to_ = (t), i = (f); i >= i##_to_; i--)
#define downtil(f, t, i) for(int i##_to_ = (t), i = (f); i > i##_to_; i--)
typedef long double LD;
#define long long long
#if defined(EBUG) && !defined(ONLINE_JUDGE)
#define debug true
#define _GLIBCXX_DEBUG
#define _LIBCPP_DEBUG 1
#define ln << endl
#else
#define debug false
#define ln << '\n'
#endif
#define tb << '\t'
#define sp << ' '
class BIT {
static constexpr int N = 131072/2;
int node[N];
public:
BIT() { times(N, i) node[i] = 0; }
/** 0-based **/
void set(int i, int v) {
add(i, v - node[i]);
}
/** 0-based **/
void add(int i, int v) {
for(++i; i <= N; i += i & -i)
node[i-1] += v;
}
/** [0, i) **/
int sum(int i) {
int s = 0;
for(++i; i; i -= i & -i)
s += node[i-1];
return s;
}
};
int A[48600], B[48600], C[48600];
int e0[48600], e[48600];
signed main() { // long: 64bit
if(!debug) {
cin.tie(0);
ios::sync_with_stdio(0);
}
int N; scanf("%d", &N);
long nn = N * (N - 1) / 2;
vector<pair<LD, int>> d0(N), d(N);
times(N, i) {
scanf("%d%d%d", &A[i], &B[i], &C[i]);
}
times(2, o) {
times(N, i) d0[i] = make_pair((C[i] - (LD)A[i] * -1e9L) / B[i], i);
if(debug) times(N, i) cout << d0[i].first ln;
sort(d0.begin(), d0.end());
if(debug) times(N, i) cout << d0[i].first ln;
times(N, i) e0[d0[i].second] = i;
if(debug) { times(N, i) cout << d0[i].first << "," << d0[i].second sp; cout ln; }
LD l = -1e9L, r = 1e9L;
times(100, oo) {
LD m = (l + r) / 2;
times(N, i) d[i] = {(C[i] - (LD)A[i] * m) / B[i], i};
sort(begin(d), end(d));
BIT bit;
long a = 0;
times(N, i) {
int aj = e0[d[i].second];
a += aj - bit.sum(aj);
bit.add(aj, 1);
}
if(a < (nn + 1) / 2) l = m;
else r = m;
}
cout << std::fixed << setprecision(30) << l << (o ? "\n" : " ");
swap(A, B);
}
return 0;
}
|
Alice lives on a line. Today, she will travel to some place in a mysterious vehicle. Initially, the distance between Alice and her destination is D. When she input a number x to the vehicle, it will travel in the direction of the destination by a distance of x if this move would shorten the distance between the vehicle and the destination, and it will stay at its position otherwise. Note that the vehicle may go past the destination when the distance between the vehicle and the destination is less than x.
Alice made a list of N numbers. The i-th number in this list is d_i. She will insert these numbers to the vehicle one by one.
However, a mischievous witch appeared. She is thinking of rewriting one number in the list so that Alice will not reach the destination after N moves.
She has Q plans to do this, as follows:
* Rewrite only the q_i-th number in the list with some integer so that Alice will not reach the destination.
Write a program to determine whether each plan is feasible.
Constraints
* 1≤ N ≤ 5*10^5
* 1≤ Q ≤ 5*10^5
* 1≤ D ≤ 10^9
* 1≤ d_i ≤ 10^9(1≤i≤N)
* 1≤ q_i ≤ N(1≤i≤Q)
* D and each d_i are integers.
Input
Input is given from Standard Input in the following format:
N D
d_1 d_2 ... d_N
Q
q_1 q_2 ... q_Q
Output
Print Q lines. The i-th line should contain `YES` if the i-th plan is feasible, and `NO` otherwise.
Examples
Input
4 10
3 4 3 3
2
4 3
Output
NO
YES
Input
5 9
4 4 2 3 2
5
1 4 2 3 5
Output
YES
YES
YES
YES
YES
Input
6 15
4 3 5 4 2 1
6
1 2 3 4 5 6
Output
NO
NO
YES
NO
NO
YES
|
#include <bits/stdc++.h>
#define yabs(x) ((x<0)?(-(x)):(x))
using namespace std;
const int N=5e5+10,Inf=1e9+10;
int n,D,Q,a[N],now[N],suf[N];
void Init()
{
scanf("%d%d",&n,&D);
for (int i=1;i<=n;++i) scanf("%d",&a[i]);
}
void Solve()
{
now[0]=D;
for (int i=1;i<=n;++i) now[i]=min(now[i-1],yabs(now[i-1]-a[i]));
suf[n+1]=1;
for (int i=n;i>=1;--i)
if (yabs(suf[i+1]-a[i])>=suf[i+1]) suf[i]=suf[i+1];
else suf[i]=min(suf[i+1]+a[i],Inf);
scanf("%d",&Q);int x;
for (int i=1;i<=Q;++i)
{
scanf("%d",&x);
if (suf[x+1]>now[x-1]) printf("NO\n");
else printf("YES\n");
}
}
int main()
{
Init();
Solve();
return 0;
}
|
Takahashi found an undirected connected graph with N vertices and M edges. The vertices are numbered 1 through N. The i-th edge connects vertices a_i and b_i, and has a weight of c_i.
He will play Q rounds of a game using this graph. In the i-th round, two vertices S_i and T_i are specified, and he will choose a subset of the edges such that any vertex can be reached from at least one of the vertices S_i or T_i by traversing chosen edges.
For each round, find the minimum possible total weight of the edges chosen by Takahashi.
Constraints
* 1 ≦ N ≦ 4,000
* 1 ≦ M ≦ 400,000
* 1 ≦ Q ≦ 100,000
* 1 ≦ a_i,b_i,S_i,T_i ≦ N
* 1 ≦ c_i ≦ 10^{9}
* a_i \neq b_i
* S_i \neq T_i
* The given graph is connected.
Input
The input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Q
S_1 T_1
S_2 T_2
:
S_Q T_Q
Output
Print Q lines. The i-th line should contain the minimum possible total weight of the edges chosen by Takahashi.
Examples
Input
4 3
1 2 3
2 3 4
3 4 5
2
2 3
1 4
Output
8
7
Input
4 6
1 3 5
4 1 10
2 4 6
3 2 2
3 4 5
2 1 3
1
2 3
Output
8
|
#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 N,M;
int A[404040],B[404040];
ll C[404040];
vector<pair<int,int>> E[4040];
int Q;
ll D[4040][4040];
template<int um> class UF {
public:
vector<int> par,rank;
UF() {rank=vector<int>(um,0); for(int i=0;i<um;i++) par.push_back(i);}
int operator[](int x) {return (par[x]==x)?(x):(par[x] = operator[](par[x]));}
int operator()(int x,int y) {
if((x=operator[](x))==(y=operator[](y))) return x;
if(rank[x]>rank[y]) return par[x]=y;
rank[x]+=rank[x]==rank[y]; return par[y]=x;
}
};
UF<500000> uf;
void dfs(int st,int cur,int pre,int ma) {
D[st][cur]=ma;
FORR(e,E[cur]) if(e.first != pre) {
dfs(st,e.first,cur,max(ma,e.second));
}
}
void solve() {
int i,j,k,l,r,x,y; string s;
cin>>N>>M;
priority_queue<pair<int,int>> EE;
FOR(i,M) {
cin>>A[i]>>B[i]>>C[i], A[i]--, B[i]--;
EE.push({-C[i],i});
}
ll tot=0;
while(EE.size()) {
auto e=EE.top();
x = A[e.second];
y = B[e.second];
EE.pop();
if(uf[x]!=uf[y]) {
uf(x,y);
E[x].push_back({y,-e.first});
E[y].push_back({x,-e.first});
tot+=-e.first;
}
}
FOR(i,N) dfs(i,i,-1,0);
cin>>M;
FOR(i,M) {
cin>>x>>y;
cout<<tot-D[x-1][y-1]<<endl;
}
}
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;
}
|
Write a program which reads an integer n and prints the number of prime numbers which are less than or equal to n. A prime number is a natural number which has exactly two distinct natural number divisors: 1 and itself. For example, the first four prime numbers are: 2, 3, 5 and 7.
Input
Input consists of several datasets. Each dataset has an integer n (1 ≤ n ≤ 999,999) in a line.
The number of datasets is less than or equal to 30.
Output
For each dataset, prints the number of prime numbers.
Example
Input
10
3
11
Output
4
2
5
|
import java.util.Arrays;
import java.util.Scanner;
public class Main
{
public static void main(String arg[])
{
Scanner sc = new Scanner(System.in);
while(sc.hasNext())
{
int n = sc.nextInt();
int ans =0;
boolean a[] = new boolean [n+1];
Arrays.fill(a, true);
a[0]=a[1]=false;
for (int p=2; p*p<=n; p++)
{
if (!a[p])
continue;
for (int j = p+p; j<= n; j += p) //合成数jを消す
{
a[j] = false;
}
}
for(int i =0; i<=n; i++)
{
if(a[i])
ans++;
}
System.out.println(ans);
}
}
}
|
I decided to create a program that displays a "round and round pattern". The "round and round pattern" is as follows.
* If the length of one side is n, it is displayed as a character string with n rows and n columns.
* A spiral pattern that rotates clockwise with the lower left corner as the base point.
* The part with a line is represented by # (half-width sharp), and the blank part is represented by "" (half-width blank).
* Leave a space between the lines.
Create a program that takes an integer n as an input and outputs a "round and round pattern" with a side length of n.
Input
The input is given in the following format:
d
n1
n2
::
nd
The number of datasets d (d ≤ 20) is given to the first line, and the side length ni (1 ≤ ni ≤ 100) of the i-th round pattern is given to each of the following d lines.
Output
Please output a round and round pattern for each data set. Insert a blank line between the datasets.
Example
Input
2
5
6
Output
#####
# #
# # #
# # #
# ###
######
# #
# ## #
# # #
# # #
# ####
|
#include "bits/stdc++.h"
using namespace std;
#define rep(i,n) for(int i=0;i<(int)(n);i++)
enum{UP,RIGHT,DOWN,LEFT};
int dy[]={-1,0,1,0};
int dx[]={0,1,0,-1};
int n;
bool adja(bool data[100][100],int y,int x,int dir){
int left=(dir+3)%4,right=(dir+1)%4;
if( x+dx[left ]>=0 && y+dy[left ]>=0 && x+dx[left ]<n && y+dy[left ]<n && data[y+dy[left ]][x+dx[left ]]==true )return true;
if( x+dx[right]>=0 && y+dy[right]>=0 && x+dx[right]<n && y+dy[right]<n && data[y+dy[right]][x+dx[right]]==true )return true;
return false;
}
int main(){
int a;
cin>>a;
bool f=false;
rep(i,a){
if(f)cout<<endl;
f=true;
bool data[100][100]={};
cin>>n;
int dir = UP;
int y=n-1,x=0;
int change_d_times = 0;
while(1){
data[y][x]=true;
int ddx = x+dx[dir], ddy = y+dy[dir];
if( ddx>=0 && ddy>=0 && ddx<n && ddy<n && !data[ddy][ddx] && !(ddx+dx[dir]>=0 && ddy+dy[dir]>=0 && ddx+dx[dir]<n && ddy+dy[dir]<n && data[ddy+dy[dir]][ddx+dx[dir]]==true) && !adja(data,ddy,ddx,dir) ){
data[ddy][ddx]=true;
change_d_times=0;
x = ddx , y = ddy;
}
else{
dir = (dir+1)%4;
change_d_times++;
}
if(change_d_times>=5)break;
}
rep(i,n){
rep(j,n){
if(data[i][j])cout<<"#";
else cout<<" ";
}
cout<<endl;
}
}
}
|
Jou and Yae are a good couple. Jou is collecting prizes for capsule toy vending machines (Gachapon), and even when they go out together, when they find Gachapon, they seem to get so hot that they try it several times. Yae was just looking at Jou, who looked happy, but decided to give him a Gachapon prize for his upcoming birthday present. Yae wasn't very interested in Gachapon itself, but hopefully he would like a match with Jou.
For Gachapon that Yae wants to try, one prize will be given in one challenge. You can see how many types of prizes there are, including those that are out of stock, and how many of each prize remains. However, I don't know which prize will be given in one challenge. Therefore, regardless of the order in which the prizes are given, create a program that outputs the minimum number of challenges required for Yae to get two of the same prizes.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
k1 k2 ... kN
Each dataset has two lines, and the first line is given the integer N (1 ≤ N ≤ 10000), which indicates how many types of prizes there are. The next line is given the integer ki (0 ≤ ki ≤ 10000), which indicates how many prizes are left.
The number of datasets does not exceed 100.
output
For each dataset, the minimum number of challenges required to get two identical prizes is output. However, if it is not possible, NA is output.
Example
Input
2
3 2
3
0 1 1
1
1000
0
Output
3
NA
2
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while(cin >> n, n){
int cnt = 0;
bool ok = false;
for(int i=0;i<n;i++){
int k;
cin >> k;
if(k>0) cnt++;
if(k>1) ok = true;
}
if(ok){
cout << cnt+1 << endl;
}
else{
cout << "NA" << endl;
}
}
return 0;
}
|
problem
JOI Pizza sells pizza home delivery along the d-meter-long ring road that runs through the city center.
JOI Pizza has n stores S1, ..., Sn on the loop line. The head office is S1. The distance from S1 to Si when moving the loop line clockwise is set to di meters. D2 , ..., dn is an integer greater than or equal to 1 and less than or equal to d -1. D2, ..., dn are all different. Bake and deliver pizza at the shortest store.
The location of the delivery destination is represented by an integer k that is greater than or equal to 0 and less than or equal to d -1. This means that the distance from the head office S1 to the delivery destination in the clockwise direction is k meters. Pizza delivery is done along the loop line and no other road is allowed. However, the loop line may move clockwise or counterclockwise.
For example, if the location of the store and the location of the delivery destination are as shown in the figure below (this example corresponds to Example 1 of "I / O example").
<image>
The store closest to the delivery destination 1 is S2, so the delivery is from store S2. At this time, the distance traveled from the store is 1. Also, the store closest to delivery destination 2 is S1 (main store), so store S1 (main store). ) To deliver to home. At this time, the distance traveled from the store is 2.
Total length of the loop line d, Number of JOI pizza stores n, Number of orders m, N --1 integer representing a location other than the main store d2, ..., dn, Integer k1, .. representing the location of the delivery destination Given ., km, create a program to find the sum of all orders for each order by the distance traveled during delivery (ie, the distance from the nearest store to the delivery destination).
input
The input consists of multiple datasets. Each dataset is given in the following format.
The first line is a positive integer d (2 ≤ d ≤ 1000000000 = 109) that represents the total length of the loop line, the second line is a positive integer n (2 ≤ n ≤ 100000) that represents the number of stores, and the third line is A positive integer m (1 ≤ m ≤ 10000) is written to represent the number of orders. The n --1 lines after the 4th line are integers d2, d3, ..., dn that represent the location of stores other than the main store. (1 ≤ di ≤ d -1) is written in this order, and the integers k1, k2, ..., km (0 ≤ ki ≤ d) representing the delivery destination location are in the m lines after the n + 3rd line. --1) are written in this order.
Of the scoring data, for 40% of the points, n ≤ 10000 is satisfied. For 40% of the points, the total distance traveled and the value of d are both 1000000 or less. In the scoring data, the total distance traveled is 1000000000 = 109 or less.
When d is 0, it indicates the end of input. The number of data sets does not exceed 10.
output
For each data set, one integer representing the total distance traveled during delivery is output on one line.
Examples
Input
8
3
2
3
1
4
6
20
4
4
12
8
16
7
7
11
8
0
Output
3
3
Input
None
Output
None
|
#include<bits/stdc++.h>
#define rep(i,n)for(ll i=0;i<n;i++)
using namespace std;
typedef long long ll;
ll a[200000];
int main() {
ll d, n, m;
while (scanf("%lld", &d), d) {
scanf("%lld%lld", &n, &m);
rep(i, n - 1)scanf("%lld", &a[i]);
a[n - 1] = 0; a[n] = d;
sort(a, a + n + 1);
a[n + 1] = a[n - 1] - d;
sort(a, a + n + 2);
ll cnt = 0;
rep(i, m) {
ll k; scanf("%lld", &k);
ll*p = lower_bound(a, a + n + 2, k);
cnt += min(*p - k, k - *(p - 1));
}
printf("%lld\n", cnt);
}
}
|
Turtle Shi-ta and turtle Be-ko decided to divide a chocolate. The shape of the chocolate is rectangle. The corners of the chocolate are put on (0,0), (w,0), (w,h) and (0,h). The chocolate has lines for cutting. They cut the chocolate only along some of these lines.
The lines are expressed as follows. There are m points on the line connected between (0,0) and (0,h), and between (w,0) and (w,h). Each i-th point, ordered by y value (i = 0 then y =0), is connected as cutting line. These lines do not share any point where 0 < x < w . They can share points where x = 0 or x = w . However, (0, li ) = (0,lj ) and (w,ri ) = (w,rj ) implies i = j . The following figure shows the example of the chocolate.
<image>
There are n special almonds, so delicious but high in calories on the chocolate. Almonds are circle but their radius is too small. You can ignore radius of almonds. The position of almond is expressed as (x,y) coordinate.
Two turtles are so selfish. Both of them have requirement for cutting.
Shi-ta's requirement is that the piece for her is continuous. It is possible for her that she cannot get any chocolate. Assume that the minimum index of the piece is i and the maximum is k . She must have all pieces between i and k . For example, chocolate piece 1,2,3 is continuous but 1,3 or 0,2,4 is not continuous.
Be-ko requires that the area of her chocolate is at least S . She is worry about her weight. So she wants the number of almond on her chocolate is as few as possible.
They doesn't want to make remainder of the chocolate because the chocolate is expensive.
Your task is to compute the minumum number of Beko's almonds if both of their requirment are satisfied.
Input
Input consists of multiple test cases.
Each dataset is given in the following format.
n m w h S
l0 r0
...
lm-1 rm-1
x0 y0
...
xn-1 yn-1
The last line contains five 0s. n is the number of almonds. m is the number of lines. w is the width of the chocolate. h is the height of the chocolate. S is the area that Be-ko wants to eat. Input is integer except xi yi.
Input satisfies following constraints.
1 ≤ n ≤ 30000
1 ≤ m ≤ 30000
1 ≤ w ≤ 200
1 ≤ h ≤ 1000000
0 ≤ S ≤ w*h
If i < j then li ≤ lj and ri ≤ rj and then i -th lines and j -th lines share at most 1 point. It is assured that lm-1 and rm-1 are h. xi yi is floating point number with ten digits. It is assured that they are inside of the chocolate. It is assured that the distance between points and any lines is at least 0.00001.
Output
You should output the minumum number of almonds for Be-ko.
Example
Input
2 3 10 10 50
3 3
6 6
10 10
4.0000000000 4.0000000000
7.0000000000 7.0000000000
2 3 10 10 70
3 3
6 6
10 10
4.0000000000 4.0000000000
7.0000000000 7.0000000000
2 3 10 10 30
3 3
6 6
10 10
4.0000000000 4.0000000000
7.0000000000 7.0000000000
2 3 10 10 40
3 3
6 6
10 10
4.0000000000 4.0000000000
7.0000000000 7.0000000000
2 3 10 10 100
3 3
6 6
10 10
4.0000000000 4.0000000000
7.0000000000 7.0000000000
0 0 0 0 0
Output
1
1
0
1
2
|
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
#include <string>
#include <queue>
using namespace std;
#define SZ(v) ((int)(v).size())
const int maxint = -1u>>1;
const int maxn = 30000 + 100;
const double eps = 1e-8;
typedef long long lint;
int sgn(double x) {
return (x > eps) - (x < -eps);
}
struct P {
double x, y;
P() {}
P(double _x, double _y): x(_x), y(_y) {}
lint cross(const P &a, const P &b) const {
return (a.x - x) * (b.y - y) - (a.y - y) * (b.x - x);
}
void input() {
scanf("%lf%lf", &x, &y);
}
};
int n, m, w, h, s;
int l[maxn], r[maxn];
double area[maxn];
int cnt[maxn];
int main() {
while (scanf("%d%d%d%d%d", &n, &m, &w, &h, &s) == 5 && (n || m || w || h || s)) {
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &l[i], &r[i]);
}
l[0] = r[0] = 0;
l[m + 1] = r[m + 1] = h;
for (int i = 0; i <= m; ++i) {
area[i] = double(r[i + 1] - r[i] + l[i + 1] - l[i]) * w / 2;
cnt[i] = 0;
}
for (int i = 0; i < n; ++i) {
P pt;
pt.input();
int low = 0, high = m, res = -1;
while (low <= high) {
int mid = (low + high) / 2;
if (sgn(P(0, l[mid]).cross(P(w, r[mid]), pt)) > 0) {
res = mid;
low = mid + 1;
} else {
high = mid - 1;
}
}
if (res == -1) while (1);
if (res != -1) ++cnt[res];
}
//for (int i = 0; i <= m; ++i) printf("%lf ", area[i]); printf("\n");
//for (int i = 0; i <= m; ++i) {
//if (i == 0) sum[i] = cnt[i];
//else sum[i] = sum[i - 1] + cnt[i];
//}
int ba = 0;
double now = 0;
int ct = 0;
int ans = 0;
for (int i = 0; i <= m; ++i) {
now += area[i];
ct += cnt[i];
while (ba <= i && sgn(now - w * h + s) > 0) {
now -= area[ba];
ct -= cnt[ba];
++ba;
}
ans = max(ans, ct);
}
printf("%d\n", n - ans);
}
return 0;
}
|
A professor of anthropology was interested in people living in isolated islands and their history. He collected their family trees to conduct some anthropological experiment. For the experiment, he needed to process the family trees with a computer. For that purpose he translated them into text files. The following is an example of a text file representing a family tree.
John
Robert
Frank
Andrew
Nancy
David
Each line contains the given name of a person. The name in the first line is the oldest ancestor in this family tree. The family tree contains only the descendants of the oldest ancestor. Their husbands and wives are not shown in the family tree. The children of a person are indented with one more space than the parent. For example, Robert and Nancy are the children of John, and Frank and Andrew are the children of Robert. David is indented with one more space than Robert, but he is not a child of Robert, but of Nancy. To represent a family tree in this way, the professor excluded some people from the family trees so that no one had both parents in a family tree.
For the experiment, the professor also collected documents of the families and extracted the set of statements about relations of two persons in each family tree. The following are some examples of statements about the family above.
John is the parent of Robert.
Robert is a sibling of Nancy.
David is a descendant of Robert.
For the experiment, he needs to check whether each statement is true or not. For example, the first two statements above are true and the last statement is false. Since this task is tedious, he would like to check it by a computer program.
Input
The input contains several data sets. Each data set consists of a family tree and a set of statements. The first line of each data set contains two integers n (0 < n < 1000) and m (0 < m < 1000) which represent the number of names in the family tree and the number of statements, respectively. Each line of the input has less than 70 characters.
As a name, we consider any character string consisting of only alphabetic characters. The names in a family tree have less than 20 characters. The name in the first line of the family tree has no leading spaces. The other names in the family tree are indented with at least one space, i.e., they are descendants of the person in the first line. You can assume that if a name in the family tree is indented with k spaces, the name in the next line is indented with at most k + 1 spaces. This guarantees that each person except the oldest ancestor has his or her parent in the family tree. No name appears twice in the same family tree. Each line of the family tree contains no redundant spaces at the end.
Each statement occupies one line and is written in one of the following formats, where X and Y are different names in the family tree.
X is a child of Y.
X is the parent of Y.
X is a sibling of Y.
X is a descendant of Y.
X is an ancestor of Y.
Names not appearing in the family tree are never used in the statements. Consecutive words in a statement are separated by a single space. Each statement contains no redundant spaces at the beginning and at the end of the line.
The end of the input is indicated by two zeros.
Output
For each statement in a data set, your program should output one line containing True or False. The first letter of True or False in the output must be a capital. The output for each data set should be followed by an empty line.
Examples
Input
6 5
John
Robert
Frank
Andrew
Nancy
David
Robert is a child of John.
Robert is an ancestor of Andrew.
Robert is a sibling of Nancy.
Nancy is the parent of Frank.
John is a descendant of Andrew.
2 1
abc
xyz
xyz is a child of abc.
0 0
Output
True
True
True
False
False
True
Input
6 5
John
Robert
Frank
Andrew
Nancy
David
Robert is a child of John.
Robert is an ancestor of Andrew.
Robert is a sibling of Nancy.
Nancy is the parent of Frank.
John is a descendant of Andrew.
2 1
abc
xyz
xyz is a child of abc.
0 0
Output
True
True
True
False
False
True
|
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define REP(i,n) for(int i=0; i<n; ++i)
class Tree
{
public:
string name;
Tree* parent;
vector<Tree*> child;
Tree()
:parent(NULL)
{}
~Tree()
{
REP(i,child.size()) delete child[i];
}
};
Tree* tree;
Tree* find(Tree* t, string name)
{
if(name==t->name) return t;
REP(i, t->child.size())
{
Tree* ret=find(t->child[i], name);
if(ret!=NULL) return ret;
}
return NULL;
}
bool isChild(Tree* t, string name)
{
REP(i, t->child.size())
{
if(t->child[i]->name==name) return true;
}
return false;
}
bool isParent(Tree* t, string name)
{
if(t->parent->name == name) return true;
return false;
}
bool isSibling(Tree* t, string name)
{
Tree* p=t->parent;
return isChild(p, name);
}
bool isDescendant(Tree* t, string name)
{
Tree* ret=find(t, name);
if(ret==NULL) return false;
return true;
}
bool isAncestor(Tree* t, string name)
{
if(t->name==name) return true;
if(t->parent==NULL) return false;
return isAncestor(t->parent, name);
}
int main()
{
int n,q;
while(cin >> n >> q, (n||q))
{
tree = new Tree;
Tree* now = tree;
Tree* prev = tree;
int sp=-1;
cin.ignore();
REP(i,n)
{
string str;
getline(cin,str);
int cnt=0;
REP(j,str.size()) if(str[j]==' ') ++cnt;
string name(str.begin()+cnt, str.end());
REP(j, (sp-cnt)+1)
now=now->parent;
Tree* nw= new Tree;
nw->parent=now;
nw->name=name;
now->child.push_back(nw);
now = nw;
sp=cnt;
}
REP(i,q)
{
bool ret;
string a,b,c;
cin >> a >> b >> b >> b >> c >> c;
c=c.substr(0,c.size()-1);
Tree* s=find(tree, c);
if(s==NULL) cout << "False" << endl;
else
{
if(b[0]=='c') ret=isChild(s,a);
if(b[0]=='p') ret=isParent(s,a);
if(b[0]=='s') ret=isSibling(s,a);
if(b[0]=='d') ret=isDescendant(s,a);
if(b[0]=='a') ret=isAncestor(s,a);
cout << (ret?"True":"False") << endl;
}
}
cout << endl;
delete tree;
}
}
|
Example
Input
4 2 1 1
1 1 1 2
2 2 2 1
2 2 1 2
1 1 2 1
9 N
Output
1 1
2 2
|
// tsukasa_diary's programing contest code template
#include <bits/stdc++.h>
using namespace std;
// define
#define for_(i,a,b) for(int i=a;i<b;++i)
#define for_rev(i,a,b) for(int i=a;i>=b;--i)
#define allof(a) a.begin(),a.end()
#define minit(a,b) memset(a,b,sizeof(a))
#define size_of(a) (int)a.size()
// typedef
typedef long long lint;
typedef double Double;
typedef pair<int, int> pii;
//
typedef vector< int > Array;
typedef vector< Array > Matrix;
typedef vector< Double > DArray;
typedef vector< DArray > DMatrix;
typedef vector< string > SArray;
typedef vector< pii > PArray;
// popcount
inline int POPCNT(int _x) { return __builtin_popcount(_x); }
inline int POPCNT(lint _x) { return __builtin_popcountll(_x); }
// inf
const int iINF = 1L << 30;
const lint lINF = 1LL << 60;
// eps
Double EPS = 1e-9;
// in range
inline bool in_range(int _v, int _mx, int _mi) { return _mi <= _v && _v < _mx; }
inline bool in_range(Double _v, Double _mi, Double _mx) { return -EPS < _v - _mi && _v - _mx < EPS; }
inline bool in_range(int _x, int _y, int _W, int _H) { return 0 <= _x && _x < _W && 0 <= _y && _y < _H; }
// neighbor clockwise
const int DX[4] = {0,1,0,-1}, DY[4] = {1,0,-1,0};
const int DX_[8] = {0,1,1,1,0,-1,-1,-1}, DY_[8] = {-1,-1,0,1,1,1,0,-1};
typedef pii Point;
typedef pair< pii, pii > Load;
int n, stx, sty, t;
set< Load > loads;
int d[110];
char c[110];
bool dp[1010][55][55][4][4];
void solve() {
minit(dp, 0);
for_(r,0,4) fill(dp[0][sty][stx][r], dp[0][sty][stx][r] + 4, 1);
int i = 0;
for_(ii,0,t) {
/*
cout << "-----candidate-----" << endl;
for_(y,0,55) for_(x,0,55) for_(r,0,4) for_(pr,0,4){
if (dp[i][y][x][r][pr]) cout << "State(" << i << "," << x << "," << y << "," << r << "," << pr << ")" << endl;
}
*/
for_(rep,0,d[ii]) {
// cout << "-----step-----" << endl;
for_(y,0,55) for_(x,0,55) for_(r,0,4) {
bool flag = false;
for_(pr,0,4) flag |= dp[i][y][x][r][pr];
if (!flag) continue;
//cout << "State(" << i << "," << x << "," << y << "," << r << ")" << endl;
int nx = x + DX[r], ny = y + DY[r];
Load ld(Point(x, y), Point(nx, ny));
if (loads.find(ld) == loads.end()) continue;
for_(nr,0,4) {
if (nr == 2) continue;
int dir = (r + nr) % 4;
dp[i + 1][ny][nx][dir][r] = 1;
}
}
++i;
}
//cout << "-----next-----" << endl;
int ok = 0;
if (c[ii] == 'S') ok = 2;
if (c[ii] == 'E') ok = 1;
if (c[ii] == 'W') ok = 3;
for_(y,0,55) for_(x,0,55) for_(r,0,4) for_(pr,0,4){
if (r != ok && pr != ok) dp[i][y][x][r][pr] = 0;
}
}
for_(x,0,55) for_(y,0,55) {
bool flag = false;
for_(r,0,4) {
int xx = x + DX[r], yy = y + DY[r];
Load ld(Point(x, y), Point(xx, yy));
if (loads.find(ld) == loads.end()) continue;
for_(pr,0,4) flag |= dp[i][y][x][r][pr];
}
if (flag) cout << x << " " << y << endl;
}
}
int main() {
cin >> n >> stx >> sty >> t;
for_(i,0,n) {
int sx, sy, ex, ey; cin >> sx >> sy >> ex >> ey;
int x = min(sx, ex), xx = max(sx, ex);
for (int j = 0; x + j < xx; ++j) {
loads.insert( Load(Point(x + j, sy), Point(x + j + 1, sy)) );
loads.insert( Load(Point(x + j + 1, sy), Point(x + j, sy)) );
}
int y = min(sy, ey), yy = max(sy, ey);
for (int j = 0; y + j < yy; ++j) {
loads.insert( Load(Point(sx, y + j), Point(sx, y + j + 1)) );
loads.insert( Load(Point(sx, y + j + 1), Point(sx, y + j)) );
}
}
for_(i,0,t) cin >> d[i] >> c[i];
solve();
return 0;
}
|
Problem
There are N villages. Each village is numbered from 1 to N. Due to the recent merger boom, several villages have been merged. Two or more merged villages will become one new city, and villages that are not merged with any village will remain villages.
You will be given multiple pieces of information that two villages will be in the same city after the merger. Depending on the combination of the information, three or more villages can become one city.
Given information about villages that will be in the same city after the merger, output the absolute value of the difference between the number of cities and the number of villages after the merger.
Constraints
* 1 ≤ N ≤ 1,000
* 0 ≤ M ≤ 100
* 1 ≤ ai ≤ N
* 1 ≤ bi ≤ N
Input
The input is given in the following format.
N M
a1 b1
a2 b2
...
ai bi
...
aM bM
The first line gives the number N of villages and the number M of information about the merger, separated by blanks.
From the second line to the M + 1 line, two integers ai and bi representing information about the merger are given, separated by blanks. Each information indicates that the ai and bi villages will be the same city after the merger. However, no input is given that satisfies ai = bi.
Output
Output the absolute value of the difference between the number of villages and the number of cities on one line.
Examples
Input
3 1
1 2
Output
0
Input
4 2
1 4
2 3
Output
2
Input
5 0
Output
5
Input
3 3
1 2
2 3
3 1
Output
1
Input
3 2
1 2
2 3
Output
1
Input
5 4
1 2
2 3
3 4
4 5
Output
1
Input
10 5
3 4
1 2
9 6
2 6
2 9
Output
2
|
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.NoSuchElementException;
public class Main{
int N,M;
int[] union,rank;
boolean[] used;
public boolean same(int x,int y){
return find(x) == find(y);
}
public int find(int x){
if(union[x] == x)return x;
return union[x] = find(union[x]);
}
public void unite(int x,int y){
x = find(x);
y = find(y);
if(x == y)return;
if(x < y){
union[y] = x;
rank[x] += rank[y];
}else{
union[x] = y;
rank[y] += rank[x];
}
}
public void solve() {
N = nextInt();
M = nextInt();
union = new int[N];
rank = new int[N];
used = new boolean[N];
for(int i = 0;i < N;i++)union[i] = i;
Arrays.fill(rank, 1);
for(int i = 0;i < M;i++){
int a = nextInt()-1;
int b = nextInt()-1;
unite(a,b);
}
int big = 0;
int small = 0;
for(int i = 0;i < N;i++){
int root = find(i);
if(used[root])continue;
used[root] = true;
if(rank[root] == 1)small++;
else big++;
}
out.println(Math.abs(big-small));
}
public static void main(String[] args) {
out.flush();
new Main().solve();
out.close();
}
/* Input */
private static final InputStream in = System.in;
private static final PrintWriter out = new PrintWriter(System.out);
private final byte[] buffer = new byte[2048];
private int p = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (p < buflen)
return true;
p = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0)
return false;
return true;
}
public boolean hasNext() {
while (hasNextByte() && !isPrint(buffer[p])) {
p++;
}
return hasNextByte();
}
private boolean isPrint(int ch) {
if (ch >= '!' && ch <= '~')
return true;
return false;
}
private int nextByte() {
if (!hasNextByte())
return -1;
return buffer[p++];
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = -1;
while (isPrint((b = nextByte()))) {
sb.appendCodePoint(b);
}
return sb.toString();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
|
After spending long long time, you had gotten tired of computer programming. Instead you were inter- ested in electronic construction. As your first work, you built a simple calculator. It can handle positive integers of up to four decimal digits, and perform addition, subtraction and multiplication of numbers. You didn’t implement division just because it was so complicated. Although the calculator almost worked well, you noticed that it displays unexpected results in several cases. So, you decided to try its simulation by a computer program in order to figure out the cause of unexpected behaviors.
The specification of the calculator you built is as follows. There are three registers on the calculator. The register R1 stores the value of the operation result of the latest operation; the register R2 stores the new input value; and the register R3 stores the input operator. At the beginning, both R1 and R2 hold zero, and R3 holds a null operator. The calculator has keys for decimal digits from ‘0’ to ‘9’ and operators ‘+’, ‘-’, ‘×’ and ‘=’. The four operators indicate addition, subtraction, multiplication and conclusion, respectively. When a digit key is pressed, R2 is multiplied by ten, and then added by the pressed digit (as a number). When ‘+’, ‘-’ or ‘×’ is pressed, the calculator first applies the binary operator held in R3 to the values in R1 and R2 and updates R1 with the result of the operation. Suppose R1 has 10, R2 has 3, and R3 has ‘-’ (subtraction operator), R1 is updated with 7 ( = 10 - 3). If R3 holds a null operator, the result will be equal to the value of R2. After R1 is updated, R2 is cleared to zero and R3 is set to the operator which the user entered. ‘=’ indicates termination of a computation. So, when ‘=’ is pressed, the calculator applies the operator held in R3 in the same manner as the other operators, and displays the final result to the user. After the final result is displayed, R3 is reinitialized with a null operator.
The calculator cannot handle numbers with five or more decimal digits. Because of that, if the intermediate computation produces a value less than 0 (i.e., a negative number) or greater than 9999, the calculator displays “E” that stands for error, and ignores the rest of the user input until ‘=’ is pressed.
Your task is to write a program to simulate the simple calculator.
Input
The input consists of multiple test cases.
Each line of the input specifies one test case, indicating the order of key strokes which a user entered. The input consists only decimal digits (from ‘0’ to ‘9’) and valid operators ‘+’, ‘-’, ‘*’ and ‘=’ where ‘*’ stands for ‘×’.
You may assume that ‘=’ occurs only at the end of each line, and no case contains more than 80 key strokes.
The end of input is indicated by EOF.
Output
For each test case, output one line which contains the result of simulation.
Example
Input
1+2+3+4+5+6+7+8+9+10=
1000-500-250-125=
1*2*3*4*5*6=
5000*5000=
10-100=
100*100=
10000=
Output
55
125
720
E
E
E
E
|
#include <iostream>
#include <string>
#include <cctype>
#include <cstdlib>
using namespace std;
int main()
{
int r1, r2;
char r3;
string str, fm;
bool f;
while(cin>>fm){
r1 = r2 = 0;
r3 = ' ';
f = true;
str = "";
for(int i = 0; f && i < fm.size(); ++i){
if(isdigit(fm[i])){
str += fm[i];
} else {
r2 = atoi(str.c_str());
str = "";
if(r3 == ' ') r1 = r2;
else if(r3 == '+') r1 += r2;
else if(r3 == '-') r1 -= r2;
else if(r3 == '*') r1 *= r2;
else if(r3 == '=') break;
if(r1 < 0 || r2 < 0 || r2 >= 10000 || r1 >= 10000) f = false;
r3 = fm[i];
}
}
if(!f) cout << "E" << endl;
else cout << r1 << endl;
}
return 0;
}
|
In 20XX, an efficient material transfer method was established for distant places, and human beings' advance into space was accelerated more and more. This transfer method was innovative in that, in principle, larger substances could be transferred when trying to transfer the substance farther. The details of the transfer method are described below.
First, the substance to be transferred is divided into particles for each unit mass at the start coordinates (1, 1). Each particle must be given a different wave energy. Wave energy is represented by a character string of arbitrary length consisting of V and H, and defines how particles drift in outer space. V means the movement on the coordinates (+1, 0), and H means the movement of (0, +1). For example, a particle given wave energy called VHHV drifts in the universe on the trajectories (2, 1), (2, 2), (2, 3) and then reaches the coordinates (3, 3).
In addition, there are multiple warp holes in outer space, which affect the trajectory of particles. The warp hole has an entrance and an exit, and when a particle moves to the entrance of the warp hole, it always warps to the coordinates of the exit. If the coordinates of the entrance and exit of the i-th warp hole are (ai, bi), (ci, di), the condition ai ≤ ci, bi ≤ di, (ai, bi) ≠ (ci, di) is satisfied. It is guaranteed that the entrance to the warp hole does not exist at the same coordinates as the entrance to other warp holes or at (1, 1). However, there may be multiple exits in the same location, or one warp hole exit may have another warp hole entrance (in this case, warp consecutively).
For example, if there is a warp hole with (1, 2) as the inlet and (3, 2) as the exit, the particles given HH and wave energy move to (1, 2) and then (3, 2). Warp to 2) and reach (3, 3).
When particles are given wave energy, they move according to it in an instant. When all the particles reach the destination at the same time, they are automatically reconstructed into the original substance.
You are a programmer of Japan Aerospace Exploration Agency. Since the target coordinates (N, M) of the transfer and the coordinate pairs of K warp holes are given, please write a program to find the maximum mass of the substance that can be transferred at one time. The answer can be very large, so print the remainder divided by 1,000,000,007.
Notes on Test Cases
Multiple datasets are given in the above input format. Create a program that outputs each data set in the above output format.
When N, M, K are all 0, it indicates the end of input.
<!-
Input
NMK
a1 b1 c1 d1
...
aK bK cK dK
Satisfy 1 ≤ N, M ≤ 105, 0 ≤ K ≤ 103. Also, for any 1 ≤ i ≤ K, ai ≤ ci, bi ≤ di, (ai, bi) ≠ (ci, di) is satisfied.
Output
Divide the maximum mass by 1,000,000,007 and output the remainder in one line.
Examples
Input
4 4 1
2 2 3 3
1 4 1
1 2 1 3
5 5 2
2 2 3 4
3 3 5 3
5 5 3
4 4 5 5
2 2 3 3
3 3 4 4
100000 100000 1
2 2 99999 99999
1 1 0
0 0 0
Output
12
1
26
18
615667476
1
Input
4 4 1
2 2 3 3
Output
12
Input
1 4 1
1 2 1 3
Output
1
Input
5 5 2
2 2 3 4
3 3 5 3
Output
26
Input
5 5 3
4 4 5 5
2 2 3 3
3 3 4 4
Output
18
Input
100000 100000 1
2 2 99999 99999
Output
615667476
Input
1 1 0
Output
1
|
/*
* AOJ 2214: Warp Hall
* ?¢??????????(1,1)?????°??????(m,n)???????¬??????????????????°?????????????????°????´???????????????´??\??°???????????????????´????????????????????°??§??????????
* ?±????????????°DP
* ???????????????????´?i(ai,bi)??°(ci,di)???(1,1)??°(ai,bi)???????????°???di??????????????\????´???????????????¢????????????????????????????????£???L??????????????????di????°?????´??????????DP?±???°?????°??????????´???\??£???????????°???
*/
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long LL;
const LL MOD = 1000000007ll;
inline LL add(LL a, LL b) { return (a + b) % MOD; }
inline LL sub(LL a, LL b) { return (a - b + MOD) % MOD; }
inline LL mul(LL a, LL b) { return a * b % MOD; }
LL f[200010];
LL Inverse(LL a, LL p = MOD) {
if (a == 1) return 1;
return sub(0, mul(p / a, Inverse(p % a, p)));
}
LL C(LL a, LL b) {
return mul(mul(f[a], Inverse(f[b])), Inverse(f[a - b]));
}
struct Warp {
int sx, sy, tx, ty;
bool operator<(const Warp &w) const {
if (sx != w.sx) return sx < w.sx;
return sy < w.sy;
}
} w[1010];
LL d[1010];
int m, n, k;
LL Gao(LL sx, LL sy, LL tx, LL ty) {
if (sx > tx || sy > ty) return 0;
// printf("%lld %lld %lld %lld\n", sx, sy, tx, ty);
return C(tx - sx + ty - sy, tx - sx);
}
int main() {
f[0] = 1;
for (LL i = 1; i <= 200000; ++i) {
f[i] = mul(f[i - 1], i);
}
while (scanf("%d%d%d", &m, &n, &k) != EOF && m + n + k > 0) {
for (int i = 0; i < k; ++i) {
scanf("%d%d%d%d", &w[i].sx, &w[i].sy, &w[i].tx, &w[i].ty);
--w[i].sx;
--w[i].sy;
--w[i].tx;
--w[i].ty;
}
memset(d, 0, sizeof(d));
sort(w, w + k);
w[k].sx = m - 1;
w[k].sy = n - 1;
for (int i = 0; i <= k; ++i) {
d[i] = C(w[i].sx + w[i].sy, w[i].sx);
// printf("%d %lld\n", i, d[i]);
for (int j = 0; j < i; ++j) {
// printf("--%d %d\n", i, j);
d[i] = add(d[i],
mul(d[j],
sub(Gao(w[j].tx, w[j].ty, w[i].sx, w[i].sy),
Gao(w[j].sx, w[j].sy, w[i].sx, w[i].sy))));
// printf("--%d %d\n", i, j);
}
// printf("%d %lld\n", i, d[i]);
}
printf("%lld\n", d[k]);
}
return 0;
}
|
There is a grid of size W × H surrounded by walls. Some cells in the grid are occupied by slimes. The slimes want to unite with each other and become a "King Slime".
In each move, a slime can move to east, west, south and north direction until it enters a cell occupied by another slime or hit the surrounding wall. If two slimes come together, they unite and become a new slime.
Your task is write a program which calculates the minimum number of moves that all the slimes unite and become a King Slime. Suppose slimes move one by one and they never move simultaneously.
Input
The first line contains three integers N (2 ≤ N ≤ 40,000), W and H (1 ≤ W, H ≤ 100,000), which denote the number of slimes, the width and the height of the grid respectively.
The following N lines describe the initial coordinates of the slimes. The i-th line contains two integers xi (1 ≤ xi ≤ W) and yi (1 ≤ yi ≤ H), which indicate the coordinates of the i-th slime . All the coordinates are 1-based.
You may assume that each cell is occupied by at most one slime initially.
Output
Output the minimum number of moves that all the slimes unite and become a King Slime.
Examples
Input
4 3 3
1 1
1 3
3 1
3 3
Output
3
Input
2 3 3
2 2
3 3
Output
2
Input
2 4 4
2 2
3 3
Output
3
Input
2 4 4
2 2
2 3
Output
1
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i=a;i<b;i++)
template<int um> class UF { // from kmjp
public:
vector<int> par;
UF() { par = vector<int>(um, 0); rep(i, 0, um) par[i] = i; }
int operator[](int x) { return par[x] == x ? x : par[x] = operator[](par[x]); }
void operator()(int x, int y)
{
x = operator[](x); y = operator[](y);
if (x != y) par[x] = y;
}
};
//-----------------------------------------------------------------
int N, W, H;
int X[40101], Y[40101];
UF<40101> uf;
//-----------------------------------------------------------------
int main() {
cin >> N >> W >> H;
rep(i, 0, N) cin >> X[i] >> Y[i];
rep(i, 0, N) rep(j, i + 1, N) if (X[i] == X[j] || Y[i] == Y[j]) uf(i, j);
bool isWall = false;
rep(i, 0, N) if ((X[i] == 1 || X[i] == W) || (Y[i] == 1 || Y[i] == H)) isWall = true;
int ans = 0;
rep(i, 0, N) if (uf[i] == i) ans++;
if (ans == 1)
ans = N - 1;
else {
if (isWall) ans--;
ans += N - 1;
}
cout << ans << endl;
}
|
C - Iyasugigappa
Problem Statement
Three animals Frog, Kappa (Water Imp) and Weasel are playing a card game.
In this game, players make use of three kinds of items: a guillotine, twelve noble cards and six action cards. Some integer value is written on the face of each noble card and each action card. Before stating the game, players put twelve noble cards in a line on the table and put the guillotine on the right of the noble cards. And then each player are dealt two action cards. Here, all the noble cards and action cards are opened, so the players share all the information in this game.
Next, the game begins. Each player takes turns in turn. Frog takes the first turn, Kappa takes the second turn, Weasel takes the third turn, and Frog takes the fourth turn, etc. Each turn consists of two phases: action phase and execution phase in this order.
In action phase, if a player has action cards, he may use one of them. When he uses an action card with value on the face y, y-th (1-based) noble card from the front of the guillotine on the table is moved to in front of the guillotine, if there are at least y noble cards on the table. If there are less than y cards, nothing happens. After the player uses the action card, he must discard it from his hand.
In execution phase, a player just remove a noble card in front of the guillotine. And then the player scores x points, where x is the value of the removed noble card.
The game ends when all the noble cards are removed.
Each player follows the following strategy:
* Each player assume that other players would follow a strategy such that their final score is maximized.
* Actually, Frog and Weasel follows such strategy.
* However, Kappa does not. Kappa plays so that Frog's final score is minimized.
* Kappa knows that Frog and Weasel would play under ``wrong'' assumption: They think that Kappa would maximize his score.
* As a tie-breaker of multiple optimum choises for each strategy, assume that players prefer to keep as many action cards as possible at the end of the turn.
* If there are still multiple optimum choises, players prefer to maximuze the total value of remaining action cards.
Your task in this problem is to calculate the final score of each player.
Input
The input is formatted as follows.
x_{12} x_{11} x_{10} x_9 x_8 x_7 x_6 x_5 x_4 x_3 x_2 x_1
y_1 y_2
y_3 y_4
y_5 y_6
The first line of the input contains twelve integers x_{12}, x_{11}, …, x_{1} (-2 \leq x_i \leq 5). x_i is integer written on i-th noble card from the guillotine. Following three lines contains six integers y_1, …, y_6 (1 \leq y_j \leq 4). y_1, y_2 are values on Frog's action cards, y_3, y_4 are those on Kappa's action cards, and y_5, y_6 are those on Weasel's action cards.
Output
Print three space-separated integers: the final scores of Frog, Kappa and Weasel.
Sample Input 1
3 2 1 3 2 1 3 2 1 3 2 1
1 1
1 1
1 1
Output for the Sample Input 1
4 8 12
Sample Input 2
4 4 4 3 3 3 2 2 2 1 1 1
1 2
2 3
3 4
Output for the Sample Input 2
8 10 12
Sample Input 3
0 0 0 0 0 0 0 -2 0 -2 5 0
1 1
4 1
1 1
Output for the Sample Input 3
-2 -2 5
Example
Input
3 2 1 3 2 1 3 2 1 3 2 1
1 1
1 1
1 1
Output
4 8 12
|
#include <bits/stdc++.h>
using namespace std;
constexpr int INF = 1e9;
using vi = vector<int>;
using pii = pair<int, int>;
using state = tuple<vi, int, int>;
using result = array<int, 3>;
map<state, result> memo;
map<state, result> memo2;
map<state, state> next_st;
map<state, int> get_score;
int card[3][2];
array<int, 3> make_array(int a, int b, int c) {
return {{a, b, c}};
}
enum {
frog, // maximize self score
kappa, // minimize frog score
weasel // maximize self score
};
result rec(vi fld, int action, int turn, bool k) {
if(fld.size() == 0) {
return make_array(0, 0, 0);
}
auto now = make_tuple(fld, action, turn);
if((k ? memo2 : memo).count(now) == 1) {
return (k ? memo2 : memo)[now];
}
auto& res = (k ? memo2 : memo)[now];
res = make_array(0, 0, -INF);
int sum = 0;
for(int i = 0; i < 2; ++i) {
if(action & (1 << (2 * turn + i))) {
sum += card[turn][i];
}
}
if(!k || turn == kappa) {
vector<result> cand;
vector<pii> comp;
vector<vi> next_fld;
vector<int> next_action;
vector<int> add_score;
{ // pass
auto f = fld;
int score = *f.begin();
f.erase(f.begin());
auto t = rec(f, action, (turn + 1) % 3, k);
t[turn] += score;
cand.push_back(move(t));
next_fld.push_back(f);
next_action.push_back(action);
add_score.push_back(score);
if(turn == kappa && k) {
comp.emplace_back(-cand.back()[frog], sum);
} else {
comp.emplace_back(cand.back()[turn], sum);
}
}
for(int i = 0; i < 2; ++i) {
if(action & (1 << (2 * turn + i)) && card[turn][i] <= fld.size()) {
int nxt_act = action & ~(1 << (2 * turn + i));
auto f = fld;
int score = *(f.begin() + card[turn][i] - 1);
f.erase(f.begin() + card[turn][i] - 1);
auto t = rec(f, nxt_act, (turn + 1) % 3, k);
t[turn] += score;
cand.push_back(move(t));
next_fld.push_back(f);
next_action.push_back(nxt_act);
add_score.push_back(score);
if(turn == kappa && k) {
comp.emplace_back(-cand.back()[frog], sum - card[turn][i]);
} else {
comp.emplace_back(cand.back()[turn], sum - card[turn][i]);
}
}
}
int idx = max_element(comp.begin(), comp.end()) - comp.begin();
if(!k) {
next_st[now] = make_tuple(next_fld[idx], next_action[idx], (turn + 1) % 3);
get_score[now] = add_score[idx];
}
return res = cand[idx];
} else {
vi f;
int a, t;
tie(f, a, t) = next_st[now];
auto tmp = rec(f, a, t, true);
tmp[turn] += get_score[now];
return res = tmp;
}
}
int main() {
vi fld(12);
for(int i = 11; i >= 0; --i) {
cin >> fld[i];
}
for(int i = 0; i < 3; ++i) {
for(int j = 0; j < 2; ++j) {
cin >> card[i][j];
}
}
rec(fld, 0b111111, 0, false);
auto res = rec(fld, 0b111111, 0, true);
cout << res[0] << ' ' << res[1] << ' ' << res[2] << endl;
}
|
ABC Gene
There is a gene sequence represented by the string `ABC`. You can rewrite this gene sequence by performing the following operations several times.
* Choose one of the letters `A`,` B`, `C`. Let this be x. Replace all x in the gene sequence with `ABC` at the same time.
Given a string S consisting only of `A`,` B`, and `C`. Determine if the gene sequence can be matched to S.
Constraints
* 1 ≤ | S | ≤ 5,000
* S consists only of `A`,` B`, and `C`.
Input Format
Input is given from standard input in the following format.
S
Output Format
Output `Yes` if the gene sequence can be matched to S, and` No` if it cannot be matched.
Sample Input 1
ABC
Sample Output 1
Yes
The gene sequence is `ABC` from the beginning.
Sample Input 2
AABCC
Sample Output 2
Yes
If you select `B` and perform the operation, it becomes` ABC` → `AABCC`.
Sample Input 3
AABCABC
Sample Output 3
No
For example, even if you select `C` and perform an operation, it does not change from` AABCC` to `AABCABC`. Since all `C`s are replaced with` ABC` at the same time, the actual result is `AABCC` →` AABABCABC`.
Example
Input
ABC
Output
Yes
|
#include <bits/stdc++.h>
#define REP(i,n,N) for(int i=n;i<N;i++)
#define p(S) cout<<(S)<<endl
#define ck(a,b) (0<=(a)&&(a)<b)
using namespace std;
string abcgene(string anss){
queue<string> q;
q.push(anss);
string c[3]={"A","B","C"};
map<string,bool> m;
m[anss]=true;
while(!q.empty()){
string s=q.front();
q.pop();
if(s=="ABC") return "Yes";
REP(j,0,3){
string tmps=s;
int cnt=0;
REP(i,0,(int) tmps.size()-2){
if(tmps[i]=='A'&&tmps[i+1]=='B'&&tmps[i+2]=='C'){
tmps.replace(i,3,c[j]);
cnt++;
}
}
if(cnt != count(tmps.begin(),tmps.end(),'A'+j)) continue;
if(!m[tmps]) {
m[tmps]=true;
q.push(tmps);
}
}
}
return "No";
}
int main(){
string ans;
cin>>ans;
p(abcgene(ans));
return 0;
}
|
Chokudai loves eating so much. However, his doctor Akensho told him that he was overweight, so he finally decided to lose his weight.
Chokudai made a slimming plan of a $D$-day cycle. It is represented by $D$ integers $w_0, ..., w_{D-1}$. His weight is $S$ on the 0-th day of the plan and he aims to reduce it to $T$ ($S > T$). If his weight on the $i$-th day of the plan is $x$, it will be $x + w_{i\%D}$ on the $(i+1)$-th day. Note that $i\%D$ is the remainder obtained by dividing $i$ by $D$. If his weight successfully gets less than or equal to $T$, he will stop slimming immediately.
If his slimming plan takes too many days or even does not end forever, he should reconsider it.
Determine whether it ends or not, and report how many days it takes if it ends.
Input
The input consists of a single test case formatted as follows.
$S$ $T$ $D$
$w_0 ... w_{D-1}$
The first line consists of three integers $S$, $T$, $D$ ($1 \leq S, T, D \leq 100,000, S > T$). The second line consists of $D$ integers $w_0, ..., w_{D-1}$ ($-100,000 \leq w_i \leq 100,000$ for each $i$).
Output
If Chokudai's slimming plan ends on the $d$-th day, print $d$ in one line. If it never ends, print $-1$.
Examples
Input
65 60 3
-2 3 -4
Output
4
Input
65 60 3
-2 10 -3
Output
-1
Input
100000 1 1
-1
Output
99999
Input
60 59 1
-123
Output
1
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll,ll> mp;
ll inf = 1e9;
int main(){
ll s,t,d;
cin>>s>>t>>d;
ll aim = s-t;
vector<ll> w(d);
for(ll i=0;i<d;i++)cin>>w[i];
ll sumw = w[0];
vector<ll> dp(d,0);
dp[0] = w[0];
for(ll i=1;i<d;i++)sumw += w[i],dp[i] = dp[i-1] + w[i];
ll mi = inf;
for(ll i=0;i<d;i++){
if( aim + dp[i] <= 0 ){
cout<<i+1<<endl;
return 0;
}
mi = min( mi , dp[i] );
}
if( sumw >= 0 ){
cout<<-1<<endl;
return 0;
}
mi = abs( mi );
ll res = ( aim - mi )/(-sumw) ;
aim += res * sumw ;
res *= d;
while( aim > 0 ){
aim +=w[ res % d ];
res++;
}
cout<<res<<endl;
return 0;
}
|
H: Colorful Tree
Story
Yamiuchi (assassination) is a traditional event that is held annually in JAG summer camp. Every team displays a decorated tree in the dark and all teams' trees are compared from the point of view of their colorfulness. In this competition, it is allowed to cut the other teams’ tree to reduce its colorfulness. Despite a team would get a penalty if it were discovered that the team cuts the tree of another team, many teams do this obstruction.
You decided to compete in Yamiuchi and write a program that maximizes the colorfulness of your team’s tree. The program has to calculate maximum scores for all subtrees in case the other teams cut your tree.
Problem Statement
You are given a rooted tree G with N vertices indexed with 1 through N. The root is vertex 1. There are K kinds of colors indexed with 1 through K. You can paint vertex i with either color c_i or d_i. Note that c_i = d_i may hold, and if so you have to paint vertex i with c_i (=d_i).
Let the colorfulness of tree T be the number of different colors in T. Your task is to write a program that calculates maximum colorfulness for all rooted subtrees. Note that coloring for each rooted subtree is done independently, so previous coloring does not affect to other coloring.
Input
N K
u_1 v_1
:
u_{N-1} v_{N-1}
c_1 d_1
:
c_N d_N
The first line contains two integers N and K in this order.
The following N-1 lines provide information about the edges of G. The i-th line of them contains two integers u_i and v_i, meaning these two vertices are connected with an edge.
The following N lines provide information about color constraints. The i-th line of them contains two integers c_i and d_i explained above.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq K \leq 2\times 10^5
* 1 \leq u_i , v_i \leq N
* 1 \leq c_i , d_i \leq K
* The input graph is a tree.
* All inputs are integers.
Output
Output N lines.
The i-th line of them contains the maximum colorfulness of the rooted subtree of G whose root is i.
Sample Input 1
2 10
1 2
1 9
8 7
Output for Sample Input 1
2
1
Sample Input 2
3 2
1 2
1 3
1 2
1 1
1 2
Output for Sample Input 2
2
1
1
Note that two color options of a vertex can be the same.
Sample Input 3
5 100000
4 3
3 5
1 3
2 1
3 2
1 3
2 1
4 2
1 4
Output for Sample Input 3
4
1
3
1
1
Example
Input
2 10
1 2
1 9
8 7
Output
2
1
|
#include<bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define fi first
#define se second
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
template <typename T> bool chkmax(T &x,T y){return x<y?x=y,true:false;}
template <typename T> bool chkmin(T &x,T y){return x>y?x=y,true:false;}
int readint(){
int x=0,f=1; 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 x*f;
}
int n,m,tot,now;
int v[200005],nxt[200005],h[100005],siz[100005],f[200005],son[100005],col[200005],a[100005],b[100005],ans[100005];
bool vis[200005];
vector<int> gar;
int getf(int x){return x==f[x]?x:f[x]=getf(f[x]);}
void addedge(int x,int y){
v[++tot]=y; nxt[tot]=h[x]; h[x]=tot;
v[++tot]=x; nxt[tot]=h[y]; h[y]=tot;
}
void dfs1(int u,int fa){
siz[u]=1;
for(int p=h[u];p;p=nxt[p]){
if(v[p]==fa) continue;
dfs1(v[p],u);
if(siz[v[p]]>siz[son[u]]) son[u]=v[p];
siz[u]+=siz[v[p]];
}
}
void change(int x,int y){
if(!col[x]) gar.pb(x),col[x]=1;
if(!col[y]) gar.pb(y),col[y]=1;
int fx=getf(x),fy=getf(y);
if(fx==fy){
if(!vis[fx]) now++,vis[fx]=1;
return;
}
f[fx]=fy;
if(!vis[fx]&&!vis[fy]){
now++;
return;
}
if(vis[fx]&&vis[fy]) return;
vis[fy]=1,now++;
}
void add(int u,int fa){
change(a[u],b[u]);
for(int p=h[u];p;p=nxt[p]){
if(v[p]==fa) continue;
add(v[p],u);
}
}
void dfs2(int u,int fa,bool kp){
for(int p=h[u];p;p=nxt[p]) if(v[p]!=fa&&v[p]!=son[u]) dfs2(v[p],u,0);
if(son[u]) dfs2(son[u],u,1);
for(int p=h[u];p;p=nxt[p]) if(v[p]!=fa&&v[p]!=son[u]) add(v[p],u);
change(a[u],b[u]);
ans[u]=now;
if(!kp){
for(auto x:gar) f[x]=x,vis[x]=0,col[x]=0;
gar.clear();
now=0;
}
}
int main(){
n=readint(); m=readint();
for(int i=1;i<=m;i++) f[i]=i;
for(int i=1;i<n;i++) addedge(readint(),readint());
for(int i=1;i<=n;i++) a[i]=readint(),b[i]=readint();
dfs1(1,-1);
dfs2(1,-1,1);
for(int i=1;i<=n;i++) printf("%d\n",ans[i]);
return 0;
}
|
Write a program which prints $n$-th fibonacci number for a given integer $n$. The $n$-th fibonacci number is defined by the following recursive formula:
\begin{equation*} fib(n)= \left \\{ \begin{array}{ll} 1 & (n = 0) \\\ 1 & (n = 1) \\\ fib(n - 1) + fib(n - 2) & \\\ \end{array} \right. \end{equation*}
Constraints
* $0 \leq n \leq 44$
Input
An integer $n$ is given.
Example
Input
3
Output
3
|
#include<iostream>
using namespace std;
int main(){
const int MAX=46;
long long f[MAX]={1,1};
for(int i=2;i<MAX;i++)f[i]=f[i-1]+f[i-2];
int n;
cin>>n;
cout<<f[n]<<endl;
return 0;
}
|
Write a program which calculates the distance between two points P1(x1, y1) and P2(x2, y2).
Input
Four real numbers x1, y1, x2 and y2 are given in a line.
Output
Print the distance in real number. The output should not contain an absolute error greater than 10-4.
Example
Input
0 0 1 1
Output
1.41421356
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double x1 = sc.nextDouble();
double y1 = sc.nextDouble();
double x2 = sc.nextDouble();
double y2 = sc.nextDouble();
double xx = x2 - x1;
double yy = y2 - y1;
double xxyy = xx * xx + yy * yy;
System.out.println(Math.sqrt(xxyy));
}
}
|
Brachiosaurus is trying to become a detective by writing words in codes. It manipulates each word in a sentence by putting the letter 'z' after each vowel, followed by that very vowel.
Eg- "belina" translates into "bezelizinaza" and "zazhiba" translates into "zazazhizibaza". A team of secret agents want to decode the sentences of Brachiosaurus.
Write a program that decodes Brachiosaurus's coded sentences.
Input
The coded sentence is given on a single line. The sentence comprises only of lowercase letters of the English alphabet and spaces. The words will be separated by exactly one space and there will be no spaces at beginning or end. The number of characters (total) will be 100 at the max.
Output
The decoded sentence is to be outputted on a single line.
Example
Input:
razat geze hozotazamnaza ozoraza bezehizisaza
Output:
rat ge hotamna ora behisa
|
# imports
import sys
import StringIO
class Problem(object):
def __init__(self, reader):
self.reader = reader
def run(self):
vowels = frozenset(["a", "e", "i", "o", "u"])
last_vowel_block = -1
# decode the message, by replacing the vowel pattterns
for i, letter in enumerate( self.reader.readline().strip() ) :
if i > last_vowel_block :
if letter in vowels:
last_vowel_block = i + 2
sys.stdout.write(letter)
# Main entry point
############################################################
if __name__ == "__main__":
#data = StringIO.StringIO("""razat geze hozotazamnaza ozoraza bezehizisaza""")
data = sys.stdin
problem = Problem(data)
problem.run()
|
While Tom Cruise(Cage) fighting in the movie "Edge of Tomorrow", he finds himself in a modern lab, where he needs to kill the brain of a mutant species Omega.
The DNA of the Omega is made up of characters of A, T, G and C like ours. He has certain enzymes which will cut and remove certain parts of this DNA.
The mutant being an intelligent species, is able to reform its DNA, even after a piece of DNA is removed.
You will be given a DNA sequence, and few enzymes. Suppose, a DNA sequence goes like this : ATGCTGCTATGCATGCAGTGACT, and you are given enzymes which can remove AT and GC sequences. Thereby, you need to remove all occurrences of AT from the DNA first and then reform the DNA and apply the next enzyme to remove all occurrences of GC. The output of the problem would be the string you get at last reforming the pieces which are not removed by these enzymes.
Input
The first line of input consists of an integer n that denotes the number of enzymes. The second line has the DNA sequence.
The next n lines has the input B1, B2, B3... Bn.
Output
For given input DNA sequence, output a single line containing the final reformed DNA that is formed by repeatedly removing all the occurrences of B1, B2, B3... Bn from A.
In case the DNA is completely consumed print 0 to indicate that there is no DNA left.
Constraints
1 <= n <= 10
Example
Input:
2
ATACGCATGACGATGCATGCAGCAT
ATA
GC
Output:
CATGACGATATAAT
Input:
3
ATGCATGCATCGACTCAGCATCAGCATCGACTA
TG
GC
AT
Output:
ACACCGACTCACACGACTA
|
import sys
t=input()
str1=raw_input()
for _ in range(t):
ss=raw_input()
str1=str1.replace(ss, "")
if(len(str1)==0):
print '0'
else:
print str1
|
The success of IEEE code-quest depends on number of times the factor is present in a given string.Help core members to find them
Factor of string is defined as a substring.In this case it's '01'.
Input
First line of input contains an integer T, denoting the number of test cases. Then follows description of T cases.Each line of input is a binary form.
Output
Print the number of times the factor is present in a given string.
Constraints
1 <= S <= 100000
1 <= T <= 50
Example
Input:
1
1001010100001
Output:
4
|
'''
Coded by Abhishek The Hacktivist
'''
test = int(raw_input())
for i in range(test):
count = 0
num = str(raw_input().split())
for j in range(len(num)):
if (num[j] == '0') and (num[j+1] == '1'):
count += 1
print count
|
One day maths teacher gave the following task for the students, only upon completion students will be taken out for a school fun trip.
First you are a given a list of n numbers and q queries. For each query you are given two indices x and y , you have to report the between the maximum number and minimum number whose indices lie within x and y (both inclusive)
Input
First line of input has two integers n and q , denoting the size of list and number of queries
Next line consists of n spaced integers denoting the elements of the array
Next q lines consists of two integer x and y , denoting the leftmost and rightmost indices of the query
Note : List is 0-indexed
Output
For each query , print the answer in a new line.
Constraints
0< n,q < 100000
0< element of list < 1000000000
0 < x,y < n
Example
Input:
5 2
1 2 3 4 5
1 2
4 4
Output:
1
0
Explanation
Example case .
First query maximum number in given range is 3 and minimum number is 2 so difference 1
Second Query maximum and mimimum both are 5 ,difference is 0
|
dic={}
n, q = map(int, raw_input().split())
li = map(int, raw_input().split())
for i in xrange(q):
l, r = map(int, raw_input().split())
tli=li[l:r+1]
s=str(l) + '+' + str(r)
if s not in dic:
dic[s] = max(tli) - min(tli)
print dic[s]
|
Sometimes mysteries happen. Chef found a directed graph with N vertices and M edges in his kitchen!
The evening was boring and chef has nothing else to do, so to entertain himself, Chef thought about a question "What is the minimum number of edges he needs to reverse in order to have at least one path from vertex 1 to vertex N, where the vertices are numbered from 1 to N.
Input
Each test file contains only one test case.
The first line of the input contains two space separated integers N and M, denoting the number of vertices and the number of edges in the graph respectively. The i^th line of the next M lines contains two space separated integers Xi and Yi, denoting that the i^th edge connects vertices from Xi to Yi.
Output
In a single line, print the minimum number of edges we need to revert. If there is no way of having at least one path from 1 to N, print -1.
Constraints
1 ≤ N, M ≤ 100000 = 10^5
1 ≤ Xi, Yi ≤ N
There can be multiple edges connecting the same pair of vertices, There can be self loops too i.e. Xi = Yi
Example
Input:
7 7
1 2
3 2
3 4
7 4
6 2
5 6
7 5
Output:
2
Explanation
We can consider two paths from 1 to 7:
1-2-3-4-7
1-2-6-5-7
In the first one we need to revert edges (3-2), (7-4). In the second one - (6-2), (5-6), (7-5). So the answer is min(2, 3) = 2.
|
from sys import stdin
from heapq import heappush, heappop
def v_con(M, graph, N):
while M > 0:
a, b = map(int, stdin.readline().split())
graph[a][b] = 0
if not graph[b].has_key(a):
if a == 1 and b == N:
graph[b][a] = 1
elif a != 1:
graph[b][a] = 1
M = M - 1
return graph
def relax(G, u, v, D):
d = D.get(u, float('inf'))+G[u][v]
if d < D.get(v, float('inf')):
D[v] = d
return True
def dijkstra(G, s=1):
D, Q, S = {s:0}, [(0,s)], set()
while Q:
_, u = heappop(Q)
if u in S: continue
S.add(u)
for v in graph[u]:
relax(graph, u, v, D)
heappush(Q, (D[v], v))
return D
N, M = map(int, stdin.readline().split())
graph = [0]
L = N
while L>0:
graph.append({})
L = L - 1
graph = v_con(M, graph, N)
D = dijkstra(graph)
if D.has_key(N):
print D[N]
else:
print -1
|
Little kids, Jack and Evan like playing their favorite game Glass-and-Stone. Today they want to play something new and came across Twitter on their father's laptop.
They saw it for the first time but were already getting bored to see a bunch of sentences having at most 140 characters each. The only thing they liked to play with it is, closing and opening tweets.
There are N tweets on the page and each tweet can be opened by clicking on it, to see some statistics related to that tweet. Initially all the tweets are closed. Clicking on an open tweet closes it and clicking on a closed tweet opens it. There is also a button to close all the open tweets. Given a sequence of K clicks by Jack, Evan has to guess the total number of open tweets just after each click. Please help Evan in this game.
Input
First line contains two integers N K, the number of tweets (numbered 1 to N) and the number of clicks respectively (1 ≤ N, K ≤ 1000). Each of the following K lines has one of the following.
CLICK X , where X is the tweet number (1 ≤ X ≤ N)
CLOSEALL
Output
Output K lines, where the i^th line should contain the number of open tweets just after the i^th click.
Example
Input:
3 6
CLICK 1
CLICK 2
CLICK 3
CLICK 2
CLOSEALL
CLICK 1
Output:
1
2
3
2
0
1
Explanation:
Let open[x] = 1 if the x^th tweet is open and 0 if its closed.
Initially open[1..3] = { 0 , 0 , 0 }. Here is the state of open[1..3] after each click and corresponding count of open tweets.
CLICK 1 : { 1, 0, 0 }, open count = 1
CLICK 2 : { 1, 1, 0 }, open count = 2
CLICK 3 : { 1, 1, 1 }, open count = 3
CLICK 2 : { 1, 0, 1 }, open count = 2
CLOSEALL : { 0, 0, 0 }, open count = 0
CLICK 1 : { 1, 0, 0 }, open count = 1
|
# your code goes here
n,k=map(int,raw_input().split())
a=[0 for i in range(n)]
cou=0
for i in range(k):
t=raw_input().split()
if len(t)==1:
for j in range(n):
a[j]=0
cou=0
else:
x=int(t[1])-1
a[x]^=1
if a[x]==0:
cou-=1
else:
cou+=1
print cou
|
This is an interactive problem.
Imur Ishakov decided to organize a club for people who love to play the famous game «The hat». The club was visited by n students, where n is even. Imur arranged them all in a circle and held a draw to break the students in pairs, but something went wrong. The participants are numbered so that participant i and participant i + 1 (1 ≤ i ≤ n - 1) are adjacent, as well as participant n and participant 1. Each student was given a piece of paper with a number in such a way, that for every two adjacent students, these numbers differ exactly by one. The plan was to form students with the same numbers in a pair, but it turned out that not all numbers appeared exactly twice.
As you know, the most convenient is to explain the words to the partner when he is sitting exactly across you. Students with numbers i and <image> sit across each other. Imur is wondering if there are two people sitting across each other with the same numbers given. Help him to find such pair of people if it exists.
You can ask questions of form «which number was received by student i?», and the goal is to determine whether the desired pair exists in no more than 60 questions.
Input
At the beginning the even integer n (2 ≤ n ≤ 100 000) is given — the total number of students.
You are allowed to ask no more than 60 questions.
Output
To ask the question about the student i (1 ≤ i ≤ n), you should print «? i». Then from standard output you can read the number ai received by student i ( - 109 ≤ ai ≤ 109).
When you find the desired pair, you should print «! i», where i is any student who belongs to the pair (1 ≤ i ≤ n). If you determined that such pair doesn't exist, you should output «! -1». In both cases you should immediately terminate the program.
The query that contains your answer is not counted towards the limit of 60 queries.
Please make sure to flush the standard output after each command. For example, in C++ use function fflush(stdout), in Java call System.out.flush(), in Pascal use flush(output) and stdout.flush() for Python language.
Hacking
Use the following format for hacking:
In the first line, print one even integer n (2 ≤ n ≤ 100 000) — the total number of students.
In the second line print n integers ai ( - 109 ≤ ai ≤ 109) separated by spaces, where ai is the number to give to i-th student. Any two adjacent elements, including n and 1, must differ by 1 or - 1.
The hacked solution will not have direct access to the sequence ai.
Examples
Input
8
<span class="tex-span"></span>
2
<span class="tex-span"></span>
2
Output
<span class="tex-span"></span>
? 4
<span class="tex-span"></span>
? 8
<span class="tex-span"></span>
! 4
Input
6
<span class="tex-span"></span>
1
<span class="tex-span"></span>
2
<span class="tex-span"></span>
3
<span class="tex-span"></span>
2
<span class="tex-span"></span>
1
<span class="tex-span"></span>
0
Output
<span class="tex-span"></span>
? 1
<span class="tex-span"></span>
? 2
<span class="tex-span"></span>
? 3
<span class="tex-span"></span>
? 4
<span class="tex-span"></span>
? 5
<span class="tex-span"></span>
? 6
<span class="tex-span"></span>
! -1
Note
Input-output in statements illustrates example interaction.
In the first sample the selected sequence is 1, 2, 1, 2, 3, 4, 3, 2
In the second sample the selection sequence is 1, 2, 3, 2, 1, 0.
|
#include <bits/stdc++.h>
using namespace std;
int n;
map<int, int> mp;
int Get(int x) {
if (mp.count(x)) return mp[x];
printf("? %d\n", x);
fflush(stdout);
int y;
scanf("%d", &y);
return mp[x] = y;
}
void Print(int x) {
printf("! %d\n", x);
exit(0);
}
int main() {
scanf("%d", &n);
if (n % 4) Print(-1);
int a = Get(n / 2), b = Get(n);
int l1 = 1, r1 = n / 2 - 1;
int l2 = n / 2 + 1, r2 = n - 1;
if (a == b) Print(n);
while (true) {
int mid1 = (l1 + r1) >> 1;
int mid2 = (l2 + r2) >> 1;
int x = Get(mid1), y = Get(mid2);
if (x == y)
Print(mid1);
else if ((a < b && x > y) || (a > b && x < y)) {
l1 = mid1 + 1;
l2 = mid2 + 1;
} else {
r1 = mid1 - 1;
r2 = mid2 - 1;
}
}
return 0;
}
|
There are n benches in the Berland Central park. It is known that a_i people are currently sitting on the i-th bench. Another m people are coming to the park and each of them is going to have a seat on some bench out of n available.
Let k be the maximum number of people sitting on one bench after additional m people came to the park. Calculate the minimum possible k and the maximum possible k.
Nobody leaves the taken seat during the whole process.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of benches in the park.
The second line contains a single integer m (1 ≤ m ≤ 10 000) — the number of people additionally coming to the park.
Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ 100) — the initial number of people on the i-th bench.
Output
Print the minimum possible k and the maximum possible k, where k is the maximum number of people sitting on one bench after additional m people came to the park.
Examples
Input
4
6
1
1
1
1
Output
3 7
Input
1
10
5
Output
15 15
Input
3
6
1
6
5
Output
6 12
Input
3
7
1
6
5
Output
7 13
Note
In the first example, each of four benches is occupied by a single person. The minimum k is 3. For example, it is possible to achieve if two newcomers occupy the first bench, one occupies the second bench, one occupies the third bench, and two remaining — the fourth bench. The maximum k is 7. That requires all six new people to occupy the same bench.
The second example has its minimum k equal to 15 and maximum k equal to 15, as there is just a single bench in the park and all 10 people will occupy it.
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 100010;
int n, m;
int a[INF];
int ss;
int maxn = 0;
int ans;
int main() {
cin >> n >> m;
ss = m;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] >= maxn) maxn = a[i];
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
if (a[i] != maxn) ans += maxn - a[i];
}
if (ans >= m)
cout << maxn;
else {
ans = m - ans;
ans = (ans + n - 1) / n;
cout << maxn + ans;
}
cout << " " << a[n - 1] + m;
return 0;
}
|
At the children's festival, children were dancing in a circle. When music stopped playing, the children were still standing in a circle. Then Lena remembered, that her parents gave her a candy box with exactly k candies "Wilky May". Lena is not a greedy person, so she decided to present all her candies to her friends in the circle. Lena knows, that some of her friends have a sweet tooth and others do not. Sweet tooth takes out of the box two candies, if the box has at least two candies, and otherwise takes one. The rest of Lena's friends always take exactly one candy from the box.
Before starting to give candies, Lena step out of the circle, after that there were exactly n people remaining there. Lena numbered her friends in a clockwise order with positive integers starting with 1 in such a way that index 1 was assigned to her best friend Roma.
Initially, Lena gave the box to the friend with number l, after that each friend (starting from friend number l) took candies from the box and passed the box to the next friend in clockwise order. The process ended with the friend number r taking the last candy (or two, who knows) and the empty box. Please note that it is possible that some of Lena's friends took candy from the box several times, that is, the box could have gone several full circles before becoming empty.
Lena does not know which of her friends have a sweet tooth, but she is interested in the maximum possible number of friends that can have a sweet tooth. If the situation could not happen, and Lena have been proved wrong in her observations, please tell her about this.
Input
The only line contains four integers n, l, r and k (1 ≤ n, k ≤ 10^{11}, 1 ≤ l, r ≤ n) — the number of children in the circle, the number of friend, who was given a box with candies, the number of friend, who has taken last candy and the initial number of candies in the box respectively.
Output
Print exactly one integer — the maximum possible number of sweet tooth among the friends of Lena or "-1" (quotes for clarity), if Lena is wrong.
Examples
Input
4 1 4 12
Output
2
Input
5 3 4 10
Output
3
Input
10 5 5 1
Output
10
Input
5 4 5 6
Output
-1
Note
In the first example, any two friends can be sweet tooths, this way each person will receive the box with candies twice and the last person to take sweets will be the fourth friend.
In the second example, sweet tooths can be any three friends, except for the friend on the third position.
In the third example, only one friend will take candy, but he can still be a sweet tooth, but just not being able to take two candies. All other friends in the circle can be sweet tooths as well, they just will not be able to take a candy even once.
In the fourth example, Lena is wrong and this situation couldn't happen.
|
//package CodeForces.Round516_div2;
import java.util.Scanner;
/**
* @Author: tianchengjiang
* @Date：2018/10/22
*/
public class problemF {
public static Scanner scanner = new Scanner(System.in);
public static void main(String[] args) {
while (scanner.hasNext()) {
long n = scanner.nextLong();
long l = scanner.nextLong();
long r = scanner.nextLong();
long k = scanner.nextLong();
long maxm = -1;
long rangeX = r-l+1;
if(rangeX <=0){
rangeX += n;
}
long rangeY = n-rangeX;
if(n <= Math.cbrt(k)){
for(long x=0;x<=rangeX;x++){
for(long y=0;y<=rangeY;y++){
long temp = k - x - rangeX;
if(temp >= 0 && temp %(rangeX+rangeY+x+y) ==0){
maxm = Math.max(maxm,x+y);
}
if( x>0 && temp+1 >=0 && (temp+1)%(rangeX+rangeY+x+y) == 0){
maxm = Math.max(maxm,x+y);
}
}
}
}else{
for(long t=0;t<=k/n;t++){
long temp = k - n * t - rangeX;
if(temp>=0){
if(t == 0 ){
if( temp <= rangeX){
maxm = Math.max(maxm, temp + rangeY);
}
if(temp +1<= rangeX){
maxm = Math.max(maxm,temp + 1 + rangeY);
}
}else {
long zmin = Math.max(ge(temp - rangeX, t), ge(temp, t + 1));
long zmax = Math.min(le(temp, t), le(temp + rangeY, t + 1));
if (zmax >= zmin) {
maxm = Math.max(maxm, zmax);
}
temp++;
zmin = Math.max(ge(temp - rangeX, t), ge(temp, t + 1));
zmax = Math.min(le(temp-1, t), le(temp + rangeY, t + 1));
if (zmax >= zmin) {
maxm = Math.max(maxm, zmax);
}
}
}
}
}
System.out.println(maxm);
}
}
public static long ple(long fz, long fm) { // fz >= 0, fm > 0
return fz / fm;
}
public static long pge(long fz, long fm) { //fz >= 0, fm > 0
return (fz + fm - 1) / fm;
}
public static long le (long fz, long fm) {
return fz >= 0 ? ple(fz, fm) : -pge(-fz, fm); // 别忘了pge(-fz, fm)前面的负号！
}
public static long ge(long fz, long fm) {
return fz >= 0 ? pge(fz, fm) : -ple(-fz, fm);
}
}
|
n players are going to play a rock-paper-scissors tournament. As you probably know, in a one-on-one match of rock-paper-scissors, two players choose their shapes independently. The outcome is then determined depending on the chosen shapes: "paper" beats "rock", "rock" beats "scissors", "scissors" beat "paper", and two equal shapes result in a draw.
At the start of the tournament all players will stand in a row, with their numbers increasing from 1 for the leftmost player, to n for the rightmost player. Each player has a pre-chosen shape that they will use in every game throughout the tournament. Here's how the tournament is conducted:
* If there is only one player left, he is declared the champion.
* Otherwise, two adjacent players in the row are chosen arbitrarily, and they play the next match. The losing player is eliminated from the tournament and leaves his place in the row (with his former neighbours becoming adjacent). If the game is a draw, the losing player is determined by a coin toss.
The organizers are informed about all players' favoured shapes. They wish to find out the total number of players who have a chance of becoming the tournament champion (that is, there is a suitable way to choose the order of the games and manipulate the coin tosses). However, some players are still optimizing their strategy, and can inform the organizers about their new shapes. Can you find the number of possible champions after each such request?
Input
The first line contains two integers n and q — the number of players and requests respectively (1 ≤ n ≤ 2 ⋅ 10^5, 0 ≤ q ≤ 2 ⋅ 10^5).
The second line contains a string of n characters. The i-th of these characters is "R", "P", or "S" if the player i was going to play "rock", "paper", or "scissors" before all requests respectively.
The following q lines describe the requests. The j-th of these lines contain an integer p_j and a character c_j meaning that the player p_j is going to use the shape described by the character c_j from this moment (1 ≤ p_j ≤ n).
Output
Print q + 1 integers r_0, …, r_q, where r_k is the number of possible champions after processing k requests.
Example
Input
3 5
RPS
1 S
2 R
3 P
1 P
2 P
Output
2
2
1
2
2
3
|
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long exp(long long a, long long b, long long m) {
if (b == 0) return 1;
if (b == 1) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
struct Bit {
vector<long long> BIT;
long long N;
Bit() {}
Bit(long long n) {
BIT.resize(n + 100, 0);
N = n + 10;
}
void update(long long x, long long v) {
while (x < N) {
BIT[x] += v;
x += (x & -x);
}
}
long long sum(long long x) {
long long r = 0;
while (x > 0) {
r += BIT[x];
x -= (x & -x);
}
return r;
}
long long query(long long l, long long r) { return sum(r) - sum(l - 1); }
};
long long mat[200100];
set<long long> S[3];
vector<Bit> BIT;
void upd(long long pos, long long c, long long f) {
if (f) {
BIT[c].update(pos, 1);
S[c].insert(pos);
} else {
long long last = mat[pos];
BIT[last].update(pos, -1);
S[last].erase(pos);
mat[pos] = c;
BIT[c].update(pos, 1);
S[c].insert(pos);
}
}
long long n, q;
void ask() {
for (long long i = 0; i < 3; i++) {
if (S[i].size() == 0) {
if (i == 2) {
cout << S[1].size() << "\n";
return;
}
if (i == 0) {
if (S[2].size() == 0) {
cout << S[1].size() << "\n";
} else
cout << S[2].size() << "\n";
return;
}
if (i == 1) {
cout << S[0].size() << "\n";
return;
}
return;
}
}
long long res = n;
for (long long i = 0; i < 3; i++) {
if (i == 0) {
long long l = *S[1].begin();
long long r = *S[2].begin();
if (l <= r) res -= BIT[i].query(l, r);
r = *S[1].rbegin();
l = *S[2].rbegin();
if (l <= r) res -= BIT[i].query(l, r);
}
if (i == 1) {
long long l = *S[2].begin();
long long r = *S[0].begin();
if (l <= r) res -= BIT[i].query(l, r);
r = *S[2].rbegin();
l = *S[0].rbegin();
if (l <= r) res -= BIT[i].query(l, r);
}
if (i == 2) {
long long l = *S[0].begin();
long long r = *S[1].begin();
if (l <= r) res -= BIT[i].query(l, r);
r = *S[0].rbegin();
l = *S[1].rbegin();
if (l <= r) res -= BIT[i].query(l, r);
}
}
cout << res << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> q;
map<char, long long> mp;
mp['P'] = 0;
mp['S'] = 1;
mp['R'] = 2;
BIT = vector<Bit>(3);
for (long long i = 0; i < 3; i++) {
BIT[i] = Bit(n);
for (long long j = 0; j < n + 10; j++) {
BIT[i].BIT[j] = 0;
}
}
for (long long i = 1; i <= n; i++) {
char cc;
cin >> cc;
mat[i] = mp[cc];
upd(i, mat[i], 1);
}
ask();
while (q--) {
long long p;
char cc;
cin >> p >> cc;
long long c = mp[cc];
upd(p, c, 0);
ask();
}
}
|
Lunar New Year is approaching, and Bob decides to take a wander in a nearby park.
The park can be represented as a connected graph with n nodes and m bidirectional edges. Initially Bob is at the node 1 and he records 1 on his notebook. He can wander from one node to another through those bidirectional edges. Whenever he visits a node not recorded on his notebook, he records it. After he visits all nodes at least once, he stops wandering, thus finally a permutation of nodes a_1, a_2, …, a_n is recorded.
Wandering is a boring thing, but solving problems is fascinating. Bob wants to know the lexicographically smallest sequence of nodes he can record while wandering. Bob thinks this problem is trivial, and he wants you to solve it.
A sequence x is lexicographically smaller than a sequence y if and only if one of the following holds:
* x is a prefix of y, but x ≠ y (this is impossible in this problem as all considered sequences have the same length);
* in the first position where x and y differ, the sequence x has a smaller element than the corresponding element in y.
Input
The first line contains two positive integers n and m (1 ≤ n, m ≤ 10^5), denoting the number of nodes and edges, respectively.
The following m lines describe the bidirectional edges in the graph. The i-th of these lines contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n), representing the nodes the i-th edge connects.
Note that the graph can have multiple edges connecting the same two nodes and self-loops. It is guaranteed that the graph is connected.
Output
Output a line containing the lexicographically smallest sequence a_1, a_2, …, a_n Bob can record.
Examples
Input
3 2
1 2
1 3
Output
1 2 3
Input
5 5
1 4
3 4
5 4
3 2
1 5
Output
1 4 3 2 5
Input
10 10
1 4
6 8
2 5
3 7
9 4
5 6
3 4
8 10
8 9
1 10
Output
1 4 3 7 9 8 6 5 2 10
Note
In the first sample, Bob's optimal wandering path could be 1 → 2 → 1 → 3. Therefore, Bob will obtain the sequence \{1, 2, 3\}, which is the lexicographically smallest one.
In the second sample, Bob's optimal wandering path could be 1 → 4 → 3 → 2 → 3 → 4 → 1 → 5. Therefore, Bob will obtain the sequence \{1, 4, 3, 2, 5\}, which is the lexicographically smallest one.
|
import java.util.*;
import java.lang.*;
import java.io.*;
public class MAIN {
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
static class triple
{
int x , y ,z ;
triple(int x ,int y ,int z)
{
this.x=x;
this.y=y;
this.z=z;
}
}
static class Graph{
int n ;
ArrayList<Integer>[] a;
Graph(int n)
{
this.n = n;
a = new ArrayList[n];
for(int i =0;i<n;i++)
{
a[i] = new ArrayList<>();
}
}
void BFS(Graph g,int n ,PrintWriter out)
{
}
}
public static void main(String[] args){
// TODO Auto-generated method
OutputStream outputStream = System.out;
FastReader sc = new FastReader();
PrintWriter out = new PrintWriter(outputStream);
int n = sc.nextInt();
Graph g = new Graph(n);
int m = sc.nextInt();
//Graph g = new Graph(n);
for(int i = 0;i<m;i++)
{
int x = sc.nextInt()-1;
int y = sc.nextInt()-1;
g.a[x].add(y);
g.a[y].add(x);
}
boolean[] visited = new boolean[n];
Arrays.fill(visited, false);
PriorityQueue<Integer> q = new PriorityQueue();
visited[0]=true;
q.add(0);
while(!q.isEmpty())
{
int item = q.poll();
out.print((item+1)+" ");
Iterator<Integer> i = g.a[item].iterator();
while(i.hasNext())
{
int temp = i.next();
if(visited[temp]!=true)
{
q.add(temp);
visited[temp]=true;
}
}
//out.println(q.toString());
}
/*for(int i =0;i<n;i++)
out.print(g.a[i].toString());*/
g.BFS(g,n,out);
out.close();
}
}
|
You are a coach at your local university. There are n students under your supervision, the programming skill of the i-th student is a_i.
You have to form k teams for yet another new programming competition. As you know, the more students are involved in competition the more probable the victory of your university is! So you have to form no more than k (and at least one) non-empty teams so that the total number of students in them is maximized. But you also know that each team should be balanced. It means that the programming skill of each pair of students in each team should differ by no more than 5. Teams are independent from one another (it means that the difference between programming skills of two students from two different teams does not matter).
It is possible that some students not be included in any team at all.
Your task is to report the maximum possible total number of students in no more than k (and at least one) non-empty balanced teams.
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 k (1 ≤ k ≤ n ≤ 5000) — the number of students and the maximum number of teams, correspondingly.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is a programming skill of the i-th student.
Output
Print one integer — the maximum possible total number of students in no more than k (and at least one) non-empty balanced teams.
Examples
Input
5 2
1 2 15 15 15
Output
5
Input
6 1
36 4 1 25 9 16
Output
2
Input
4 4
1 10 100 1000
Output
4
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
public class Main {
private static class ArrayEntry {
int v;
int c;
public ArrayEntry(int v, int c) {
super();
this.v = v;
this.c = c;
}
}
private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
public static void main(String[] args) throws IOException {
String s[] = br.readLine().trim().split(" ");
int n = Integer.parseInt(s[0]);
if(n == 1) {
System.out.println("1");
return;
}
int k = Integer.parseInt(s[1]);
s = br.readLine().trim().split(" ");
int a[] = new int[n];
for(int i = 0; i < n; i++) {
a[i] = Integer.parseInt(s[i]);
}
Arrays.sort(a);
ArrayList<ArrayEntry> b = new ArrayList();
for(int i = 0; i < n-1;i++) {
int j = 1;
while(i+1 < n && a[i] == a[i+1]) {
j++;i++;
}
b.add(new ArrayEntry(a[i], j));
}
if(a[n-1] != a[n-2]) b.add(new ArrayEntry(a[n-1],1));
int m = b.size();
int dp[][] = new int[m][k+1];
int ans = 0;
for(int j = 1; j <= k ; j++) {
for(int i = 0; i < m; i++) {
int c = 0, x = b.get(i).v, l = 0;
for(l = i; l >= 0; l--) {
if(x - b.get(l).v > 5) break;
c += b.get(l).c;
}
if(i > 0)
dp[i][j] = Math.max(dp[i][j], dp[i-1][j]);
if(l >= 0)
dp[i][j] = Math.max(dp[i][j], dp[l][j-1]+c);
else
dp[i][j] = Math.max(dp[i][j], c);
}
dp[m-1][j] = Math.max(dp[m-1][j], dp[m-1][j-1]);
}
System.out.println(dp[m-1][k]);
}
}
|
You are given a sequence a_1, a_2, ..., a_n consisting of n integers.
You can choose any non-negative integer D (i.e. D ≥ 0), and for each a_i you can:
* add D (only once), i. e. perform a_i := a_i + D, or
* subtract D (only once), i. e. perform a_i := a_i - D, or
* leave the value of a_i unchanged.
It is possible that after an operation the value a_i becomes negative.
Your goal is to choose such minimum non-negative integer D and perform changes in such a way, that all a_i are equal (i.e. a_1=a_2=...=a_n).
Print the required D or, if it is impossible to choose such value D, print -1.
For example, for array [2, 8] the value D=3 is minimum possible because you can obtain the array [5, 5] if you will add D to 2 and subtract D from 8. And for array [1, 4, 7, 7] the value D=3 is also minimum possible. You can add it to 1 and subtract it from 7 and obtain the array [4, 4, 4, 4].
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100) — the sequence a.
Output
Print one integer — the minimum non-negative integer value D such that if you add this value to some a_i, subtract this value from some a_i and leave some a_i without changes, all obtained values become equal.
If it is impossible to choose such value D, print -1.
Examples
Input
6
1 4 4 7 4 1
Output
3
Input
5
2 2 5 2 5
Output
3
Input
4
1 3 3 7
Output
-1
Input
2
2 8
Output
3
|
n = int(input())
L = [int(i) for i in input().split()]
F = []
mi = 101
ma = 0
for i in L:
if i not in F:
F.append(i)
if len(F) > 3:
print(-1)
else:
F.sort()
if len(F) == 3:
D = F[1] - F[0]
if F[2] - F[1] == D:
print(D)
else:
print(-1)
elif len(F) == 2:
D = F[1] - F[0]
if D % 2:
print(D)
else:
print(D // 2)
else:
print(0)
|
You are given array a_1, a_2, ..., a_n. You need to split it into k subsegments (so every element is included in exactly one subsegment).
The weight of a subsegment a_l, a_{l+1}, ..., a_r is equal to (r - l + 1) ⋅ max_{l ≤ i ≤ r}(a_i). The weight of a partition is a total weight of all its segments.
Find the partition of minimal weight.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^4, 1 ≤ k ≤ min(100, n)) — the length of the array a and the number of subsegments in the partition.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^4) — the array a.
Output
Print single integer — the minimal weight among all possible partitions.
Examples
Input
4 2
6 1 7 4
Output
25
Input
4 3
6 1 7 4
Output
21
Input
5 4
5 1 5 1 5
Output
21
Note
The optimal partition in the first example is next: 6 1 7 \bigg| 4.
The optimal partition in the second example is next: 6 \bigg| 1 \bigg| 7 4.
One of the optimal partitions in the third example is next: 5 \bigg| 1 5 \bigg| 1 \bigg| 5.
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct dreapta {
ll a, b;
ll operator()(ll x) { return a * x + b; }
};
bool useless(dreapta a, dreapta b, dreapta c) {
assert(a.a >= b.a && b.a >= c.a);
return (double)(b.b - a.b) / (a.a - b.a) > (double)(c.b - b.b) / (b.a - c.a);
}
class merging_batch {
deque<dreapta> buf;
public:
merging_batch() {}
ll query(ll x) {
ll i = 0;
for (ll step = 1 << 23; step; step /= 2)
if (i + step < buf.size() && buf[i + step](x) <= buf[i + step - 1](x))
i += step;
assert(i == buf.size() - 1 || buf[i](x) <= buf[i + 1](x));
return buf[i](x);
}
void add_right(dreapta x) {
while (buf.size() > 1 && useless(buf.rbegin()[1], buf.back(), x))
buf.pop_back();
buf.push_back(x);
}
void add_left(dreapta x) {
while (buf.size() > 1 && useless(x, buf[0], buf[1])) buf.pop_front();
buf.push_front(x);
}
void swap_with(merging_batch& rhs) { swap(buf, rhs.buf); }
void merge_with(merging_batch& rhs) {
if (buf.size() < rhs.buf.size()) {
for (auto it = buf.rbegin(); it != buf.rend(); ++it) rhs.add_left(*it);
swap(buf, rhs.buf);
} else
for (auto x : rhs.buf) add_right(x);
}
};
class undo_batch {
ll top = 0;
vector<dreapta> st = vector<dreapta>(
1000000 + 10,
dreapta{1000ll * 1000 * 1000, 1000ll * 1000 * 1000 * 1000 * 1000});
struct modification {
ll old_top, old_pos;
dreapta d;
};
vector<modification> undo_st;
public:
undo_batch() { top = 1; }
void clear() { top = 1; }
void print() {
for (int i = 1; i < top; ++i) {
cerr << "(" << st[i].a << "," << st[i].b << ") ";
}
cerr << endl;
}
ll query(ll x) {
ll i = 0;
for (ll step = 1 << 23; step; step /= 2)
if (i + step < top && st[i + step](x) <= st[i + step - 1](x)) i += step;
assert(i == top - 1 || st[i](x) <= st[i + 1](x));
return st[i](x);
}
void undo() {
assert(!undo_st.empty());
top = undo_st.back().old_top;
st[undo_st.back().old_pos] = undo_st.back().d;
undo_st.pop_back();
}
void add_right(dreapta d) {
undo_st.push_back(modification{top, 0, 0});
ll ret = 0;
for (ll step = 1 << 23; step; step /= 2)
if (ret + step < top && (!useless(st[ret + step - 1], st[ret + step], d)))
ret += step;
top = ret + 2;
undo_st.back().old_pos = ret + 1;
undo_st.back().d = st[ret + 1];
st[ret + 1] = d;
}
};
void produce_state(const ll n, const vector<ll>& d, const vector<ll>& v,
vector<ll>& ret) {
static vector<ll> posz;
static vector<merging_batch> mb;
static undo_batch ub;
posz.clear();
mb.clear();
ub.clear();
for (ll i = 0; i < n; ++i) {
merging_batch x;
x.add_right(dreapta{-i + 1, d[i]});
while (!posz.empty() && v[posz.back()] <= v[i]) {
mb.back().merge_with(x);
x.swap_with(mb.back());
mb.pop_back();
posz.pop_back();
ub.undo();
}
posz.push_back(i);
mb.push_back(move(x));
ub.add_right(dreapta{v[i], mb.back().query(v[i])});
ret[i + 1] = ub.query(i);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, k;
cin >> n >> k;
vector<ll> v(n);
for (auto& x : v) cin >> x;
vector<ll> state(n + 1, (ll)1e9 * (ll)1e9), tmp(n + 1, 0);
state[0] = 0;
tmp[0] = 0;
for (ll i = 0; i < k; ++i) {
produce_state(n, state, v, tmp);
swap(state, tmp);
}
cout << state.back() << endl;
return 0;
}
|
Today Adilbek is taking his probability theory test. Unfortunately, when Adilbek arrived at the university, there had already been a long queue of students wanting to take the same test. Adilbek has estimated that he will be able to start the test only T seconds after coming.
Fortunately, Adilbek can spend time without revising any boring theorems or formulas. He has an app on this smartphone which contains n Japanese crosswords to solve. Adilbek has decided to solve them all one by one in the order they are listed in the app, without skipping any crossword. For each crossword, a number t_i is given that represents the time it takes an average crossword expert to solve this crossword (the time is given in seconds).
Adilbek is a true crossword expert, but, unfortunately, he is sometimes unlucky in choosing the way to solve the crossword. So, it takes him either t_i seconds or t_i + 1 seconds to solve the i-th crossword, equiprobably (with probability 1/2 he solves the crossword in exactly t_i seconds, and with probability 1/2 he has to spend an additional second to finish the crossword). All these events are independent.
After T seconds pass (or after solving the last crossword, if he manages to do it in less than T seconds), Adilbek closes the app (if he finishes some crossword at the same moment, that crossword is considered solved; otherwise Adilbek does not finish solving the current crossword at all). He thinks it would be an interesting probability theory problem to calculate E — the expected number of crosswords he will be able to solve completely. Can you calculate it?
Recall that the expected value of a discrete random variable is the probability-weighted average of all possible values — in this problem it means that the expected value of the number of solved crosswords can be calculated as E = ∑ _{i = 0}^{n} i p_i, where p_i is the probability that Adilbek will solve exactly i crosswords.
We can represent E as rational fraction P/Q with Q > 0. To give the answer, you should print P ⋅ Q^{-1} mod (10^9 + 7).
Input
The first line contains two integers n and T (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ T ≤ 2 ⋅ 10^{14}) — the number of crosswords and the time Adilbek has to spend, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ 10^9), where t_i is the time it takes a crossword expert to solve the i-th crossword.
Note that Adilbek solves the crosswords in the order they are given in the input without skipping any of them.
Output
Print one integer — the expected value of the number of crosswords Adilbek solves in T seconds, expressed in the form of P ⋅ Q^{-1} mod (10^9 + 7).
Examples
Input
3 5
2 2 2
Output
750000007
Input
3 5
2 1 2
Output
125000003
Note
The answer for the first sample is equal to 14/8.
The answer for the second sample is equal to 17/8.
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 200010, Mod = 1000000007;
long long n, T, M, res, ans;
long long a[N], inv[N], fac[N];
long long Inv[N], pow_2[N];
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline long long C(long long n, long long m) {
if (n < m) return 0;
return fac[n] * inv[m] % Mod * inv[n - m] % Mod;
}
inline long long Power(long long base, long long power) {
long long result = 1;
while (power > 0) {
if (power & 1) result = result * base % Mod;
power >>= 1;
base = (base * base) % Mod;
}
return result;
}
inline void Pre() {
fac[0] = inv[0] = pow_2[0] = Inv[0] = 1;
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = 1; i <= n; i++) a[i] += a[i - 1];
for (long long i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % Mod;
for (long long i = 1; i <= n; i++) inv[i] = Power(fac[i], Mod - 2);
for (long long i = 1; i <= n; i++) {
pow_2[i] = pow_2[i - 1] * 2 % Mod;
Inv[i] = Power(pow_2[i], Mod - 2);
}
}
signed main() {
n = read(), T = read();
Pre();
M = n, res = 1;
for (long long i = 1; i <= n; i++) {
long long s = min(n, T - a[i]);
if (s < 0) continue;
res = ((2 * res - C(i - 1, M)) % Mod + Mod) % Mod;
while (M > s) {
res = ((res - C(i, M)) % Mod + Mod) % Mod;
M--;
}
ans = (ans + res * Inv[i] % Mod) % Mod;
}
printf("%lld\n", ans % Mod);
return 0;
}
|
The only difference between easy and hard versions are constraints on n and k.
You are messaging in one of the popular social networks via your smartphone. Your smartphone can show at most k most recent conversations with your friends. Initially, the screen is empty (i.e. the number of displayed conversations equals 0).
Each conversation is between you and some of your friends. There is at most one conversation with any of your friends. So each conversation is uniquely defined by your friend.
You (suddenly!) have the ability to see the future. You know that during the day you will receive n messages, the i-th message will be received from the friend with ID id_i (1 ≤ id_i ≤ 10^9).
If you receive a message from id_i in the conversation which is currently displayed on the smartphone then nothing happens: the conversations of the screen do not change and do not change their order, you read the message and continue waiting for new messages.
Otherwise (i.e. if there is no conversation with id_i on the screen):
* Firstly, if the number of conversations displayed on the screen is k, the last conversation (which has the position k) is removed from the screen.
* Now the number of conversations on the screen is guaranteed to be less than k and the conversation with the friend id_i is not displayed on the screen.
* The conversation with the friend id_i appears on the first (the topmost) position on the screen and all the other displayed conversations are shifted one position down.
Your task is to find the list of conversations (in the order they are displayed on the screen) after processing all n messages.
Input
The first line of the input contains two integers n and k (1 ≤ n, k ≤ 200) — the number of messages and the number of conversations your smartphone can show.
The second line of the input contains n integers id_1, id_2, ..., id_n (1 ≤ id_i ≤ 10^9), where id_i is the ID of the friend which sends you the i-th message.
Output
In the first line of the output print one integer m (1 ≤ m ≤ min(n, k)) — the number of conversations shown after receiving all n messages.
In the second line print m integers ids_1, ids_2, ..., ids_m, where ids_i should be equal to the ID of the friend corresponding to the conversation displayed on the position i after receiving all n messages.
Examples
Input
7 2
1 2 3 2 1 3 2
Output
2
2 1
Input
10 4
2 3 3 1 1 2 1 2 3 3
Output
3
1 3 2
Note
In the first example the list of conversations will change in the following way (in order from the first to last message):
* [];
* [1];
* [2, 1];
* [3, 2];
* [3, 2];
* [1, 3];
* [1, 3];
* [2, 1].
In the second example the list of conversations will change in the following way:
* [];
* [2];
* [3, 2];
* [3, 2];
* [1, 3, 2];
* and then the list will not change till the end.
|
def line():
return map(int, input().split())
def num():
return int(input())
from collections import OrderedDict as od
n,k = line()
ids = list(line())
screen = od()
for id in ids:
if id not in screen:
if len(screen)==k:
screen.popitem(last=False)
screen[id]=None
print(len(screen))
print(' '.join(map(str, reversed(screen))))
|
There are four stones on an infinite line in integer coordinates a_1, a_2, a_3, a_4. The goal is to have the stones in coordinates b_1, b_2, b_3, b_4. The order of the stones does not matter, that is, a stone from any position a_i can end up in at any position b_j, provided there is a required number of stones in each position (that is, if a coordinate x appears k times among numbers b_1, …, b_4, there should be exactly k stones at x in the end).
We are allowed to move stones with the following operation: choose two stones at distinct positions x and y with at least one stone each, and move one stone from x to 2y - x. In other words, the operation moves a stone to a symmetric position relative to some other stone. At any moment it is allowed to have any number of stones at the same position.
Find any sequence of operations that achieves the goal, or determine that it is impossible. The sequence does not have to be shortest, but it may contain at most 1000 operations.
Input
The first line contains four integers a_1, …, a_4 (-10^9 ≤ a_i ≤ 10^9) — initial coordinates of the stones. There may be multiple stones sharing the same coordinate.
The second line contains four integers b_1, …, b_4 (-10^9 ≤ b_i ≤ 10^9) — target coordinates of the stones. There may be multiple targets sharing the same coordinate.
Output
If there is no sequence of operations that achieves the goal, print a single integer -1. Otherwise, on the first line print a single integer k (0 ≤ k ≤ 1000) — the number of operations in your sequence. On the next k lines, describe the operations. The i-th of these lines should contain two integers x_i and y_i (x_i ≠ y_i) — coordinates of the moved stone and the center of symmetry stone for the i-th operation.
For each operation i, there should at least one stone in each of the coordinates x_i and y_i, and the resulting coordinate 2y_i - x_i must not exceed 10^{18} by absolute value.
If there are multiple suitable sequences, print any of them. It is guaranteed that if there is a suitable sequence of operations, then there is also a suitable sequence that satisfies all the additional requirement.
Examples
Input
0 1 2 3
3 5 6 8
Output
3
1 3
2 5
0 3
Input
0 0 0 0
1 1 1 1
Output
-1
Input
0 0 0 1
0 1 0 1
Output
-1
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > v1, v2, v3;
long long a[5], b[5], d;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
void op(long long *a, vector<pair<long long, long long> > &mov, long long p1,
long long p2) {
mov.push_back(make_pair(a[p1], a[p2]));
a[p1] = a[p2] * 2 - a[p1];
}
void solve(long long *a, vector<pair<long long, long long> > &mov) {
while (true) {
sort(a + 1, a + 5);
if (a[1] + 1 == a[4]) break;
while (min(a[2] - a[1], a[4] - a[2]) * 4 < a[4] - a[1] &&
min(a[3] - a[1], a[4] - a[3]) * 4 < a[4] - a[1]) {
long long p, q, q1, q2;
if (min(a[2] - a[1], a[4] - a[2]) < min(a[3] - a[1], a[4] - a[3]))
p = 2, q = 3;
else
p = 3, q = 2;
if (a[q] - a[1] < a[4] - a[q])
q1 = 1, q2 = q;
else
q1 = q, q2 = 4;
if (a[p] - a[1] < a[4] - a[p])
op(a, mov, p, q1), op(a, mov, p, q2);
else
op(a, mov, p, q2), op(a, mov, p, q1);
}
sort(a + 1, a + 5);
if (min(a[2] - a[1], a[4] - a[2]) * 4 >= a[4] - a[1]) {
if (a[2] - a[1] < a[4] - a[2])
op(a, mov, 1, 2);
else
op(a, mov, 3, 2), op(a, mov, 4, 2);
} else {
if (a[3] - a[1] < a[4] - a[3])
op(a, mov, 1, 3), op(a, mov, 2, 3);
else
op(a, mov, 4, 3);
}
}
sort(a + 1, a + 5);
if (a[1] & 1)
for (long long i = 1; i <= 3; i++)
if (a[i] < a[4]) op(a, mov, i, 4);
sort(a + 1, a + 5);
}
void shift() {
sort(a + 1, a + 5);
if ((a[4] - a[1]) * 3 < abs(d)) {
op(a, v3, 3, 1);
op(a, v3, 2, 4);
shift();
sort(a + 1, a + 5);
op(a, v3, 1, 2);
op(a, v3, 4, 3);
}
sort(a + 1, a + 5);
while (a[4] - a[1] <= abs(d)) {
if (d > 0) {
d -= a[4] - a[1];
op(a, v3, 2, 1);
op(a, v3, 2, 4);
op(a, v3, 3, 1);
op(a, v3, 3, 4);
op(a, v3, 1, 4);
op(a, v3, 4, 1);
} else {
d += a[4] - a[1];
op(a, v3, 2, 4);
op(a, v3, 2, 1);
op(a, v3, 3, 4);
op(a, v3, 3, 1);
op(a, v3, 4, 1);
op(a, v3, 1, 4);
}
sort(a + 1, a + 5);
}
}
void purify(vector<pair<long long, long long> > &vec) {
vector<pair<long long, long long> > tmp;
for (pair<long long, long long> p : vec)
if (p.first != p.second) tmp.push_back(p);
vec = tmp;
}
signed main() {
for (long long i = 1; i <= 4; i++) cin >> a[i];
sort(a + 1, a + 5);
for (long long i = 1; i <= 4; i++) cin >> b[i];
sort(b + 1, b + 5);
long long g = gcd(gcd(a[2] - a[1], a[3] - a[1]), a[4] - a[1]);
if (gcd(gcd(b[2] - b[1], b[3] - b[1]), b[4] - b[1]) != g) {
cout << -1;
return 0;
}
bool e1 = a[1] == a[2] && a[2] == a[3] && a[3] == a[4],
e2 = b[1] == b[2] && b[2] == b[3] && b[3] == b[4];
if (e1 && e2) {
if (a[1] != b[1])
cout << -1;
else
cout << 0;
return 0;
}
if (e1 || e2) {
cout << -1;
return 0;
}
if ((a[1] % g + g) % g != (b[1] % g + g) % g) {
cout << -1;
return 0;
}
long long delta = (a[1] % g + g) % g;
for (long long i = 1; i <= 4; i++)
a[i] = (a[i] - delta) / g, b[i] = (b[i] - delta) / g;
long long c1[2] = {0}, c2[2] = {0};
for (long long i = 1; i <= 4; i++) c1[abs(a[i]) & 1]++, c2[abs(b[i]) & 1]++;
if (c1[0] != c2[0] || c1[1] != c2[1]) {
cout << -1;
return 0;
}
solve(a, v1);
solve(b, v2);
d = (b[1] - a[1]) / 2;
shift();
purify(v1);
purify(v2);
purify(v3);
cout << v1.size() + v2.size() + v3.size() << '\n';
for (pair<long long, long long> p : v1)
cout << p.first * g + delta << ' ' << p.second * g + delta << '\n';
for (pair<long long, long long> p : v3)
cout << p.first * g + delta << ' ' << p.second * g + delta << '\n';
long long siz = v2.size();
for (long long i = siz - 1; i >= 0; i--)
cout << (2 * v2[i].second - v2[i].first) * g + delta << ' '
<< v2[i].second * g + delta << '\n';
return 0;
}
|
This is a hard version of the problem. The actual problems are different, but the easy version is almost a subtask of the hard version. Note that the constraints and the output format are different.
You are given a string s consisting of n lowercase Latin letters.
You have to color all its characters the minimum number of colors (each character to exactly one color, the same letters can be colored the same or different colors, i.e. you can choose exactly one color for each index in s).
After coloring, you can swap any two neighboring characters of the string that are colored different colors. You can perform such an operation arbitrary (possibly, zero) number of times.
The goal is to make the string sorted, i.e. all characters should be in alphabetical order.
Your task is to find the minimum number of colors which you have to color the given string in so that after coloring it can become sorted by some sequence of swaps. Note that you have to restore only coloring, not the sequence of swaps.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of s.
The second line of the input contains the string s consisting of exactly n lowercase Latin letters.
Output
In the first line print one integer res (1 ≤ res ≤ n) — the minimum number of colors in which you have to color the given string so that after coloring it can become sorted by some sequence of swaps.
In the second line print any possible coloring that can be used to sort the string using some sequence of swaps described in the problem statement. The coloring is the array c of length n, where 1 ≤ c_i ≤ res and c_i means the color of the i-th character.
Examples
Input
9
abacbecfd
Output
2
1 1 2 1 2 1 2 1 2
Input
8
aaabbcbb
Output
2
1 2 1 2 1 2 1 1
Input
7
abcdedc
Output
3
1 1 1 1 1 2 3
Input
5
abcde
Output
1
1 1 1 1 1
|
// Working program using Reader Class
import java.io.*;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.*;
public class Main
{
static class Reader
{
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Reader()
{
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Reader(String file_name) throws IOException
{
din = new DataInputStream(new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException
{
byte[] buf = new byte[64]; // line length
int cnt = 0, c;
while ((c = read()) != -1)
{
if (c == '\n')
break;
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
public int nextInt() throws IOException
{
int ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do
{
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public long nextLong() throws IOException
{
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public double nextDouble() throws IOException
{
double ret = 0, div = 1;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (c == '.')
{
while ((c = read()) >= '0' && c <= '9')
{
ret += (c - '0') / (div *= 10);
}
}
if (neg)
return -ret;
return ret;
}
private void fillBuffer() throws IOException
{
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}
private byte read() throws IOException
{
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}
public void close() throws IOException
{
if (din == null)
return;
din.close();
}
}
public static int gcd(int a, int b)
{
// Everything divides 0
if (a == 0 || b == 0)
return 0;
// base case
if (a == b)
return a;
// a is greater
if (a > b)
return gcd(a-b, b);
return gcd(a, b-a);
}
public static void main(String[] args) throws IOException
{
//Reader scan=new Reader();
Scanner scan=new Scanner(System.in);
PrintWriter out=new PrintWriter(System.out);
int n=scan.nextInt();
String s=scan.next();
int[] maxValue=new int[26];
int[] ans=new int[n];
int max=1;
for(int i=0;i<n;i++) {
char c=s.charAt(i);
int value=Math.max(maxValue[c-'a'], 1);
for(int j=c-'a'+1;j<26;j++) {
value=Math.max(value, maxValue[j]+1);
}
ans[i]=value;
maxValue[c-'a']=value;
max=Math.max(max, value);
}
out.println(max);
for(int i : ans) {
out.print(i+" ");
}
out.close();
}
}
|
How many stars are there in the sky? A young programmer Polycarpus can't get this question out of his head! He took a photo of the starry sky using his digital camera and now he analyzes the resulting monochrome digital picture. The picture is represented by a rectangular matrix consisting of n lines each containing m characters. A character equals '1', if the corresponding photo pixel is white and '0', if it is black.
Polycarpus thinks that he has found a star on the photo if he finds a white pixel surrounded by four side-neighboring pixels that are also white:
1
111
1
a star on the photo
Polycarpus whats to cut out a rectangular area from the photo and give his mom as a present. This area should contain no less than k stars. The stars can intersect, have shared white pixels on the photo. The boy will cut out the rectangular area so that its borders will be parallel to the sides of the photo and the cuts will go straight between the pixel borders.
Now Polycarpus keeps wondering how many ways there are to cut an area out of the photo so that it met the conditions given above. Help Polycarpus find this number.
Input
The first line of the input data contains three integers n, m and k (1 ≤ n, m ≤ 500;1 ≤ k ≤ nm). Then follow n lines, containing the description of the given photo as a sequence of lines. Each line contains m characters '0' or '1'.
Output
Print the required number of areas on the given photo.
Examples
Input
4 6 2
111000
111100
011011
000111
Output
6
Input
5 5 4
11111
11111
11111
11111
11111
Output
9
Note
We'll number the rows and columns below starting from 1, the coordinates (p, q) will denote a cell in row p, column q.
In the first sample Polycarpus should cut out any area containing a rectangle whose opposite corners lie in cells (1, 1) and (3, 4). Only rectangles with opposite corners in (1, 1) and (x, y), where x ≥ 3 and y ≥ 4 fit the conditions.
In the second sample any rectangle whose each side is no less than four, will do. The possible rectangle sizes are 4 × 4, 4 × 5, 5 × 4 and 5 × 5. Such figures can be cut in 4 ways, 2 ways, 2 ways and 1 way correspondingly.
Please do not use the %lld specificator to read or write 64-bit integers in C++. It is preferred to use cin, cout streams or the %I64d specificator.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 510;
char data[N][N];
int n, m, k;
bool a[N][N];
int s[N][N];
int go[5][2] = {0, 0, -1, 0, 0, 1, 1, 0, 0, -1};
bool judge(int x, int y) {
for (int i = 0; i < 5; i++)
if (data[x + go[i][0]][y + go[i][1]] != '1') return 0;
return 1;
}
long long cal(int x1, int y1, int x2, int y2) {
return s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1];
}
int main() {
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
memset(a, 0, sizeof(a));
memset(s, 0, sizeof(s));
int i, j, p;
for (i = 1; i <= n; i++) scanf("%s", data[i] + 1);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
a[i][j] = judge(i, j);
s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i][j];
}
long long ans = 0;
for (i = 1; i <= n; i++) {
for (j = i + 2; j <= n; j++) {
if (cal(i + 1, 2, j - 1, m - 1) < k) continue;
long long l = 1;
for (p = 3; p <= m; p++) {
while (l <= p && cal(i + 1, l + 2, j - 1, p - 1) >= k) l++;
if (cal(i + 1, l + 1, j - 1, p - 1) >= k) ans += l;
}
}
}
printf("%I64d\n", ans);
}
}
|
You have an array a of length n. For every positive integer x you are going to perform the following operation during the x-th second:
* Select some distinct indices i_{1}, i_{2}, …, i_{k} which are between 1 and n inclusive, and add 2^{x-1} to each corresponding position of a. Formally, a_{i_{j}} := a_{i_{j}} + 2^{x-1} for j = 1, 2, …, k. Note that you are allowed to not select any indices at all.
You have to make a nondecreasing as fast as possible. Find the smallest number T such that you can make the array nondecreasing after at most T seconds.
Array a is nondecreasing if and only if a_{1} ≤ a_{2} ≤ … ≤ a_{n}.
You have to answer t independent test cases.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^{4}) — the number of test cases.
The first line of each test case contains single integer n (1 ≤ n ≤ 10^{5}) — the length of array a. It is guaranteed that the sum of values of n over all test cases in the input does not exceed 10^{5}.
The second line of each test case contains n integers a_{1}, a_{2}, …, a_{n} (-10^{9} ≤ a_{i} ≤ 10^{9}).
Output
For each test case, print the minimum number of seconds in which you can make a nondecreasing.
Example
Input
3
4
1 7 6 5
5
1 2 3 4 5
2
0 -4
Output
2
0
3
Note
In the first test case, if you select indices 3, 4 at the 1-st second and 4 at the 2-nd second, then a will become [1, 7, 7, 8]. There are some other possible ways to make a nondecreasing in 2 seconds, but you can't do it faster.
In the second test case, a is already nondecreasing, so answer is 0.
In the third test case, if you do nothing at first 2 seconds and select index 2 at the 3-rd second, a will become [0, 0].
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<long long> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];
long long maxi = arr[n - 1], mini = arr[n - 1];
int x = 0;
for (int i = n - 2; i >= 0; i--) {
x = max((long long)x,
(long long)ceil(log((double)(arr[i] - mini + 1)) / log(2.0)));
mini = min(mini, arr[i]);
}
cout << x << endl;
}
}
|
You are given four positive integers n, m, a, b (1 ≤ b ≤ n ≤ 50; 1 ≤ a ≤ m ≤ 50). Find any such rectangular matrix of size n × m that satisfies all of the following conditions:
* each row of the matrix contains exactly a ones;
* each column of the matrix contains exactly b ones;
* all other elements are zeros.
If the desired matrix does not exist, indicate this.
For example, for n=3, m=6, a=2, b=1, there exists a matrix satisfying the conditions above:
$$$ \begin{vmatrix} 0 & 1 & 0 & 0 & 0 & 1 \\\ 1 & 0 & 0 & 1 & 0 & 0 \\\ 0 & 0 & 1 & 0 & 1 & 0 \end{vmatrix} $$$
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
Each test case is described by four positive integers n, m, a, b (1 ≤ b ≤ n ≤ 50; 1 ≤ a ≤ m ≤ 50), where n and m are the sizes of the matrix, and a and b are the number of ones for rows and columns, respectively.
Output
For each test case print:
* "YES" (without quotes) and the required matrix (if there are several answers, print any) if it exists, or
* "NO" (without quotes) if it does not exist.
To print the matrix n × m, print n rows, each of which consists of m numbers 0 or 1 describing a row of the matrix. Numbers must be printed without spaces.
Example
Input
5
3 6 2 1
2 2 2 1
2 2 2 2
4 4 2 2
2 1 1 2
Output
YES
010001
100100
001010
NO
YES
11
11
YES
1100
1100
0011
0011
YES
1
1
|
for q in range(int(input())):
n, m, a, b = map(int, input().split())
if n*a != m*b:
print('NO')
continue
print('YES')
t = '1'*a+'0'*(m-a)
for i in range(n):
print(t)
t = t[m-a:]+t[:m-a]
|
This is the easy version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 3n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 1000) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 1000.
Output
For each test case, output an integer k (0≤ k≤ 3n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
|
#include <bits/stdc++.h>
using namespace std;
string a, b;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cin >> a;
cin >> b;
int k = 0;
for (int i = 0; i < n; i++)
if (a[i] != b[i]) k++;
k *= 3;
cout << k;
for (int i = 0; i < n; i++)
if (a[i] != b[i]) cout << " " << i + 1 << " 1 " << i + 1;
cout << "\n";
}
return 0;
}
|
We have a point A with coordinate x = n on OX-axis. We'd like to find an integer point B (also on OX-axis), such that the absolute difference between the distance from O to B and the distance from A to B is equal to k.
<image> The description of the first test case.
Since sometimes it's impossible to find such point B, we can, in one step, increase or decrease the coordinate of A by 1. What is the minimum number of steps we should do to make such point B exist?
Input
The first line contains one integer t (1 ≤ t ≤ 6000) — the number of test cases.
The only line of each test case contains two integers n and k (0 ≤ n, k ≤ 10^6) — the initial position of point A and desirable absolute difference.
Output
For each test case, print the minimum number of steps to make point B exist.
Example
Input
6
4 0
5 8
0 1000000
0 0
1 0
1000000 1000000
Output
0
3
1000000
0
1
0
Note
In the first test case (picture above), if we set the coordinate of B as 2 then the absolute difference will be equal to |(2 - 0) - (4 - 2)| = 0 and we don't have to move A. So the answer is 0.
In the second test case, we can increase the coordinate of A by 3 and set the coordinate of B as 0 or 8. The absolute difference will be equal to |8 - 0| = 8, so the answer is 3.
<image>
|
for _ in range(int(input())):
n, k = map(int, input().split())
if n<k:print(k-n)
elif n%2 == k%2: print(0)
else: print(1)
|
John has Q closed intervals of consecutive 2K-bit numbers [l_i, r_i] and one 16-bit value v_i for each interval. (0 ≤ i < Q)
John wants to implement a function F that maps 2K-bit numbers to 16-bit numbers in such a way that inputs from each interval are mapped to that interval's value. In other words: $$$F(x) = v_i, \; for every 0 ≤ i < Q \; , and every x ∈ [l_i, r_i]$$$ The output of F for other inputs is unimportant.
John wants to make his implementation of F fast so he has decided to use lookup tables. A single 2K-bit lookup table would be too large to fit in memory, so instead John plans to use two K-bit lookup tables, LSBTable and MSBTable. His implementation will look like this: $$$ F(x) = LSBTable[lowKBits(x)] \; \& \; MSBTable[highKBits(x)]$$$ In other words it returns the "bitwise and" of results of looking up the K least significant bits in LSBTable and the K most significant bits in MSBTable.
John needs your help. Given K, Q and Q intervals [l_i, r_i] and values v_i, find any two lookup tables which can implement F or report that such tables don't exist.
Input
The first line contains two integers K and Q ( 1 <= K <= 16, 1 <= Q <= 2⋅ 10^5).
Each of the next Q lines contains three integers l_i, r_i and v_i. ( 0 ≤ l_i ≤ r_i < 2^{2K}, 0 ≤ v_i < 2^{16}).
Output
On the first line output "possible" (without quotes) if two tables satisfying the conditions exist, or "impossible" (without quotes) if they don't exist.
If a solution exists, in the next 2 ⋅ 2^K lines your program should output all values of the two lookup tables (LSBTable and MSBTable) it found. When there are multiple pairs of tables satisfying the conditions, your program may output any such pair.
On lines 1 + i output LSBTable[i]. (0 ≤ i < 2^K, 0 ≤ LSBTable[i] < 2^{16}).
On lines 1 + 2^K + i output MSBTable[i]. (0 ≤ i < 2^K, 0 ≤ MSBTable[i] < 2^{16}).
Examples
Input
1 2
0 2 1
3 3 3
Output
possible
1
3
1
3
Input
2 4
4 5 3
6 7 2
0 3 0
12 13 1
Output
possible
3
3
2
2
0
3
0
1
Input
2 3
4 4 3
5 6 2
12 14 1
Output
impossible
Note
A closed interval [a, b] includes both a and b.
In the first sample, tables LSBTable = [1,3] and MSBTable = [1,3] satisfy the conditions: F[0] = LSBTable[0] \& MSBTable[0] = 1 \& 1 = 1, F[1] = LSBTable[1] \& MSBTable[0] = 3 \& 1 = 1, F[2] = LSBTable[0] \& MSBTable[1] = 1 \& 3 = 1, F[3] = LSBTable[1] \& MSBTable[1] = 3 \& 3 = 3.
In the second sample, tables LSBTable = [3,3,2,2] and MSBTable = [0,3,0,1] satisfy all the conditions.
In the third sample there are no two lookup tables which can satisfy the conditions.
|
#include <bits/stdc++.h>
using namespace std;
class segtree {
public:
struct node {
int val = 0;
int put = 0;
void apply(int l, int r, int v) {
val |= v;
put |= v;
}
};
node unite(const node &a, const node &b) const {
node res;
res.val = a.val | b.val;
return res;
}
inline void push(int x, int l, int r) {
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
if (tree[x].put != 0) {
tree[x + 1].apply(l, y, tree[x].put);
tree[z].apply(y + 1, r, tree[x].put);
tree[x].put = 0;
}
}
inline void pull(int x, int z) { tree[x] = unite(tree[x + 1], tree[z]); }
int n;
vector<node> tree;
void build(int x, int l, int r) {
if (l == r) {
return;
}
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
build(x + 1, l, y);
build(z, y + 1, r);
pull(x, z);
}
template <typename M>
void build(int x, int l, int r, const vector<M> &v) {
if (l == r) {
tree[x].apply(l, r, v[l]);
return;
}
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
build(x + 1, l, y, v);
build(z, y + 1, r, v);
pull(x, z);
}
node get(int x, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) {
return tree[x];
}
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
push(x, l, r);
node res{};
if (rr <= y) {
res = get(x + 1, l, y, ll, rr);
} else {
if (ll > y) {
res = get(z, y + 1, r, ll, rr);
} else {
res = unite(get(x + 1, l, y, ll, rr), get(z, y + 1, r, ll, rr));
}
}
pull(x, z);
return res;
}
template <typename... M>
void modify(int x, int l, int r, int ll, int rr, const M &...v) {
if (ll <= l && r <= rr) {
tree[x].apply(l, r, v...);
return;
}
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
push(x, l, r);
if (ll <= y) {
modify(x + 1, l, y, ll, rr, v...);
}
if (rr > y) {
modify(z, y + 1, r, ll, rr, v...);
}
pull(x, z);
}
int find_first_knowingly(int x, int l, int r,
const function<bool(const node &)> &f) {
if (l == r) {
return l;
}
push(x, l, r);
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
int res;
if (f(tree[x + 1])) {
res = find_first_knowingly(x + 1, l, y, f);
} else {
res = find_first_knowingly(z, y + 1, r, f);
}
pull(x, z);
return res;
}
int find_first(int x, int l, int r, int ll, int rr,
const function<bool(const node &)> &f) {
if (ll <= l && r <= rr) {
if (!f(tree[x])) {
return -1;
}
return find_first_knowingly(x, l, r, f);
}
push(x, l, r);
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
int res = -1;
if (ll <= y) {
res = find_first(x + 1, l, y, ll, rr, f);
}
if (rr > y && res == -1) {
res = find_first(z, y + 1, r, ll, rr, f);
}
pull(x, z);
return res;
}
int find_last_knowingly(int x, int l, int r,
const function<bool(const node &)> &f) {
if (l == r) {
return l;
}
push(x, l, r);
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
int res;
if (f(tree[z])) {
res = find_last_knowingly(z, y + 1, r, f);
} else {
res = find_last_knowingly(x + 1, l, y, f);
}
pull(x, z);
return res;
}
int find_last(int x, int l, int r, int ll, int rr,
const function<bool(const node &)> &f) {
if (ll <= l && r <= rr) {
if (!f(tree[x])) {
return -1;
}
return find_last_knowingly(x, l, r, f);
}
push(x, l, r);
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
int res = -1;
if (rr > y) {
res = find_last(z, y + 1, r, ll, rr, f);
}
if (ll <= y && res == -1) {
res = find_last(x + 1, l, y, ll, rr, f);
}
pull(x, z);
return res;
}
segtree(int _n) : n(_n) {
assert(n > 0);
tree.resize(2 * n - 1);
build(0, 0, n - 1);
}
template <typename M>
segtree(const vector<M> &v) {
n = v.size();
assert(n > 0);
tree.resize(2 * n - 1);
build(0, 0, n - 1, v);
}
node get(int ll, int rr) {
assert(0 <= ll && ll <= rr && rr <= n - 1);
return get(0, 0, n - 1, ll, rr);
}
node get(int p) {
assert(0 <= p && p <= n - 1);
return get(0, 0, n - 1, p, p);
}
template <typename... M>
void modify(int ll, int rr, const M &...v) {
assert(0 <= ll && ll <= rr && rr <= n - 1);
modify(0, 0, n - 1, ll, rr, v...);
}
int find_first(int ll, int rr, const function<bool(const node &)> &f) {
assert(0 <= ll && ll <= rr && rr <= n - 1);
return find_first(0, 0, n - 1, ll, rr, f);
}
int find_last(int ll, int rr, const function<bool(const node &)> &f) {
assert(0 <= ll && ll <= rr && rr <= n - 1);
return find_last(0, 0, n - 1, ll, rr, f);
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int k, q;
cin >> k >> q;
vector<long long> l(q);
vector<long long> r(q);
vector<int> v(q);
for (int i = 0; i < q; i++) {
cin >> l[i] >> r[i] >> v[i];
}
segtree msb(1 << k);
segtree lsb(1 << k);
for (int i = 0; i < q; i++) {
{
int from = l[i] >> k;
int to = r[i] >> k;
msb.modify(from, to, v[i]);
}
{
if (r[i] - l[i] + 1 >= (1 << k)) {
lsb.modify(0, (1 << k) - 1, v[i]);
} else {
int from = l[i] & ((1 << k) - 1);
int to = r[i] & ((1 << k) - 1);
if (from <= to) {
lsb.modify(from, to, v[i]);
} else {
lsb.modify(from, (1 << k) - 1, v[i]);
lsb.modify(0, to, v[i]);
}
}
}
}
for (int i = 0; i < q; i++) {
long long x = l[i];
long long y = r[i];
while (x <= y) {
if ((x & ((1 << k) - 1)) == 0 && y - x + 1 >= (1 << k)) {
int full = (y - x + 1) >> k;
int a = msb.get(x >> k, (x >> k) + full - 1).val;
int b = lsb.get(0, (1 << k) - 1).val;
if ((a & b) != v[i]) {
cout << "impossible" << '\n';
return 0;
}
x += ((long long)full) << k;
continue;
}
long long z = min(y, x | ((1 << k) - 1));
int a = msb.get(x >> k, x >> k).val;
int b = lsb.get(x & ((1 << k) - 1), z & ((1 << k) - 1)).val;
if ((a & b) != v[i]) {
cout << "impossible" << '\n';
return 0;
}
x = z + 1;
}
}
cout << "possible" << '\n';
for (int i = 0; i < (1 << k); i++) {
cout << lsb.get(i, i).val << '\n';
}
for (int i = 0; i < (1 << k); i++) {
cout << msb.get(i, i).val << '\n';
}
return 0;
}
|
You are given an array a of length 2n. Consider a partition of array a into two subsequences p and q of length n each (each element of array a should be in exactly one subsequence: either in p or in q).
Let's sort p in non-decreasing order, and q in non-increasing order, we can denote the sorted versions by x and y, respectively. Then the cost of a partition is defined as f(p, q) = ∑_{i = 1}^n |x_i - y_i|.
Find the sum of f(p, q) over all correct partitions of array a. Since the answer might be too big, print its remainder modulo 998244353.
Input
The first line contains a single integer n (1 ≤ n ≤ 150 000).
The second line contains 2n integers a_1, a_2, …, a_{2n} (1 ≤ a_i ≤ 10^9) — elements of array a.
Output
Print one integer — the answer to the problem, modulo 998244353.
Examples
Input
1
1 4
Output
6
Input
2
2 1 2 1
Output
12
Input
3
2 2 2 2 2 2
Output
0
Input
5
13 8 35 94 9284 34 54 69 123 846
Output
2588544
Note
Two partitions of an array are considered different if the sets of indices of elements included in the subsequence p are different.
In the first example, there are two correct partitions of the array a:
1. p = [1], q = [4], then x = [1], y = [4], f(p, q) = |1 - 4| = 3;
2. p = [4], q = [1], then x = [4], y = [1], f(p, q) = |4 - 1| = 3.
In the second example, there are six valid partitions of the array a:
1. p = [2, 1], q = [2, 1] (elements with indices 1 and 2 in the original array are selected in the subsequence p);
2. p = [2, 2], q = [1, 1];
3. p = [2, 1], q = [1, 2] (elements with indices 1 and 4 are selected in the subsequence p);
4. p = [1, 2], q = [2, 1];
5. p = [1, 1], q = [2, 2];
6. p = [2, 1], q = [2, 1] (elements with indices 3 and 4 are selected in the subsequence p).
|
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
public class COVID {
static long mod = 998244353 ;
static PrintWriter pw;
static int n,m;
static ArrayList<Integer>[] adjList;
static int INF=(int)1e8;
static double EPS=1e-6;
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
PrintWriter pw = new PrintWriter(System.out);
int n=sc.nextInt();
int arr[]=sc.nextIntArr(2*n);
shuffle(arr);
Arrays.sort(arr);
long sum=0;
for(int i=0;i<n;i++)
sum+=arr[2*n-1-i]-arr[i];
long c=1;for(int i=1;i<=n;i++)c=mul(c, i);
c=c*c%mod;
c=powmod(c,mod-2,(int)mod);
for(int i=1;i<=2*n;i++)c=mul(c, i);
pw.println(mul(c, sum));
pw.flush();
}
public static long getAns(long p , long q) {
long ans=0;
for(long i=1;i*i<=p;i++) {
if(p%i==0) {
long div=p/i;
if(div%q!=0) {
return div;
}else {
if(i%q!=0) {
ans=Math.max(ans, i);
}
}
}
}
return ans;
}
static boolean[] isPrime;
static ArrayList<Integer> primes;
public static void sieve(int N) {// O( n log( log n ) )
isPrime= new boolean[N+1];//u can save half the memory by neglecting all even numbers since they aren't primes
primes= new ArrayList<>(N);
Arrays.fill(isPrime, true);
isPrime[0]=isPrime[1]=false;
for(int i=2;i*i<=N;i++) {
if(isPrime[i]) {
for(int j=i*i;j<=N;j+=i) {
isPrime[j]=false;
}
}
}
for(int i=2;i<=N;i++) {
if(isPrime[i])primes.add(i);
}
}
public static class Segment{
Point a,b;
int id;
public Segment(Point s,Point e,int id) {
a=s;b=e;
this.id=id;
}
public double getY(int x) {
return b.y+(x-b.x)*1.0*(a.y-b.y)/(a.x-b.x);
}
public String toString() {
return a.x+" "+a.y+" "+b.x+" "+b.y;
}
}
public static class Point{
int x,y;
public Point(int a,int b) {
x=a;y=b;
}
}
static int pow(int b, long e) {
int ans = 1;
while (e > 0) {
if ((e & 1) == 1)
ans = (int) ((ans * 1l * b));
e >>= 1;
{
}
b = (int) ((b * 1l * b));
}
return ans;
}
static long powmod(long b, long e, int mod) {
long ans = 1;
b %= mod;
while (e > 0) {
if ((e & 1) == 1)
ans = (int) ((ans * 1l * b) % mod);
e >>= 1;
b = (int) ((b * 1l * b) % mod);
}
return ans;
}
public static long add(long a, long b) {
return (a + b) % mod;
}
public static long sub(long a, long b) {
return (a - b + mod) % mod;
}
public static long mul(long a, long b) {
return ((a % mod) * (b % mod)) % mod;
}
static class longPair implements Comparable<longPair> {
long x, y;
public longPair(long a, long b) {
x = a;
y = b;
}
public int compareTo(longPair p) {
return (p.x == x) ? ((p.y == y) ? 0 : (y > p.y) ? 1 : -1) : (x > p.x) ? 1 : -1;
}
}
static class Pair implements Comparable<Pair> {
int x;
int y;
public Pair(int a, int b) {
this.x = a;
y = b;
}
public int compareTo(Pair o) {
return (x == o.x) ? ((y > o.y) ? 1 : (y == o.y) ? 0 : -1) : ((x > o.x) ? 1 : -1);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + x;
result = prime * result + y;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Pair other = (Pair) obj;
if (x != other.x)
return false;
if (y != other.y)
return false;
return true;
}
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public Scanner(String s) throws FileNotFoundException {
br = new BufferedReader(new FileReader(s));
}
public long[] nextLongArr(int n) throws IOException {
long[] arr = new long[n];
for (int i = 0; i < n; i++)
arr[i] = nextLong();
return arr;
}
public int[] nextIntArr(int n) throws IOException {
int[] arr = new int[n];
for (int i = 0; i < n; i++)
arr[i] = nextInt();
return arr;
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine(), " ,");
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
public double nextDouble() throws IOException {
String x = next();
StringBuilder sb = new StringBuilder("0");
double res = 0, f = 1;
boolean dec = false, neg = false;
int start = 0;
if (x.charAt(0) == '-') {
neg = true;
start++;
}
for (int i = start; i < x.length(); i++) {
if (x.charAt(i) == '.') {
res = Long.parseLong(sb.toString());
sb = new StringBuilder("0");
dec = true;
} else {
sb.append(x.charAt(i));
if (dec)
f *= 10;
}
if (sb.length() == 18) {
res += Long.parseLong(sb.toString()) / f;
sb = new StringBuilder("0");
}
}
res += Long.parseLong(sb.toString()) / f;
return res * (neg ? -1 : 1);
}
public boolean ready() throws IOException {
return br.ready();
}
}
public static void shuffle(int[] a) {
int n = a.length;
for (int i = 0; i < n; i++) {
int r = i + (int) (Math.random() * (n - i));
int tmp = a[i];
a[i] = a[r];
a[r] = tmp;
}
}
}
|
Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya loves long lucky numbers very much. He is interested in the minimum lucky number d that meets some condition. Let cnt(x) be the number of occurrences of number x in number d as a substring. For example, if d = 747747, then cnt(4) = 2, cnt(7) = 4, cnt(47) = 2, cnt(74) = 2. Petya wants the following condition to fulfil simultaneously: cnt(4) = a1, cnt(7) = a2, cnt(47) = a3, cnt(74) = a4. Petya is not interested in the occurrences of other numbers. Help him cope with this task.
Input
The single line contains four integers a1, a2, a3 and a4 (1 ≤ a1, a2, a3, a4 ≤ 106).
Output
On the single line print without leading zeroes the answer to the problem — the minimum lucky number d such, that cnt(4) = a1, cnt(7) = a2, cnt(47) = a3, cnt(74) = a4. If such number does not exist, print the single number "-1" (without the quotes).
Examples
Input
2 2 1 1
Output
4774
Input
4 7 3 1
Output
-1
|
#include <bits/stdc++.h>
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a > b ? b : a; }
int main() {
int i;
int a4, a7, a47, a74;
scanf("%d %d %d %d", &a4, &a7, &a47, &a74);
if (fabs(a47 - a74) > 1) {
printf("-1\n");
return 0;
}
if (a47 != a74) {
if (min(a4, a7) < max(a47, a74)) {
printf("-1\n");
return 0;
}
}
if (a47 == a74) {
if (!((a4 > a47 && a7 >= a47) || (a4 >= a47 && a7 > a47))) {
printf("-1\n");
return 0;
}
}
if (a47 > a74) {
for (i = 1; i <= a4 - a47; i++) printf("4");
for (i = 1; i <= a47; i++) printf("47");
for (i = 1; i <= a7 - a47; i++) printf("7");
printf("\n");
} else if (a47 < a74) {
printf("74");
for (i = 1; i <= a4 - a74; i++) printf("4");
for (i = 1; i <= a74 - 2; i++) printf("74");
for (i = 1; i <= a7 - a74 + 1; i++) printf("7");
printf("4\n");
} else if (a47 == a74) {
if (a4 == a47) {
for (i = 1; i <= a47; i++) printf("74");
for (i = 1; i <= a7 - a47; i++) printf("7");
printf("\n");
} else {
for (i = 1; i <= a4 - a47 - 1; i++) printf("4");
for (i = 1; i <= a47; i++) printf("47");
for (i = 1; i <= a7 - a47; i++) printf("7");
printf("4\n");
}
}
}
|
There are n squares drawn from left to right on the floor. The i-th square has three integers p_i,a_i,b_i, written on it. The sequence p_1,p_2,...,p_n forms a permutation.
Each round you will start from the leftmost square 1 and jump to the right. If you are now on the i-th square, you can do one of the following two operations:
1. Jump to the i+1-th square and pay the cost a_i. If i=n, then you can end the round and pay the cost a_i.
2. Jump to the j-th square and pay the cost b_i, where j is the leftmost square that satisfies j > i, p_j > p_i. If there is no such j then you can end the round and pay the cost b_i.
There are q rounds in the game. To make the game more difficult, you need to maintain a square set S (initially it is empty). You must pass through these squares during the round (other squares can also be passed through). The square set S for the i-th round is obtained by adding or removing a square from the square set for the (i-1)-th round.
For each round find the minimum cost you should pay to end it.
Input
The first line contains two integers n, q (1≤ n,q≤ 2 ⋅ 10^5) — the number of squares and the number of rounds.
The second line contains n distinct integers p_1,p_2,...,p_n (1≤ p_i≤ n). It is guaranteed that the sequence p_1,p_2,...,p_n forms a permutation.
The third line contains n integers a_1,a_2,…,a_n (-10^9≤ a_i≤ 10^9).
The fourth line contains n integers b_1,b_2,...,b_n (-10^9≤ b_i≤ 10^9).
Then q lines follow, i-th of them contains a single integer x_i (1≤ x_i≤ n). If x_i was in the set S on the (i-1)-th round you should remove it, otherwise, you should add it.
Output
Print q lines, each of them should contain a single integer — the minimum cost you should pay to end the corresponding round.
Examples
Input
3 2
2 1 3
10 -5 4
3 -2 3
1
2
Output
6
8
Input
5 4
2 1 5 3 4
6 -5 3 -10 -1
0 3 2 7 2
1
2
3
2
Output
-8
-7
-7
-8
Note
Let's consider the character T as the end of a round. Then we can draw two graphs for the first and the second test.
<image> <image>
In the first round of the first test, the set that you must pass through is \{1\}. The path you can use is 1→ 3→ T and its cost is 6.
In the second round of the first test, the set that you must pass through is \{1,2\}. The path you can use is 1→ 2→ 3→ T and its cost is 8.
|
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
#include <queue>
#include <map>
#include <set>
using namespace std;
#define int long long
#define ull unsigned long long
#define fi first
#define se second
#define mpr make_pair
#define dingyi int mid = l + r >> 1, ls = p << 1, rs = p << 1 | 1
#define y0 y_csyakioi_0
#define y1 y_csyakioi_1
#define rep(i, x, y) for(int i = x; i <= y; ++i)
#define per(i, x, y) for(int i = x; i >= y; --i)
#define repg(i, u) for(int i = head[u]; i; i = e[i].nxt)
inline int read(){
int x = 0, f = 1; char ch = getchar();
while(ch < '0' || ch > '9'){ if(ch == '-') f = -1; ch = getchar(); }
while(ch >= '0' && ch <= '9'){ x = x * 10 + (ch ^ 48); ch = getchar(); }
return x * f;
}
const int N = 200010;
struct edge{ int v, nxt; } e[N << 1]; int head[N], cnt;
int n, m, p[N], a[N], b[N], dis[N], dep[N], f[N][20], c[N], sta[N], len, num[N], ans;
set <int> st; set <int> ::iterator it; bool vis[N];
inline void add(int u, int v){ e[++cnt].v = v; e[cnt].nxt = head[u]; head[u] = cnt; }
inline void dfs(int u){
dep[u] = dep[f[u][0]] + 1;
rep(j, 1, 18) f[u][j] = f[f[u][j - 1]][j - 1];
repg(i, u) dfs(e[i].v);
}
inline int lca(int x, int y){
if(dep[x] < dep[y]) swap(x, y); per(i, 18, 0) if(dep[f[x][i]] >= dep[y]) x = f[x][i];
if(x == y) return x; per(i, 18, 0) if(f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
inline int pat(int x, int y){ return dis[x] + dis[y] - 2 * dis[lca(x, y)]; }
inline void Insert(int x){
it = st.insert(x).fi; int y = *(--it); ++it; ++it;
int z = ((it == st.end()) ? *st.begin() : *it);
ans += pat(y, x) + pat(x, z) - pat(y, z);
}
inline void Delete(int x){
it = st.find(x); int y = *(--it); ++it; ++it;
int z = ((it == st.end()) ? *st.begin() : *it);
ans -= pat(y, x) + pat(x, z) - pat(y, z);
--it; st.erase(it);
}
inline void mian(){
n = read(); m = read();
rep(i, 1, n){
p[i] = read(); while(p[sta[len]] < p[i] && len) --len;
f[i][0] = sta[len]; add(sta[len], i); sta[++len] = i;
} dfs(0);
rep(i, 1, n) a[i] = read(), c[i] += a[i];
rep(i, 1, n) b[i] = read(), c[i] -= b[i], c[f[i][0]] += b[i];
per(i, n, 1) dis[i] += c[i], dis[f[i][0]] += min(dis[i], 0ll), dis[i] -= min(0ll, dis[i]);
dis[0] += c[0]; rep(i, 1, n) dis[i] += dis[f[i][0]]; num[0] = 1; st.insert(0);
while(m--){
int x = read();
if(vis[x]){
vis[x] = 0;
if(!(--num[f[x][0]])) Delete(f[x][0]);
}
else{
vis[x] = 1;
if(!(num[f[x][0]]++)) Insert(f[x][0]);
}
printf("%lld\n", ans / 2 + dis[0]);
}
}
signed main(){ int qwq = 1; while(qwq--) mian(); return 0; }
|
Polycarp is an organizer of a Berland ICPC regional event. There are n universities in Berland numbered from 1 to n. Polycarp knows all competitive programmers in the region. There are n students: the i-th student is enrolled at a university u_i and has a programming skill s_i.
Polycarp has to decide on the rules now. In particular, the number of members in the team.
Polycarp knows that if he chooses the size of the team to be some integer k, each university will send their k strongest (with the highest programming skill s) students in the first team, the next k strongest students in the second team and so on. If there are fewer than k students left, then the team can't be formed. Note that there might be universities that send zero teams.
The strength of the region is the total skill of the members of all present teams. If there are no teams present, then the strength is 0.
Help Polycarp to find the strength of the region for each choice of k from 1 to n.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of testcases.
The first line of each testcase contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of universities and the number of students.
The second line of each testcase contains n integers u_1, u_2, ..., u_n (1 ≤ u_i ≤ n) — the university the i-th student is enrolled at.
The third line of each testcase contains n integers s_1, s_2, ..., s_n (1 ≤ s_i ≤ 10^9) — the programming skill of the i-th student.
The sum of n over all testcases doesn't exceed 2 ⋅ 10^5.
Output
For each testcase print n integers: the strength of the region — the total skill of the members of the present teams — for each choice of team size k.
Example
Input
4
7
1 2 1 2 1 2 1
6 8 3 1 5 1 5
10
1 1 1 2 2 2 2 3 3 3
3435 3014 2241 2233 2893 2102 2286 2175 1961 2567
6
3 3 3 3 3 3
5 9 6 7 9 7
1
1
3083
Output
29 28 26 19 0 0 0
24907 20705 22805 9514 0 0 0 0 0 0
43 43 43 32 38 43
3083
Note
In the first testcase the teams from each university for each k are:
* k=1:
* university 1: [6], [5], [5], [3];
* university 2: [8], [1], [1];
* k=2:
* university 1: [6, 5], [5, 3];
* university 2: [8, 1];
* k=3:
* university 1: [6, 5, 5];
* university 2: [8, 1, 1];
* k=4:
* university 1: [6, 5, 5, 3];
|
import java.util.*;
import java.awt.image.BandedSampleModel;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Array;
import java.util.Scanner;
public class B {
static void sort(int[] A){
int n = A.length;
Random rnd = new Random();
for(int i=0; i<n; ++i){
int tmp = A[i];
int randomPos = i + rnd.nextInt(n-i);
A[i] = A[randomPos];
A[randomPos] = tmp;
}
Arrays.sort(A);
}
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int cases = sc.nextInt();
StringBuilder ans=new StringBuilder();
for(int i=0;i<cases;i++)
{
Map<Long,Integer> map=new HashMap<>();
int c=0;
Map<Long,Integer> m2=new HashMap<>();
int n = sc.nextInt();
long u[] = new long[n];
for(int j=0;j<n;j++)
{
u[j]=sc.nextLong();
map.putIfAbsent(u[j],0);
map.put(u[j],map.get(u[j])+1);
if(m2.get(u[j])==null)
{
m2.put(u[j],c);
c++;
}
}
long s[]=new long[n];
for(int j=0;j<n;j++)
{
s[j]=sc.nextLong();
}
long arr[][]=new long[map.size()][];
long x[][]=new long[map.size()][];
long sum[]=new long[map.size()];
for(long j:map.keySet())
{
int key=(int)j;
int val=m2.get(j);
int num=map.get(j);
arr[val]= new long[num];
x[val]=new long[num];
}
int cons[]=new int[map.size()];
//Arrays.fill(cons,-1);
for(int j=0;j<n;j++)
{
int f=m2.get(u[j]);
arr[f][cons[f]]=s[j];
// x[f][cons[f]]=-1;
sum[f]=s[j]+sum[f];
cons[f]++;
}
for(int j=0;j<arr.length;j++)
{
Arrays.sort(arr[j]);
}
for(int j=0;j<map.size();j++)
{
for(int k=1;k<arr[j].length;k++)
{
// if(k==0)
// {
// x[j][0]=arr[j][k];
// }
//else
{
x[j][k]=x[j][k-1]+arr[j][k-1];
}
}
}
long fin[]=new long[n];
for(int j=0;j<map.size();j++)
{
for(int k=0;k<n;k++)
{
if(k>arr[j].length-1)
{
break;
}
else
{
int a=arr[j].length%(k+1);
//if(a<arr[j].length) {
fin[k] = fin[k] + sum[j] - x[j][a];
}
}
}
for(int j=0;j<n;j++)
{
ans.append(fin[j]+" ");
}
ans.append("\n");
}
System.out.print(ans);
}
}
|
AquaMoon has n friends. They stand in a row from left to right, and the i-th friend from the left wears a T-shirt with a number a_i written on it. Each friend has a direction (left or right). In the beginning, the direction of each friend is right.
AquaMoon can make some operations on friends. On each operation, AquaMoon can choose two adjacent friends and swap their positions. After each operation, the direction of both chosen friends will also be flipped: left to right and vice versa.
AquaMoon hopes that after some operations, the numbers written on the T-shirt of n friends in the row, read from left to right, become non-decreasing. Also she wants, that all friends will have a direction of right at the end. Please find if it is possible.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 50) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of Aquamoon's friends.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^5) — the numbers, written on the T-shirts.
It is guaranteed that the sum of n for all test cases does not exceed 10^5.
Output
For each test case, if there exists a possible sequence of operations, print "YES" (without quotes); otherwise, print "NO" (without quotes).
You can print each letter in any case (upper or lower).
Example
Input
3
4
4 3 2 5
4
3 3 2 2
5
1 2 3 5 4
Output
YES
YES
NO
Note
The possible list of operations in the first test case:
1. Swap a_1 and a_2. The resulting sequence is 3, 4, 2, 5. The directions are: left, left, right, right.
2. Swap a_2 and a_3. The resulting sequence is 3, 2, 4, 5. The directions are: left, left, right, right.
3. Swap a_1 and a_2. The resulting sequence is 2, 3, 4, 5. The directions are: right, right, right, right.
|
#include<bits/stdc++.h>
using namespace std;
template<typename T,typename T1>T amax(T &a,T1 b){if(b>a)a=b;return a;}
template<typename T,typename T1>T amin(T &a,T1 b){if(b<a)a=b;return a;}
#define ll long long int
#define ld long double
#define INF (int)1e9+4
#define INFL (ll)1e18+4
#define md (int)1e9+7 //use fixed<<setprecion
#define mk make_pair
#define pi pair<int,int>
#define ss second
#define ff first
#define pb push_back
#define eb emplace_back
#define ppcl(x) __builtin_popcountll(x)
#define ppc(x) __builtin_popcount(x)
#define maxi(a) *max_element(a.begin(),a.end());
#define mini(a) *min_element(a.begin(),a.end());
#define all(s) s.begin(),s.end()
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) ((long long)x.size())
#define mez(s) memset(s,0,sizeof s)
#define mex(s) memset(s,-1,sizeof s)
#define metr(s) memset(s,true, sizeof s)
#define rep(i,a,b) for(int i=a;i<b;i++)
#define fr(i,a,b) for(int i=a;i<=b;i++)
#define rrep(i,a,b) for(int i=a;i>b;i--)
#define rfr(i,a,b) for(int i=a;i>=b;i--)
//#define INF 1e9+7
typedef vector<int> vi;
typedef vector<vector<int>>vvi;
typedef vector<ll>vl;
typedef map<string,int> mp;
typedef queue<int> que;
typedef vector<pi> vp;
const int mxn=1e5+1;
int odd[mxn],even[mxn],new_odd[mxn],new_even[mxn];
void solve(){
int n=0,m=0,k=0,x=0,y=0,z=0;
cin>>n;
memset(odd,0,sizeof odd);
memset(even,0,sizeof even);
memset(new_odd,0,sizeof new_odd);
memset(new_even,0,sizeof new_even);
vector<int>a(n);
for(int i=0;i<n;i++){
cin>>a[i];
if(i%2)odd[a[i]]++;
else even[a[i]]++;
}
sort(a.begin(),a.end());
for(int i=0;i<n;i++){
if(i%2)new_odd[a[i]]++;
else new_even[a[i]]++;
}
for(int i=1;i<mxn;i++){
if(odd[i]!=new_odd[i] || even[i]!=new_even[i]){
cout<<"NO\n";
return;
}
}
cout<<"YES\n";
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int t=1;
cin>>t;
while(t--){
solve();
}
return 0;
}
|
The Trinitarian kingdom has exactly n = 3k cities. All of them are located on the shores of river Trissisipi, which flows through the whole kingdom. Some of the cities are located on one side of the river, and all the rest are on the other side.
Some cities are connected by bridges built between them. Each bridge connects two cities that are located on the opposite sides of the river. Between any two cities exists no more than one bridge.
The recently inaugurated King Tristan the Third is busy distributing his deputies among cities. In total there are k deputies and the king wants to commission each of them to control exactly three cities. However, no deputy can be entrusted to manage the cities, which are connected by a bridge — the deputy can set a too high fee for travelling over the bridge to benefit his pocket, which is bad for the reputation of the king.
Help King Tristan the Third distribute the deputies between the cities, if it is possible.
Input
The first line contains two integers n and m — the number of cities and bridges (3 ≤ n < 105, n = 3k, 0 ≤ m ≤ 105). Next m lines describe the bridges. The i-th line contains two integers ai and bi — the numbers of cities that are connected by the i-th bridge (1 ≤ ai, bi ≤ n, ai ≠ bi, 1 ≤ i ≤ m).
It is guaranteed that no bridge connects a city with itself and that any two cities are connected with no more than one bridge.
Output
If distributing the deputies in the required manner is impossible, print in a single line "NO" (without the quotes).
Otherwise, in the first line print "YES" (without the quotes), and in the second line print which deputy should be put in charge of each city. The i-th number should represent the number of the deputy (from 1 to k), who should be in charge of city numbered i-th in the input — overall there should be n numbers.
If there are multiple solutions, print any of them.
Examples
Input
6 6
1 2
4 1
3 5
6 5
2 6
4 6
Output
YES
1 2 1 2 2 1
Input
3 1
1 2
Output
NO
|
#include <bits/stdc++.h>
using namespace std;
namespace ufs {
int fa[100005];
void makeset(int n) {
for (int i = 1; i <= n; i++) fa[i] = i;
}
int findset(int u) {
if (fa[u] == u) return fa[u];
return fa[u] = findset(fa[u]);
}
void unionset(int a, int b) {
int u = findset(a);
int v = findset(b);
fa[u] = v;
}
} // namespace ufs
using namespace ufs;
int n, m, tot;
int x = 1, y = 0;
int tot_white, tot_black;
int col[100005], id[100005], d[100005];
bool used[100005];
vector<int> w, b;
vector<int> g[100005], v[100005];
map<int, int> t[100005];
void pr() {
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << id[i] << ' ';
exit(0);
}
void makenext(int &x, int &y) {
y++;
x += y / 3;
y %= 3;
}
void dfs(int u) {
if (col[u] == 1)
tot_white++;
else
tot_black++;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (col[v] != col[u] * -1) {
col[v] = col[u] * -1;
dfs(v);
}
}
}
void prepare() {
for (int i = 1; i <= n; i++)
if (col[i] == 0) {
col[i] = 1;
dfs(i);
}
if (tot_white % 3 == 2) {
swap(tot_white, tot_black);
for (int i = 1; i <= n; i++) col[i] *= -1;
}
}
void filp() {
for (int i = 1; i <= n; i++)
if (v[i].size() >= 1) {
for (int j = 0; j < v[i].size(); j++) col[v[i][j]] *= -1;
break;
}
tot_white = tot_black = 0;
for (int i = 1; i <= n; i++)
if (col[i] == 1)
tot_white++;
else
tot_black++;
if (tot_white % 3 == 2) {
swap(tot_white, tot_black);
for (int i = 1; i <= n; i++) col[i] *= -1;
}
}
void make12(int &x, int &y) {
int _ind;
for (int i = 0; i < w.size(); i++)
if (id[w[i]] == 0) {
_ind = w[i];
break;
}
id[_ind] = x;
makenext(x, y);
for (int i = 0; i < b.size(); i++) {
if (id[b[i]] == 0 && t[_ind][b[i]] == 0) {
id[b[i]] = x;
makenext(x, y);
}
if (x != id[_ind]) break;
}
}
void makeall(int &x, int &y) {
for (int i = 1; i <= n; i++)
if (col[i] == 1 && id[i] == 0) {
id[i] = x;
makenext(x, y);
}
for (int i = 1; i <= n; i++)
if (col[i] == -1 && id[i] == 0) {
id[i] = x;
makenext(x, y);
}
}
void check() {
w.clear();
b.clear();
for (int i = 1; i <= n; i++)
if (col[i] == 1)
w.push_back(i);
else
b.push_back(i);
bool f = 0;
for (int i = 0; i < w.size(); i++)
if (d[w[i]] <= tot_black - 2) {
swap(w[0], w[i]);
f = 1;
break;
}
if (f) {
make12(x, y);
makeall(x, y);
pr();
}
if (tot_white >= 4) {
int tot = 0;
for (int i = 0; i < b.size(); i++)
if (d[b[i]] <= tot_white - 2 && tot <= 1) {
swap(b[tot], b[i]);
tot++;
}
if (tot == 2) {
swap(tot_black, tot_white);
swap(w, b);
for (int i = 1; i <= n; i++) col[i] *= -1;
make12(x, y);
make12(x, y);
makeall(x, y);
pr();
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
makeset(n);
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
d[u]++;
d[v]++;
t[u][v] = t[v][u] = 1;
unionset(u, v);
}
for (int i = 1; i <= n; i++) {
if (used[findset(i)] == 0) {
used[findset(i)] = 1;
tot++;
}
v[findset(i)].push_back(i);
}
prepare();
if (tot_white % 3 == 0 && tot_black % 3 == 0) {
makeall(x, y);
pr();
}
if (tot == 2) {
check();
} else
check();
cout << "NO";
return 0;
}
|
John Doe has a list of all Fibonacci numbers modulo 1013. This list is infinite, it starts with numbers 0 and 1. Each number in the list, apart from the first two, is a sum of previous two modulo 1013. That is, John's list is made from the Fibonacci numbers' list by replacing each number there by the remainder when divided by 1013.
John got interested in number f (0 ≤ f < 1013) and now wants to find its first occurrence in the list given above. Help John and find the number of the first occurence of number f in the list or otherwise state that number f does not occur in the list.
The numeration in John's list starts from zero. There, the 0-th position is the number 0, the 1-st position is the number 1, the 2-nd position is the number 1, the 3-rd position is the number 2, the 4-th position is the number 3 and so on. Thus, the beginning of the list looks like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
Input
The first line contains the single integer f (0 ≤ f < 1013) — the number, which position in the list we should find.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number — the number of the first occurrence of the given number in John's list. If this number doesn't occur in John's list, print -1.
Examples
Input
13
Output
7
Input
377
Output
14
|
#include <bits/stdc++.h>
long long mo, ans[1000], res[1000];
long long mul(long long a, long long b) {
return b == 0 ? 0 : ((mul(a, b >> 16) << 16) + a * (b & (1 << 16) - 1)) % mo;
}
void mul(long long f[2][2], long long g[2][2]) {
long long a[2][2];
a[0][0] = (mul(f[0][0], g[0][0]) + mul(f[0][1], g[1][0])) % mo;
a[0][1] = (mul(f[0][0], g[0][1]) + mul(f[0][1], g[1][1])) % mo;
a[1][0] = (mul(f[1][0], g[0][0]) + mul(f[1][1], g[1][0])) % mo;
a[1][1] = (mul(f[1][0], g[0][1]) + mul(f[1][1], g[1][1])) % mo;
memcpy(f, a, sizeof a);
}
void prezro(long long g[2][2]) { g[0][0] = g[1][1] = 1, g[0][1] = g[1][0] = 0; }
void quick(long long f[2][2], long long n) {
long long g[2][2];
for (prezro(g); n; n >>= 1) {
if (n & 1) mul(g, f);
mul(f, f);
}
memcpy(f, g, sizeof g);
}
void preget(long long f[2][2]) { f[0][0] = 0, f[0][1] = f[1][0] = f[1][1] = 1; }
bool dw(long long g[2][2]) {
return g[0][0] == 1 && g[1][1] == 1 && !g[0][1] && !g[1][0];
}
int main() {
long long n, tm;
long long f[2][2], g[2][2], h[2][2];
int i, j, k, cnt, pp;
scanf("%I64d", &n);
for (mo = tm = 1, cnt = 1, ans[0] = 0, i = 0; i < 13; i++) {
mo = mo * 10;
preget(f);
quick(f, tm);
prezro(g), pp = 0, j = 0;
do {
for (k = 0; k < cnt; k++) {
preget(h);
quick(h, ans[k] + tm * j);
if (h[1][0] == n % mo) res[pp++] = ans[k] + tm * j;
}
mul(g, f);
j++;
} while (!dw(g));
memcpy(ans, res, sizeof res);
cnt = pp;
tm *= j;
}
printf("%I64d\n", cnt == 0 ? -1 : ans[0]);
return 0;
}
|
Professor Bajtocy is conducting experiments on alien DNA. He has discovered that it is subject to repetitive mutations — each mutation happens in the same way: some continuous subsequence of the alien DNA becomes active, copies itself, the copy gets mangled and inserts itself right after the original subsequence. The mangled copy of the activated continuous subsequence is formed by first joining all the elements at the even positions in that subsequence, and then joining all the elements at the odd ones at the end. That is, if the activated subsequence consists of 11 elements and represented as s1s2... s11, its mangled copy is s2s4s6s8s10s1s3s5s7s9s11.
For example, if the original sequence was "ACTGG" and the mutation happened on the segment [2, 4] (that is the activated subsequence is "CTG"), the mutated DNA is: "ACTGTCGG". The mangled copy of the activated subsequence is marked with bold font.
Professor Bajtocy has written down the original DNA sequence and the mutations that sequentially happened to it, and he now asks you to recover the first k elements of the DNA sequence after all the mutations.
Input
The first line of input contains the original DNA sequence, consisting only of letters "A", "C", "T" and "G" and not exceeding 3·106 in length.
The second line contains a single integer k (1 ≤ k ≤ 3·106).
The third line contains a single integer n (0 ≤ n ≤ 5000) — the number of mutations. The next n lines describe the mutations in chronological order — each mutation is described by two numbers li and ri (1 ≤ li ≤ ri ≤ 109), meaning that the continuous subsequence [li, ri] has become active and cloned itself, joining itself with the mangled copy.
It is guaranteed that the input data is correct, that is, no mutation acts on non-existing elements of the DNA sequence, and the resulting DNA sequence has at least k elements.
Assume that the DNA elements are indexed starting from 1 and that the notation [l, r] meaning the continuous subsequence of DNA sequence that consists of r - l + 1 elements starting at the l-th DNA sequence element and ending at the r-th DNA sequence element.
Output
Output a single line, containing the first k letters of the mutated DNA sequence.
Examples
Input
GAGA
4
0
Output
GAGA
Input
ACGTACGT
16
2
1 2
2 8
Output
ACCAGTACCGACATCG
Note
In the second example, after the first mutation the sequence is "ACCAGTACGT". After the second mutation it's "ACCAGTACCGACATCGT".
|
#include <bits/stdc++.h>
const int MOD = 1E9 + 7;
const int N = 3000000 + 5;
const int dx[] = {-1, 1, 0, 0, -1, -1, 1, 1};
const int dy[] = {0, 0, -1, 1, -1, 1, -1, 1};
using namespace std;
int tot, f[N], X[N], Y[N], a[N], len, seq[N];
int n, m;
int father[N];
char str[N], c;
int get(int x) {
int l = 1;
seq[1] = x;
for (; f[seq[l]]; l++) seq[l + 1] = f[seq[l]];
for (int i = 1; i < l; i++) f[seq[i]] = seq[l];
return seq[l];
}
int getPos(int x) {
if (!tot) return x;
int i = 1, last;
if (x < X[a[i]]) return x;
x -= X[a[i]] - 1;
for (last = i++; i <= tot; i++)
if (X[a[i]] > Y[a[last]]) {
if (x > X[a[i]] - Y[a[last]] - 1) {
x -= X[a[i]] - Y[a[last]] - 1;
last = i;
} else
return Y[a[last]] + x;
}
return Y[a[last]] + x;
}
struct Query {
int right;
int left;
} query[N];
int main() {
scanf("%s", str + 1);
scanf("%d%d", &m, &n);
for (int i = 0; i < n; i++) scanf("%d%d", &query[i].left, &query[i].right);
memset(f, 0, sizeof(f));
memset(father, 0, sizeof(father));
for (int i = n - 1; i >= 0; i--)
if (query[i].right < m) {
int pos = getPos(query[i].right + 1);
if (pos <= m) {
int k = query[i].left + 1;
if (k > query[i].right) k = query[i].left;
int newPos = getPos(k), lim = (query[i].right << 1) - query[i].left + 1,
j;
X[i] = pos;
for (j = query[i].right + 1; j <= lim && pos <= m;
j++, pos = get(pos)) {
father[pos] = newPos;
f[pos] = pos + 1;
k += 2;
if (k <= query[i].right)
newPos = get(get(newPos + 1) + 1);
else {
k = query[i].left;
newPos = getPos(k);
}
Y[i] = pos;
}
for (j = tot; j && X[a[j]] > X[i]; j--) a[j + 1] = a[j];
a[j + 1] = i;
tot++;
}
}
int cnt = 0;
for (int i = 1; i <= m; i++) {
father[i] = (!father[i]) ? ++cnt : father[father[i]];
printf("%c", str[father[i]]);
}
printf("\n");
return 0;
}
|
You have a sequence of n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n). You want to remove some integers in such a way that the resulting sequence of integers satisfies the following three conditions:
1. the resulting sequence is not empty;
2. the exclusive or (xor operation) of all the integers in the resulting sequence equals 0;
3. if you write all the integers of the resulting sequence (from beginning to the end) in a row in the decimal numeral system and without any spaces, the written number is divisible by p.
You are given the sequence of n integers a and a prime number p, find a way to satisfy the described conditions.
Input
The first line of the input contains two integers n and p (1 ≤ n, p ≤ 50000). Next line contains n space-separated distinct integers a1, a2, ..., an (1 ≤ ai ≤ n).
It is guaranteed that p is a prime number.
Output
If there is no solution for the given input, print "No" (without quotes) in the only line of the output.
Otherwise print "Yes" in the first line of output. The second line should contain an integer k (k > 0) specifying the number of remaining elements and the third line should contain k distinct integers x1, x2, ..., xk (1 ≤ xi ≤ n). These integers mean that you should remove all integers from the sequence except integers ax1, ax2, ..., axk to satisfy the described conditions.
If there are multiple solutions, any of them will be accepted.
Examples
Input
3 3
1 2 3
Output
Yes
3
1 2 3
Input
3 5
1 2 3
Output
No
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
register long long s = 0, f = 0;
register char ch = getchar();
while (!isdigit(ch)) f |= (ch == '-'), ch = getchar();
while (isdigit(ch)) s = (s << 1) + (s << 3) + (ch ^ 48), ch = getchar();
return f ? -s : s;
}
long long n, m, p, check;
const long long MAX = 26;
long long a[MAX], b[MAX], pos[MAX];
inline long long pw(long long x) { return x < 10 ? 10 : 100; }
inline void dfs(long long k, long long x, long long y, long long num) {
if (x == 0 and y == 0 and num) {
puts("Yes");
printf("%lld\n", num);
for (register long long i = 1; i <= num; ++i) {
printf("%lld ", b[i]);
}
exit(0);
}
if (k > m) return;
dfs(k + 1, x, y, num);
b[num + 1] = pos[a[k]];
dfs(k + 1, x ^ a[k], (y * pw(a[k]) + a[k]) % p, num + 1);
}
signed main() {
n = read(), p = read();
for (register long long i = 1; i <= n; ++i) {
long long x = read();
if (x < MAX) a[++m] = x, pos[x] = i;
}
dfs(1, 0, 0, 0);
puts("No");
return 0;
}
|
You are given a square matrix consisting of n rows and n columns. We assume that the rows are numbered from 1 to n from top to bottom and the columns are numbered from 1 to n from left to right. Some cells (n - 1 cells in total) of the the matrix are filled with ones, the remaining cells are filled with zeros. We can apply the following operations to the matrix:
1. Swap i-th and j-th rows of the matrix;
2. Swap i-th and j-th columns of the matrix.
You are asked to transform the matrix into a special form using these operations. In that special form all the ones must be in the cells that lie below the main diagonal. Cell of the matrix, which is located on the intersection of the i-th row and of the j-th column, lies below the main diagonal if i > j.
Input
The first line contains an integer n (2 ≤ n ≤ 1000) — the number of rows and columns. Then follow n - 1 lines that contain one's positions, one per line. Each position is described by two integers xk, yk (1 ≤ xk, yk ≤ n), separated by a space. A pair (xk, yk) means that the cell, which is located on the intersection of the xk-th row and of the yk-th column, contains one.
It is guaranteed that all positions are distinct.
Output
Print the description of your actions. These actions should transform the matrix to the described special form.
In the first line you should print a non-negative integer m (m ≤ 105) — the number of actions. In each of the next m lines print three space-separated integers t, i, j (1 ≤ t ≤ 2, 1 ≤ i, j ≤ n, i ≠ j), where t = 1 if you want to swap rows, t = 2 if you want to swap columns, and i and j denote the numbers of rows or columns respectively.
Please note, that you do not need to minimize the number of operations, but their number should not exceed 105. If there are several solutions, you may print any of them.
Examples
Input
2
1 2
Output
2
2 1 2
1 1 2
Input
3
3 1
1 3
Output
3
2 2 3
1 1 3
1 1 2
Input
3
2 1
3 2
Output
0
|
import java.util.*;
public class C163 {
class Line{
public ArrayList<Integer> l = new ArrayList<Integer>();
public int yuan;
public Line() {
l = new ArrayList<Integer>();
}
}
class Lie{
public int min;
public int shu;
public int yuan;
public Lie(int min, int shu, int yuan) {
super();
this.min = min;
this.shu = shu;
this.yuan = yuan;
}
}
class Jl{
public int a,b,c;
public Jl(int a, int b, int c) {
super();
this.a = a;
this.b = b;
this.c = c;
}
@Override
public String toString() {
return String.format("%d %d %d", a,b,c);
}
}
Line maz[] ;
Lie lie[];
int juzhen[][];
List <Jl> ans = new LinkedList<Jl>();
void run(){
Scanner cin = new Scanner(System.in);
int n = cin.nextInt();
maz = new Line[n+1];
int i,j;
for(i=0;i<n+1;i++){
maz[i] = new Line();
maz[i].yuan = i;
}
maz[0].yuan = 0;
for(i=0;i<n-1;i++){
int x = cin.nextInt();
int y = cin.nextInt();
maz[x].l.add(y);
}
Arrays.sort(maz,new Comparator<Line>() {
@Override
public int compare(Line o1, Line o2) {
if(o1.l.size() != o2.l.size())
return o1.l.size() - o2.l.size();
return o1.yuan - o2.yuan;
}
});
int bi[] = new int[n+1];
for(i=0;i<=n;i++)
bi[maz[i].yuan] = i;
for(i=n;i>=1;i--){
if(i != bi[i])
{
int w = i;
for(j=1;j<=n;j++)
{
if(bi[j] == i)
w = j;
}
ans.add(new Jl(1,i,w));
int temp = bi[i];
bi[i] = bi[w];
bi[w] = temp;
}
}
juzhen = new int[n+1][n+1];
for(i=1;i<=n;i++){
for(j=1;j<=n;j++)
juzhen[i][j] = 0;
}
for(i=n;i>=1;i--){
if(maz[i].l.size() == 0)
break;
for(j=0;j<maz[i].l.size();j++)
{
juzhen[i][maz[i].l.get(j)] = 1;
}
}
lie = new Lie[n+1];
lie[0] = new Lie(-9,90000,-9);
for(j=1;j<=n;j++){
boolean flag = false;
int count = 0;
int min = -1;
for(i=1;i<=n;i++){
if(juzhen[i][j] == 1 && flag == false)
{
flag =true;
min = i;
count ++;
}
else if(juzhen[i][j] == 1){
count ++;
}
}
lie[j] = new Lie(min, count,j);
}
Arrays.sort(lie,new Comparator<Lie>() {
@Override
public int compare(Lie o1, Lie o2) {
if(o1.shu != o2.shu)
{
return o2.shu - o1.shu;
}
return o1.min - o2.min;
}
});
for(i=1;i<=n;i++)
bi[lie[i].yuan] = i;
for(i=n;i>=1;i--){
if(i != bi[i])
{
int w = i;
for(j=1;j<=n;j++)
{
if(bi[j] == i)
w = j;
}
ans.add(new Jl(2,i,w));
int temp = bi[i];
bi[i] = bi[w];
bi[w] = temp;
}
}
System.out.println(ans.size());
for(Jl buf : ans){
System.out.println(buf);
}
}
public static void main(String[] args) {
new C163().run();
}
}
|
There are n students living in the campus. Every morning all students wake up at the same time and go to wash. There are m rooms with wash basins. The i-th of these rooms contains ai wash basins. Every student independently select one the rooms with equal probability and goes to it. After all students selected their rooms, students in each room divide into queues by the number of wash basins so that the size of the largest queue is the least possible. Calculate the expected value of the size of the largest queue among all rooms.
Input
The first line contains two positive integers n and m (1 ≤ n, m ≤ 50) — the amount of students and the amount of rooms. The second line contains m integers a1, a2, ... , am (1 ≤ ai ≤ 50). ai means the amount of wash basins in the i-th room.
Output
Output single number: the expected value of the size of the largest queue. Your answer must have an absolute or relative error less than 10 - 9.
Examples
Input
1 1
2
Output
1.00000000000000000000
Input
2 2
1 1
Output
1.50000000000000000000
Input
2 3
1 1 1
Output
1.33333333333333350000
Input
7 5
1 1 2 3 1
Output
2.50216960000000070000
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n, m;
int a[N];
double dp[N][N][N];
long long C[N][N];
double qmod(double a, long long b) {
double res = 1;
while (b) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
int main() {
for (int i = 0; i < int(N); i++) {
C[i][0] = 1;
for (int j = 1; j < int(i + 1); j++)
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
scanf("%d%d", &n, &m);
for (int i = 1; i < int(m + 1); i++) scanf("%d", &a[i]);
for (int i = 0; i < int(n + 1); i++) dp[0][0][i] = i;
for (int i = 1; i < int(m + 1); i++) {
for (int j = 0; j < int(n + 1); j++) {
for (int k = 0; k < int(n + 1); k++) {
for (int c = 0; c < int(j + 1); c++) {
int p = max(k, (c + a[i] - 1) / a[i]);
dp[i][j][k] +=
dp[i - 1][j - c][p] * C[j][c] * qmod(i - 1, j - c) / qmod(i, j);
}
}
}
}
printf("%.12lf\n", dp[m][n][0]);
return 0;
}
|
During the last Sereja's Codesecrof round the server crashed many times, so the round was decided to be made unrated for some participants.
Let's assume that n people took part in the contest. Let's assume that the participant who got the first place has rating a1, the second place participant has rating a2, ..., the n-th place participant has rating an. Then changing the rating on the Codesecrof site is calculated by the formula <image>.
After the round was over, the Codesecrof management published the participants' results table. They decided that if for a participant di < k, then the round can be considered unrated for him. But imagine the management's surprise when they found out that the participants' rating table is dynamic. In other words, when some participant is removed from the rating, he is removed from the results' table and the rating is recalculated according to the new table. And of course, all applications for exclusion from the rating are considered in view of the current table.
We know that among all the applications for exclusion from the rating the first application to consider is from the participant with the best rank (the rank with the minimum number), for who di < k. We also know that the applications for exclusion from rating were submitted by all participants.
Now Sereja wonders, what is the number of participants to be excluded from the contest rating, and the numbers of the participants in the original table in the order of their exclusion from the rating. Pay attention to the analysis of the first test case for a better understanding of the statement.
Input
The first line contains two integers n, k (1 ≤ n ≤ 2·105, - 109 ≤ k ≤ 0). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — ratings of the participants in the initial table.
Output
Print the numbers of participants in the order in which they were removed from the table. Print the initial numbers of the participants, that is, the numbers that the participants had in the initial table.
Examples
Input
5 0
5 3 4 1 2
Output
2
3
4
Input
10 -10
5 5 1 7 5 1 2 4 9 2
Output
2
4
5
7
8
9
Note
Consider the first test sample.
1. Initially the sequence of the contest participants' ratings equals [5, 3, 4, 1, 2]. You can use this sequence to calculate the sequence of rating changes: [0, -9, -13, 8, 14]. According to the problem statement, the application of the participant who won the second place will be considered first.
2. As soon as the second place winner is out from the ratings, the participants' rating sequence will equal [5, 4, 1, 2]. By this sequence you can count the new sequence of rating changes: [0, -8, 2, 6]. According to the problem statement, the application of the participant who won the second place will be considered. Initially this participant won third place.
3. The new rating sequence equals [5, 1, 2], the new sequence of rating changes equals [0, -1, 1]. The second place participant's application is taken into consideration, initially this participant won the fourth place.
4. The new rating sequence equals [5, 2], the new sequence of rating changes equals [0, 0]. No more applications will be considered.
Thus, you should print 2, 3, 4.
|
#include <bits/stdc++.h>
inline int getInt() {
int s;
scanf("%d", &s);
return s;
}
using namespace std;
int main() {
const int n = getInt();
const long long k = getInt();
vector<long long> a(n);
for (int i = 0; i < (int)(n); i++) a[i] = getInt();
int cnt = 1;
long long d = 0;
for (int i = 1; i < n; i++) {
d -= (n - 1 - i) * a[i] * cnt;
const bool f = d < k;
d += (n - 1 - i) * a[i] * cnt;
if (f) {
printf("%d\n", i + 1);
} else {
cnt++;
d += a[i] * (cnt - 1);
}
}
return 0;
}
|
A divisor tree is a rooted tree that meets the following conditions:
* Each vertex of the tree contains a positive integer number.
* The numbers written in the leaves of the tree are prime numbers.
* For any inner vertex, the number within it is equal to the product of the numbers written in its children.
Manao has n distinct integers a1, a2, ..., an. He tries to build a divisor tree which contains each of these numbers. That is, for each ai, there should be at least one vertex in the tree which contains ai. Manao loves compact style, but his trees are too large. Help Manao determine the minimum possible number of vertices in the divisor tree sought.
Input
The first line contains a single integer n (1 ≤ n ≤ 8). The second line contains n distinct space-separated integers ai (2 ≤ ai ≤ 1012).
Output
Print a single integer — the minimum number of vertices in the divisor tree that contains each of the numbers ai.
Examples
Input
2
6 10
Output
7
Input
4
6 72 8 4
Output
12
Input
1
7
Output
1
Note
Sample 1. The smallest divisor tree looks this way: <image>
Sample 2. In this case you can build the following divisor tree: <image>
Sample 3. Note that the tree can consist of a single vertex.
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[8];
int factors[8];
int primeCnt;
int solve(int cur, vector<long long> &tree, int rootNum, int rootSum) {
if (cur == n) return n + (rootNum > 1) + rootSum - primeCnt;
int ret = 1 << 28;
for (int i = 0; i < (int)(tree.size()); i++) {
if (tree[i] % a[cur] == 0) {
tree.push_back(a[cur]);
tree[i] /= a[cur];
ret = min(ret, solve(cur + 1, tree, rootNum + (i == 0),
rootSum + (i == 0) * factors[cur]));
tree[i] *= a[cur];
tree.pop_back();
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < (int)(n); i++) cin >> a[i];
sort(a, a + n, greater<long long>());
for (int i = 0; i < (int)(n); i++) {
long long tmp = a[i];
for (int j = 2; (long long)j * j <= tmp; j++) {
while (tmp % j == 0) {
factors[i]++;
tmp /= j;
}
}
if (tmp > 1) factors[i]++;
if (tmp == a[i]) primeCnt++;
}
vector<long long> tree;
tree.push_back(0);
int ret = solve(0, tree, 0, 0);
cout << ret << endl;
return 0;
}
|
Levko has an array that consists of integers: a1, a2, ... , an. But he doesn’t like this array at all.
Levko thinks that the beauty of the array a directly depends on value c(a), which can be calculated by the formula:
<image> The less value c(a) is, the more beautiful the array is.
It’s time to change the world and Levko is going to change his array for the better. To be exact, Levko wants to change the values of at most k array elements (it is allowed to replace the values by any integers). Of course, the changes should make the array as beautiful as possible.
Help Levko and calculate what minimum number c(a) he can reach.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 2000). The second line contains space-separated integers a1, a2, ... , an ( - 109 ≤ ai ≤ 109).
Output
A single number — the minimum value of c(a) Levko can get.
Examples
Input
5 2
4 7 4 7 4
Output
0
Input
3 1
-100 0 100
Output
100
Input
6 3
1 2 3 7 8 9
Output
1
Note
In the first sample Levko can change the second and fourth elements and get array: 4, 4, 4, 4, 4.
In the third sample he can get array: 1, 2, 3, 4, 5, 6.
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long m) {
long long x = 1 % m;
a %= m;
while (b) {
if ((1 & b)) x = x * a % m;
a = a * a % m;
b >>= 1;
}
return x;
}
int a[2005];
int n, k;
long long dp[2005];
long long solve(long long x) {
for (int i = 1; i <= n + 1; i++) {
dp[i] = i - 1;
if (i != n + 1) {
for (int j = i - 1; j > 0; j--) {
if (abs(a[i] - a[j]) <= x * (i - j)) {
dp[i] = min(dp[i], dp[j] + (i - j - 1));
}
}
} else {
for (int j = i - 1; j > 0; j--) {
dp[i] = min(dp[i], dp[j] + (i - j - 1));
}
}
}
return dp[n + 1];
}
int main() {
scanf("%d", &n);
scanf("%d", &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
if (n == 1) {
printf("0");
return 0;
}
int mx = 0;
for (int i = 2; i <= n; i++) {
mx = max(mx, abs(a[i] - a[i - 1]));
}
long long l = 0, r = mx;
while (l < r) {
long long mid = (l + r) >> 1;
if (solve(mid) <= k)
r = mid;
else
l = mid + 1;
}
printf("%lld\n", l);
}
|
Iahubina is tired of so many complicated languages, so she decided to invent a new, simple language. She already made a dictionary consisting of n 3-words. A 3-word is a sequence of exactly 3 lowercase letters of the first 24 letters of the English alphabet (a to x). She decided that some of the letters are vowels, and all the others are consonants. The whole language is based on a simple rule: any word that contains at least one vowel is correct.
Iahubina forgot which letters are the vowels, and wants to find some possible correct sets of vowels. She asks Iahub questions. In each question, she will give Iahub a set of letters considered vowels (in this question). For each question she wants to know how many words of the dictionary are correct, considering the given set of vowels.
Iahubina wants to know the xor of the squared answers to all the possible questions. There are 224 different questions, they are all subsets of the set of the first 24 letters of the English alphabet. Help Iahub find that number.
Input
The first line contains one integer, n (1 ≤ n ≤ 104). Each of the next n lines contains a 3-word consisting of 3 lowercase letters. There will be no two identical 3-words.
Output
Print one number, the xor of the squared answers to the queries.
Examples
Input
5
abc
aaa
ada
bcd
def
Output
0
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 10010;
const int N = 24;
int inv = (1 << N) - 1;
int F[(1 << N) + 10];
int ara[MAX];
int howManyZeroPairs(int n, int ara[]) {
memset(F, 0, sizeof(F));
for (int i = 0; i < n; i++) F[ara[i]]++;
;
for (int i = 0; i < N; ++i)
for (int mask = 0; mask < (1 << N); ++mask) {
if (mask & (1 << i)) F[mask] += F[mask ^ (1 << i)];
}
int ans = 0;
for (int i = 0; i < (1 << N); i++)
ans ^= ((n - F[i ^ inv]) * (n - F[i ^ inv]));
return ans;
}
char str[5];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", str);
ara[i] = ara[i] ^ (1 << (str[0] - 'a'));
if (!(ara[i] & (1 << (str[1] - 'a'))))
ara[i] = ara[i] ^ (1 << (str[1] - 'a'));
if (!(ara[i] & (1 << (str[2] - 'a'))))
ara[i] = ara[i] ^ (1 << (str[2] - 'a'));
}
cout << howManyZeroPairs(n, ara) << endl;
return 0;
}
|
Game "Minesweeper 1D" is played on a line of squares, the line's height is 1 square, the line's width is n squares. Some of the squares contain bombs. If a square doesn't contain a bomb, then it contains a number from 0 to 2 — the total number of bombs in adjacent squares.
For example, the correct field to play looks like that: 001*2***101*. The cells that are marked with "*" contain bombs. Note that on the correct field the numbers represent the number of bombs in adjacent cells. For example, field 2* is not correct, because cell with value 2 must have two adjacent cells with bombs.
Valera wants to make a correct field to play "Minesweeper 1D". He has already painted a squared field with width of n cells, put several bombs on the field and wrote numbers into some cells. Now he wonders how many ways to fill the remaining cells with bombs and numbers are there if we should get a correct field in the end.
Input
The first line contains sequence of characters without spaces s1s2... sn (1 ≤ n ≤ 106), containing only characters "*", "?" and digits "0", "1" or "2". If character si equals "*", then the i-th cell of the field contains a bomb. If character si equals "?", then Valera hasn't yet decided what to put in the i-th cell. Character si, that is equal to a digit, represents the digit written in the i-th square.
Output
Print a single integer — the number of ways Valera can fill the empty cells and get a correct field.
As the answer can be rather large, print it modulo 1000000007 (109 + 7).
Examples
Input
?01???
Output
4
Input
?
Output
2
Input
**12
Output
0
Input
1
Output
0
Note
In the first test sample you can get the following correct fields: 001**1, 001***, 001*2*, 001*10.
|
import java.util.*;
import java.io.*;
public class Main{
BufferedReader in;
StringTokenizer str = null;
PrintWriter out;
private String next() throws Exception{
if (str == null || !str.hasMoreElements())
str = new StringTokenizer(in.readLine());
return str.nextToken();
}
private int nextInt() throws Exception{
return Integer.parseInt(next());
}
final static int MOD = (int)(1e9 + 7);
public void run() throws Exception{
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
char []a = next().toCharArray();
if (a[0] == '2') {
out.println(0);
out.close();
return;
}
int n = a.length;
long f[][] = new long[n][5];
if (a[0] == '?') {
f[0][0] = f[0][4] = 1;
if (n > 1) f[0][2] = 1;
}else {
if (a[0] == '0') f[0][0] = 1;
else if (a[0] == '*') f[0][4] = 1;
else {
if (n > 1) f[0][2] = 1;
}
}
for(int i=1;i<n;i++){
if (a[i] != '?') {
if (a[i] == '0') {
f[i][0] = f[i-1][0] + f[i-1][1];
}else if (a[i] == '1') {
f[i][1] = f[i-1][4];
f[i][2] = f[i-1][0] + f[i-1][1];
}else if (a[i] == '2') {
f[i][3] = f[i-1][4];
}else {
f[i][4] = f[i-1][2] + f[i-1][3] + f[i-1][4];
}
}else {
f[i][0] = f[i-1][0] + f[i-1][1];
f[i][1] = f[i-1][4];
f[i][2] = f[i-1][0] + f[i-1][1];
f[i][3] = f[i-1][4];
f[i][4] = f[i-1][2] + f[i-1][3] + f[i-1][4];
}
for(int j=0;j<5;j++){
f[i][j]%=MOD;
}
}
long res = 0;
if (a[n-1] == '?') {
res = f[n-1][0] + f[n-1][1] + f[n-1][4];
}else {
if (a[n-1] == '0') {
res = f[n-1][0];
}else if (a[n-1] == '1') {
res = f[n-1][1];
}else if (a[n-1] == '2') {
res = 0;
}else {
res = f[n-1][4];
}
}
out.println(res % MOD);
out.close();
}
public static void main(String args[]) throws Exception{
new Main().run();
}
}
|
One day two students, Grisha and Diana, found themselves in the university chemistry lab. In the lab the students found n test tubes with mercury numbered from 1 to n and decided to conduct an experiment.
The experiment consists of q steps. On each step, one of the following actions occurs:
1. Diana pours all the contents from tube number pi and then pours there exactly xi liters of mercury.
2. Let's consider all the ways to add vi liters of water into the tubes; for each way let's count the volume of liquid (water and mercury) in the tube with water with maximum amount of liquid; finally let's find the minimum among counted maximums. That is the number the students want to count. At that, the students don't actually pour the mercury. They perform calculations without changing the contents of the tubes.
Unfortunately, the calculations proved to be too complex and the students asked you to help them. Help them conduct the described experiment.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 105) — the number of tubes ans the number of experiment steps. The next line contains n space-separated integers: h1, h2, ..., hn (0 ≤ hi ≤ 109), where hi is the volume of mercury in the і-th tube at the beginning of the experiment.
The next q lines contain the game actions in the following format:
* A line of form "1 pi xi" means an action of the first type (1 ≤ pi ≤ n; 0 ≤ xi ≤ 109).
* A line of form "2 vi" means an action of the second type (1 ≤ vi ≤ 1015).
It is guaranteed that there is at least one action of the second type. It is guaranteed that all numbers that describe the experiment are integers.
Output
For each action of the second type print the calculated value. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 4.
Examples
Input
3 3
1 2 0
2 2
1 2 1
2 3
Output
1.50000
1.66667
Input
4 5
1 3 0 1
2 3
2 1
1 3 2
2 3
2 4
Output
1.66667
1.00000
2.33333
2.66667
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:67108864")
using namespace std;
inline long long FastMax(long long x, long long y) {
return (((y - x) >> (32 - 1)) & (x ^ y)) ^ y;
}
inline long long FastMin(long long x, long long y) {
return (((y - x) >> (32 - 1)) & (x ^ y)) ^ x;
}
long long N, Q;
long long A[1000007 + 7];
map<long long, long long> mp;
vector<long long> wh;
vector<pair<long long, pair<long long, long long> > > qr;
long long BIT_vol[1000007 + 7];
long long BIT_cnt[1000007 + 7];
void Update(long long *B, long long I, long long v) {
while (I and I <= 1000007) {
B[I] += v;
I += I & -I;
}
}
long long Find(long long *B, long long I) {
long long s = 0;
while (I) {
s += B[I];
I -= I & -I;
}
return s;
}
bool isPos(long long I, long long v, double &ans) {
long long c = Find(BIT_cnt, I);
long long tot = Find(BIT_vol, I);
long long Lim = wh[I] * c - tot;
if (Lim > v) {
ans = min(ans, (double)wh[I]);
return true;
} else {
ans = min(ans, wh[I] + (1.0 * v - Lim) / c);
return false;
}
}
int main(void) {
long long i, j, t, p, x, v, Icase, k = 0;
scanf("%I64d%I64d", &N, &Q);
mp[-1] = mp[0] = mp[1000000007] = 0;
for (i = 1; i <= N; i++) {
scanf("%I64d", &A[i]);
mp[A[i]] = 0;
}
for (i = 1; i <= Q; i++) {
scanf("%I64d", &t);
if (t == 1) {
scanf("%I64d%I64d", &p, &x);
qr.push_back(make_pair(1, make_pair(p, x)));
mp[x] = 0;
} else {
scanf("%I64d", &v);
qr.push_back(make_pair(2, make_pair(v, 0)));
}
}
map<long long, long long>::iterator it = mp.begin();
i = 0;
while (it != mp.end()) {
it->second = i;
wh.push_back(it->first);
i++;
it++;
}
for (i = 1; i <= N; i++) {
Update(BIT_vol, mp[A[i]], A[i]);
Update(BIT_cnt, mp[A[i]], 1);
}
for (i = 0; i < qr.size(); i++) {
t = qr[i].first;
if (t == 1) {
p = qr[i].second.first;
x = qr[i].second.second;
Update(BIT_vol, mp[A[p]], -A[p]);
Update(BIT_cnt, mp[A[p]], -1);
A[p] = x;
Update(BIT_vol, mp[A[p]], A[p]);
Update(BIT_cnt, mp[A[p]], 1);
} else {
v = qr[i].second.first;
long long lo = 1, hi = mp.size();
double ans = 1e17;
while (lo <= hi) {
long long mid = (lo + hi) / 2;
if (isPos(mid, v, ans))
hi = mid - 1;
else
lo = mid + 1;
}
printf("%.7lf\n", ans);
}
}
return 0;
}
|
One day, Twilight Sparkle is interested in how to sort a sequence of integers a1, a2, ..., an in non-decreasing order. Being a young unicorn, the only operation she can perform is a unit shift. That is, she can move the last element of the sequence to its beginning:
a1, a2, ..., an → an, a1, a2, ..., an - 1.
Help Twilight Sparkle to calculate: what is the minimum number of operations that she needs to sort the sequence?
Input
The first line contains an integer n (2 ≤ n ≤ 105). The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
If it's impossible to sort the sequence output -1. Otherwise output the minimum number of operations Twilight Sparkle needs to sort it.
Examples
Input
2
2 1
Output
1
Input
3
1 3 2
Output
-1
Input
2
1 2
Output
0
|
def us_num(nums):
where = None
for idx, (a, na) in enumerate(zip(nums[:-1], nums[1:])):
if a > na:
if where is None:
where = idx
else:
return -1
if where is None:
return 0
elif nums[-1] > nums[0]:
return -1
return len(nums) - 1 - where
n = int(input())
nums = list(map(int, input().split()))
print(us_num(nums))
|
Dreamoon has a string s and a pattern string p. He first removes exactly x characters from s obtaining string s' as a result. Then he calculates <image> that is defined as the maximal number of non-overlapping substrings equal to p that can be found in s'. He wants to make this number as big as possible.
More formally, let's define <image> as maximum value of <image> over all s' that can be obtained by removing exactly x characters from s. Dreamoon wants to know <image> for all x from 0 to |s| where |s| denotes the length of string s.
Input
The first line of the input contains the string s (1 ≤ |s| ≤ 2 000).
The second line of the input contains the string p (1 ≤ |p| ≤ 500).
Both strings will only consist of lower case English letters.
Output
Print |s| + 1 space-separated integers in a single line representing the <image> for all x from 0 to |s|.
Examples
Input
aaaaa
aa
Output
2 2 1 1 0 0
Input
axbaxxb
ab
Output
0 1 1 2 1 1 0 0
Note
For the first sample, the corresponding optimal values of s' after removal 0 through |s| = 5 characters from s are {"aaaaa", "aaaa", "aaa", "aa", "a", ""}.
For the second sample, possible corresponding optimal values of s' are {"axbaxxb", "abaxxb", "axbab", "abab", "aba", "ab", "a", ""}.
|
#include <bits/stdc++.h>
using namespace std;
string s;
string p;
int a[2005];
int A[2005];
int ans[2005];
int dp[2005][2005];
int main() {
cin >> s >> p;
memset(a, -1, sizeof(a));
a[0] = 0;
for (int i = 0; i < s.size(); i++) {
for (int j = p.size() - 1; j >= 0; j--) {
if (s[i] == p[j]) a[j + 1] = a[j];
}
a[0] = i + 1;
A[i + 1] = a[p.size()];
}
for (int i = 1; i <= s.size(); i++) {
for (int j = 0; j <= i; j++) {
dp[i][j] = dp[i - 1][j];
if (A[i] >= 0 && j - (i - A[i] - p.size()) >= 0 &&
j - (i - A[i] - p.size()) <= A[i])
dp[i][j] = max(dp[A[i]][j - (i - A[i] - p.size())] + 1, dp[i][j]);
}
}
for (int i = 0; i <= s.size(); i++) ans[i] = dp[s.size()][i];
for (int i = 0; i <= s.size(); i++) cout << ans[i] << " ";
return 0;
}
|
One hot summer day Pete and his friend Billy decided to buy a watermelon. They chose the biggest and the ripest one, in their opinion. After that the watermelon was weighed, and the scales showed w kilos. They rushed home, dying of thirst, and decided to divide the berry, however they faced a hard problem.
Pete and Billy are great fans of even numbers, that's why they want to divide the watermelon in such a way that each of the two parts weighs even number of kilos, at the same time it is not obligatory that the parts are equal. The boys are extremely tired and want to start their meal as soon as possible, that's why you should help them and find out, if they can divide the watermelon in the way they want. For sure, each of them should get a part of positive weight.
Input
The first (and the only) input line contains integer number w (1 ≤ w ≤ 100) — the weight of the watermelon bought by the boys.
Output
Print YES, if the boys can divide the watermelon into two parts, each of them weighing even number of kilos; and NO in the opposite case.
Examples
Input
8
Output
YES
Note
For example, the boys can divide the watermelon into two parts of 2 and 6 kilos respectively (another variant — two parts of 4 and 4 kilos).
|
x=int(input())
y=x-2
if y%2==0 and y!=0:
print("YES")
else :
print("NO")
|
Polycarpus has a finite sequence of opening and closing brackets. In order not to fall asleep in a lecture, Polycarpus is having fun with his sequence. He is able to perform two operations:
* adding any bracket in any position (in the beginning, the end, or between any two existing brackets);
* cyclic shift — moving the last bracket from the end of the sequence to the beginning.
Polycarpus can apply any number of operations to his sequence and adding a cyclic shift in any order. As a result, he wants to get the correct bracket sequence of the minimum possible length. If there are several such sequences, Polycarpus is interested in the lexicographically smallest one. Help him find such a sequence.
Acorrect bracket sequence is a sequence of opening and closing brackets, from which you can get a correct arithmetic expression by adding characters "1" and "+" . Each opening bracket must correspond to a closed one. For example, the sequences "(())()", "()", "(()(()))" are correct and ")(", "(()" and "(()))(" are not.
The sequence a1 a2... an is lexicographically smaller than sequence b1 b2... bn, if there is such number i from 1 to n, thatak = bk for 1 ≤ k < i and ai < bi. Consider that "(" < ")".
Input
The first line contains Polycarpus's sequence consisting of characters "(" and ")". The length of a line is from 1 to 1 000 000.
Output
Print a correct bracket sequence of the minimum length that Polycarpus can obtain by his operations. If there are multiple such sequences, print the lexicographically minimum one.
Examples
Input
()(())
Output
(())()
Input
()(
Output
(())
Note
The sequence in the first example is already correct, but to get the lexicographically minimum answer, you need to perform four cyclic shift operations. In the second example you need to add a closing parenthesis between the second and third brackets and make a cyclic shift. You can first make the shift, and then add the bracket at the end.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5;
char s[N];
int tp[N], rak[N], sa[N], tax[N], sl, m, cnt[N], lg[N], f[N][20], rr[N];
void radixSort() {
for (int i = 1; i <= m; i++) tax[i] = 0;
for (int i = 1; i <= sl; i++) tax[rak[i]]++;
for (int i = 1; i <= m; i++) tax[i] += tax[i - 1];
for (int i = sl; i; i--) sa[tax[rak[tp[i]]]--] = tp[i];
}
void build_sa() {
m = 125;
for (int i = 1; i <= sl; i++) rak[i] = s[i], tp[i] = i;
radixSort();
for (int p = 0, w = 1; p < sl; w <<= 1, m = p) {
p = 0;
for (int i = 1; i <= w; i++) tp[++p] = sl - w + i;
for (int i = 1; i <= sl; i++)
if (sa[i] > w) tp[++p] = sa[i] - w;
radixSort();
swap(tp, rak);
rak[sa[1]] = p = 1;
for (int i = 2; i <= sl; i++)
rak[sa[i]] =
(tp[sa[i]] == tp[sa[i - 1]] && tp[sa[i] + w] == tp[sa[i - 1] + w])
? p
: ++p;
}
}
void make_st() {
int range = lg[sl];
if (cnt[sl] > 0) {
for (int i = 1; i <= sl; i++) f[i][0] = cnt[i];
for (int i = 1; i <= range; i++)
for (int j = 1; j + (1 << i) - 1 <= sl; j++)
f[j][i] = min(f[j][i - 1], f[j + (1 << (i - 1))][i - 1]);
} else {
for (int i = 1; i <= sl; i++) f[i][0] = rr[i];
for (int i = 1; i <= range; i++)
for (int j = 1; j + (1 << i) - 1 <= sl; j++)
f[j][i] = max(f[j][i - 1], f[j + (1 << (i - 1))][i - 1]);
}
}
int query(int l, int r) {
int range = lg[r - l + 1];
if (cnt[sl] > 0)
return min(f[l][range], f[r - (1 << range) + 1][range]);
else
return max(f[l][range], f[r - (1 << range) + 1][range]);
}
int main() {
scanf("%s", s + 1);
sl = strlen(s + 1);
for (int i = 1; i <= sl; i++) s[i + sl] = s[i];
sl <<= 1;
build_sa();
for (int i = 1; i <= sl; i++) cnt[i] = cnt[i - 1] + ((s[i] == '(') ? 1 : -1);
for (int i = sl; i; i--) rr[i] = rr[i + 1] + ((s[i] == '(') ? 1 : -1);
for (int i = 2; i <= sl; i++)
lg[i] = lg[i - 1] + (i == (1 << (lg[i - 1] + 1)));
make_st();
int l_cnt = 0, r_cnt = 0, ans_pos;
for (int i = 1; i <= sl; i++) {
int p = sa[i];
if (p > sl / 2) continue;
int res = query(p, p + sl / 2 - 1);
if (cnt[sl] > 0) {
if (res - cnt[p - 1] < 0) continue;
r_cnt = abs(cnt[sl] / 2);
ans_pos = p;
break;
} else {
if (res - rr[p + sl / 2] > 0) continue;
l_cnt = abs(cnt[sl] / 2);
ans_pos = p;
break;
}
}
for (int i = 1; i <= l_cnt; i++) printf("(");
for (int i = ans_pos; i <= ans_pos + sl / 2 - 1; i++) printf("%c", s[i]);
for (int i = 1; i <= r_cnt; i++) printf(")");
return 0;
}
|
You are given string s. Your task is to determine if the given string s contains two non-overlapping substrings "AB" and "BA" (the substrings can go in any order).
Input
The only line of input contains a string s of length between 1 and 105 consisting of uppercase Latin letters.
Output
Print "YES" (without the quotes), if string s contains two non-overlapping substrings "AB" and "BA", and "NO" otherwise.
Examples
Input
ABA
Output
NO
Input
BACFAB
Output
YES
Input
AXBYBXA
Output
NO
Note
In the first sample test, despite the fact that there are substrings "AB" and "BA", their occurrences overlap, so the answer is "NO".
In the second sample test there are the following occurrences of the substrings: BACFAB.
In the third sample test there is no substring "AB" nor substring "BA".
|
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
if ((s.contains("AB") && s.replaceFirst("AB", ".").contains("BA")) || s.contains("BA") && s.replaceFirst("BA", ".").contains("AB"))
System.out.println("YES");
else
System.out.println("NO");
sc.close();
}
}
|
You are given a sequence of numbers a1, a2, ..., an, and a number m.
Check if it is possible to choose a non-empty subsequence aij such that the sum of numbers in this subsequence is divisible by m.
Input
The first line contains two numbers, n and m (1 ≤ n ≤ 106, 2 ≤ m ≤ 103) — the size of the original sequence and the number such that sum should be divisible by it.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109).
Output
In the single line print either "YES" (without the quotes) if there exists the sought subsequence, or "NO" (without the quotes), if such subsequence doesn't exist.
Examples
Input
3 5
1 2 3
Output
YES
Input
1 6
5
Output
NO
Input
4 6
3 1 1 3
Output
YES
Input
6 6
5 5 5 5 5 5
Output
YES
Note
In the first sample test you can choose numbers 2 and 3, the sum of which is divisible by 5.
In the second sample test the single non-empty subsequence of numbers is a single number 5. Number 5 is not divisible by 6, that is, the sought subsequence doesn't exist.
In the third sample test you need to choose two numbers 3 on the ends.
In the fourth sample test you can take the whole subsequence.
|
n,x=map(int,input().split())
a=set()
for i in input().split():
i=int(i)
b=set()
for j in a: b.add((i+j)%x)
a|=b
a.add(i%x)
if 0 in a:
print("YES")
break
else:
print("NO")
|
Rooted tree is a connected graph without any simple cycles with one vertex selected as a root. In this problem the vertex number 1 will always serve as a root.
Lowest common ancestor of two vertices u and v is the farthest from the root vertex that lies on both the path from u to the root and on path from v to the root. We will denote it as LCA(u, v).
Sandy had a rooted tree consisting of n vertices that she used to store her nuts. Unfortunately, the underwater storm broke her tree and she doesn't remember all it's edges. She only managed to restore m edges of the initial tree and q triples ai, bi and ci, for which she supposes LCA(ai, bi) = ci.
Help Sandy count the number of trees of size n with vertex 1 as a root, that match all the information she remembered. If she made a mess and there are no such trees then print 0. Two rooted trees are considered to be distinct if there exists an edge that occur in one of them and doesn't occur in the other one.
Input
The first line of the input contains three integers n, m and q (1 ≤ n ≤ 13, 0 ≤ m < n, 0 ≤ q ≤ 100) — the number of vertices, the number of edges and LCA triples remembered by Sandy respectively.
Each of the next m lines contains two integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi) — the numbers of vertices connected by the i-th edge. It's guaranteed that this set of edges is a subset of edges of some tree.
The last q lines contain the triplets of numbers ai, bi, ci (1 ≤ ai, bi, ci ≤ n). Each of these triples define LCA(ai, bi) = ci. It's not guaranteed that there exists a tree that satisfy all the given LCA conditions.
Output
Print a single integer — the number of trees of size n that satisfy all the conditions.
Examples
Input
4 0 0
Output
16
Input
4 0 1
3 4 2
Output
1
Input
3 1 0
1 2
Output
2
Input
3 0 2
2 3 2
2 3 1
Output
0
Input
4 1 2
1 2
2 2 2
3 4 2
Output
1
Note
In the second sample correct answer looks like this:
<image>
In the third sample there are two possible trees:
<image> <image>
In the fourth sample the answer is 0 because the information about LCA is inconsistent.
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, q;
long long dp[15][1 << 15];
pair<long long, long long> con[15];
pair<pair<long long, long long>, long long> lca[105];
void myinit() {
cin >> n >> m >> q;
for (long long i = 1; i <= m; i++) {
long long u, v;
cin >> u >> v;
u--, v--;
con[i] = make_pair(u, v);
}
for (long long i = 1; i <= q; i++) {
long long u, v, w;
cin >> u >> v >> w;
u--, v--, w--;
lca[i] = make_pair(make_pair(u, v), w);
}
}
void dfs(long long root, long long mask) {
if (dp[root][mask]) return;
long long maskll = mask;
mask -= 1 << root;
if (mask == 0) {
dp[root][maskll] = 1;
return;
}
long long least = (mask) - ((mask) & ((mask)-1));
long long newmask = mask, newroot;
for (newmask = mask; newmask != 0; newmask = (newmask - 1) & mask) {
if (!(newmask & least)) continue;
bool was = true;
long long cnt = 0;
for (long long i = 1; i <= m; i++) {
long long u, v;
u = con[i].first;
v = con[i].second;
if (!((maskll) & (1 << u)) || !((maskll) & (1 << v))) continue;
if (u == root) swap(u, v);
if (newmask & (1 << u) && newmask & (1 << v) ||
(maskll - newmask) & (1 << u) && (maskll - newmask) & (1 << v))
continue;
if (v == root && newmask & (1 << u)) {
cnt++;
newroot = u;
continue;
}
was = false;
}
if (cnt > 1 || !was) {
continue;
}
for (long long i = 1; i <= q; i++) {
long long u, v, w;
u = lca[i].first.first;
v = lca[i].first.second;
w = lca[i].second;
if (!((maskll) & (1 << u)) || !((maskll) & (1 << v)) ||
!((maskll) & (1 << w)))
continue;
if (w == root) {
if (u == root || v == root) continue;
if (newmask & (1 << u) && newmask & (1 << v)) {
was = false;
break;
}
} else {
long long t = 0;
if (newmask & (1 << u)) t++;
if (newmask & (1 << v)) t++;
if (newmask & (1 << w)) t++;
if (t != 0 && t != 3) was = false;
}
}
if (was) {
if (cnt == 1) {
dfs(newroot, newmask);
dfs(root, maskll - newmask);
dp[root][maskll] += dp[newroot][newmask] * dp[root][maskll - newmask];
} else {
for (long long i = 0; i < n; i++) {
if (newmask & (1 << i)) {
newroot = i;
dfs(newroot, newmask);
dfs(root, maskll - newmask);
dp[root][maskll] +=
dp[newroot][newmask] * dp[root][maskll - newmask];
}
}
}
}
}
}
int main() {
myinit();
dfs(0, (1 << n) - 1);
cout << dp[0][(1 << n) - 1];
return 0;
}
|
Professor GukiZ has two arrays of integers, a and b. Professor wants to make the sum of the elements in the array a sa as close as possible to the sum of the elements in the array b sb. So he wants to minimize the value v = |sa - sb|.
In one operation professor can swap some element from the array a and some element from the array b. For example if the array a is [5, 1, 3, 2, 4] and the array b is [3, 3, 2] professor can swap the element 5 from the array a and the element 2 from the array b and get the new array a [2, 1, 3, 2, 4] and the new array b [3, 3, 5].
Professor doesn't want to make more than two swaps. Find the minimal value v and some sequence of no more than two swaps that will lead to the such value v. Professor makes swaps one by one, each new swap he makes with the new arrays a and b.
Input
The first line contains integer n (1 ≤ n ≤ 2000) — the number of elements in the array a.
The second line contains n integers ai ( - 109 ≤ ai ≤ 109) — the elements of the array a.
The third line contains integer m (1 ≤ m ≤ 2000) — the number of elements in the array b.
The fourth line contains m integers bj ( - 109 ≤ bj ≤ 109) — the elements of the array b.
Output
In the first line print the minimal value v = |sa - sb| that can be got with no more than two swaps.
The second line should contain the number of swaps k (0 ≤ k ≤ 2).
Each of the next k lines should contain two integers xp, yp (1 ≤ xp ≤ n, 1 ≤ yp ≤ m) — the index of the element in the array a and the index of the element in the array b in the p-th swap.
If there are several optimal solutions print any of them. Print the swaps in order the professor did them.
Examples
Input
5
5 4 3 2 1
4
1 1 1 1
Output
1
2
1 1
4 2
Input
5
1 2 3 4 5
1
15
Output
0
0
Input
5
1 2 3 4 5
4
1 2 3 4
Output
1
1
3 1
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << ": " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << " |";
__f(comma + 1, args...);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n;
long long a[n];
long long in = 0;
long long s1 = 0, s2 = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
s1 += a[i];
}
cin >> m;
long long b[m];
for (long long i = 0; i < m; i++) {
cin >> b[i];
s2 += b[i];
}
vector<pair<long long, long long> > c, d;
c.resize((n * (n - 1)) / 2);
d.resize((m * (m - 1)) / 2);
long long v = LONG_MAX, x1 = -1, x2 = -1, y1 = -1, y2 = -1;
v = abs(s1 - s2);
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
c[in] = {2 * a[i] + 2 * a[j], in};
in++;
}
}
in = 0;
for (long long i = 0; i < m; i++) {
for (long long j = i + 1; j < m; j++) {
d[in] = {2 * b[i] + 2 * b[j], in};
in++;
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (abs(s1 - s2 + 2 * (b[j] - a[i])) <= v) {
v = abs(s1 - s2 + 2 * (b[j] - a[i]));
x1 = i;
y1 = j;
}
}
}
vector<pair<long long, long long> >::iterator it;
sort(d.begin(), d.end());
for (long long i = 0; i < (n * (n - 1)) / 2; i++) {
it = lower_bound(d.begin(), d.end(),
make_pair(s2 - s1 + c[i].first, (long long)-1));
if (it == d.end()) {
in = (m * (m - 1)) / 2 - 1;
} else {
in = it - d.begin();
}
if (in >= 0 && d.size() > 0 &&
abs(s2 - s1 + c[i].first - d[in].first) < v) {
v = abs(s2 - s1 + c[i].first - d[in].first);
x2 = c[i].second;
y2 = d[in].second;
}
if (in - 1 >= 0 && d.size() > 0 &&
abs(s2 - s1 + c[i].first - d[in - 1].first) < v) {
v = abs(s2 - s1 + c[i].first - d[in - 1].first);
x2 = c[i].second;
y2 = d[in - 1].second;
}
}
cout << v << "\n";
if (y1 == -1) {
cout << 0 << "\n";
return 0;
}
if (y2 == -1) {
cout << 1 << "\n";
cout << x1 + 1 << " " << y1 + 1 << "\n";
return 0;
}
in = 0;
bool v1 = 0;
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
if (in == x2) {
x1 = i;
x2 = j;
v1 = 1;
break;
}
in++;
}
if (v1) break;
}
in = 0;
v1 = 0;
for (long long i = 0; i < m; i++) {
for (long long j = i + 1; j < m; j++) {
if (in == y2) {
y1 = i;
y2 = j;
v1 = 1;
break;
}
in++;
}
if (v1) break;
}
cout << 2 << "\n";
cout << x1 + 1 << " " << y1 + 1 << "\n";
cout << x2 + 1 << " " << y2 + 1 << "\n";
return 0;
}
|
Little Artem is fond of dancing. Most of all dances Artem likes rueda — Cuban dance that is danced by pairs of boys and girls forming a circle and dancing together.
More detailed, there are n pairs of boys and girls standing in a circle. Initially, boy number 1 dances with a girl number 1, boy number 2 dances with a girl number 2 and so on. Girls are numbered in the clockwise order. During the dance different moves are announced and all pairs perform this moves. While performing moves boys move along the circle, while girls always stay at their initial position. For the purpose of this problem we consider two different types of moves:
1. Value x and some direction are announced, and all boys move x positions in the corresponding direction.
2. Boys dancing with even-indexed girls swap positions with boys who are dancing with odd-indexed girls. That is the one who was dancing with the girl 1 swaps with the one who was dancing with the girl number 2, while the one who was dancing with girl number 3 swaps with the one who was dancing with the girl number 4 and so one. It's guaranteed that n is even.
Your task is to determine the final position of each boy.
Input
The first line of the input contains two integers n and q (2 ≤ n ≤ 1 000 000, 1 ≤ q ≤ 2 000 000) — the number of couples in the rueda and the number of commands to perform, respectively. It's guaranteed that n is even.
Next q lines contain the descriptions of the commands. Each command has type as the integer 1 or 2 first. Command of the first type is given as x ( - n ≤ x ≤ n), where 0 ≤ x ≤ n means all boys moves x girls in clockwise direction, while - x means all boys move x positions in counter-clockwise direction. There is no other input for commands of the second type.
Output
Output n integers, the i-th of them should be equal to the index of boy the i-th girl is dancing with after performing all q moves.
Examples
Input
6 3
1 2
2
1 2
Output
4 3 6 5 2 1
Input
2 3
1 1
2
1 -2
Output
1 2
Input
4 2
2
1 3
Output
1 4 3 2
|
#include <bits/stdc++.h>
using namespace std;
int b[1100000];
int main() {
int n, q, odd, even, p1, p2;
while (scanf("%d %d", &n, &q) != EOF) {
memset(b, 0, sizeof(b));
odd = 0, even = 1;
while (q--) {
int x, y;
scanf("%d", &x);
if (x == 1) {
scanf("%d", &y);
odd = (odd + y + n) % n;
even = (even + y + n) % n;
} else {
if (odd % 2) {
odd = (odd - 1 + n) % n;
even = (even + 1 + n) % n;
} else {
odd = (odd + 1 + n) % n;
even = (even - 1 + n) % n;
}
}
}
int cnt = 1;
while (cnt <= n) {
b[odd] = cnt++;
b[even] = cnt++;
odd = (odd + 2 + n) % n;
even = (even + 2 + n) % n;
}
for (int i = 0; i < n - 1; i++) printf("%d ", b[i]);
printf("%d\n", b[n - 1]);
}
return 0;
}
|
Little Petya has recently started attending a programming club. Naturally he is facing the problem of choosing a programming language. After long considerations he realized that Java is the best choice. The main argument in favor of choosing Java was that it has a very large integer data type, called BigInteger.
But having attended several classes of the club, Petya realized that not all tasks require using the BigInteger type. It turned out that in some tasks it is much easier to use small data types. That's why a question arises: "Which integer type to use if one wants to store a positive integer n?"
Petya knows only 5 integer types:
1) byte occupies 1 byte and allows you to store numbers from - 128 to 127
2) short occupies 2 bytes and allows you to store numbers from - 32768 to 32767
3) int occupies 4 bytes and allows you to store numbers from - 2147483648 to 2147483647
4) long occupies 8 bytes and allows you to store numbers from - 9223372036854775808 to 9223372036854775807
5) BigInteger can store any integer number, but at that it is not a primitive type, and operations with it are much slower.
For all the types given above the boundary values are included in the value range.
From this list, Petya wants to choose the smallest type that can store a positive integer n. Since BigInteger works much slower, Peter regards it last. Help him.
Input
The first line contains a positive number n. It consists of no more than 100 digits and doesn't contain any leading zeros. The number n can't be represented as an empty string.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Output
Print the first type from the list "byte, short, int, long, BigInteger", that can store the natural number n, in accordance with the data given above.
Examples
Input
127
Output
byte
Input
130
Output
short
Input
123456789101112131415161718192021222324
Output
BigInteger
|
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.math.BigInteger;
public class PetyaAndJava {
void run() {
try {
BufferedReader bfd = new BufferedReader(new InputStreamReader(
System.in));
String[] types = { "byte", "short", "int", "long", "BigInteger" };
String s = bfd.readLine();
BigInteger b = new BigInteger(s);
if(b.compareTo(new BigInteger("127"))<=0 && b.compareTo(new BigInteger("-128"))>=0)
System.out.println(types[0]);
else if(b.compareTo(new BigInteger("32767"))<=0 && b.compareTo(new BigInteger("-32768"))>=0)
System.out.println(types[1]);
else if(b.compareTo(new BigInteger("2147483647"))<=0 && b.compareTo(new BigInteger("-2147483648"))>=0)
System.out.println(types[2]);
else if(b.compareTo(new BigInteger("9223372036854775807"))<=0 && b.compareTo(new BigInteger("-9223372036854775808"))>=0)
System.out.println(types[3]);
else
System.out.println(types[4]);
} catch (Exception e) {
}
}
public static void main(String[] args) {
new PetyaAndJava().run();
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.