input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
Today at the lesson Vitya learned a very interesting function β mex. Mex of a sequence of numbers is the minimum non-negative number that is not present in the sequence as element. For example, mex([4, 33, 0, 1, 1, 5]) = 2 and mex([1, 2, 3]) = 0.
Vitya quickly understood all tasks of the teacher, but can you do the same?
You are given an array consisting of n non-negative integers, and m queries. Each query is characterized by one number x and consists of the following consecutive steps:
* Perform the bitwise addition operation modulo 2 (xor) of each array element with the number x.
* Find mex of the resulting array.
Note that after each query the array changes.
Input
First line contains two integer numbers n and m (1 β€ n, m β€ 3Β·105) β number of elements in array and number of queries.
Next line contains n integer numbers ai (0 β€ ai β€ 3Β·105) β elements of then array.
Each of next m lines contains query β one integer number x (0 β€ x β€ 3Β·105).
Output
For each query print the answer on a separate line.
Examples
Input
2 2
1 3
1
3
Output
1
0
Input
4 3
0 1 5 6
1
2
4
Output
2
0
0
Input
5 4
0 1 5 6 7
1
1
4
5
Output
2
2
0
2
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 19) - 1;
const int MAXN = 600010;
int cnt[MAXN << 2];
int dig[20];
void update(int x, int l, int r, int rt) {
if (l == r) {
cnt[rt] = 1;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
update(x, l, mid, rt << 1);
else
update(x, mid + 1, r, rt << 1 | 1);
cnt[rt] = cnt[rt << 1] + cnt[rt << 1 | 1];
}
int query(int dep, int l, int r, int rt) {
if (l == r) return 0;
int mid = (l + r) >> 1;
if (dig[dep]) {
if (cnt[rt << 1 | 1] == r - mid)
return query(dep - 1, l, mid, rt << 1) + (1 << dep);
return query(dep - 1, mid + 1, r, rt << 1 | 1);
} else {
if (cnt[rt << 1] == mid - l + 1)
return query(dep - 1, mid + 1, r, rt << 1 | 1) + (1 << dep);
return query(dep - 1, l, mid, rt << 1);
}
}
int main() {
int n, m, t;
cin >> n >> m;
for (int i = 0; i < n; i++) scanf("%d", &t), update(t, 0, N, 1);
while (m--) {
scanf("%d", &t);
for (int i = 0; i <= 18; i++)
if (t & 1 << i) dig[i] ^= 1;
printf("%d\n", query(18, 0, N, 1));
}
return 0;
}
|
You are given an array a of size n, and q queries to it. There are queries of two types:
* 1 li ri β perform a cyclic shift of the segment [li, ri] to the right. That is, for every x such that li β€ x < ri new value of ax + 1 becomes equal to old value of ax, and new value of ali becomes equal to old value of ari;
* 2 li ri β reverse the segment [li, ri].
There are m important indices in the array b1, b2, ..., bm. For each i such that 1 β€ i β€ m you have to output the number that will have index bi in the array after all queries are performed.
Input
The first line contains three integer numbers n, q and m (1 β€ n, q β€ 2Β·105, 1 β€ m β€ 100).
The second line contains n integer numbers a1, a2, ..., an (1 β€ ai β€ 109).
Then q lines follow. i-th of them contains three integer numbers ti, li, ri, where ti is the type of i-th query, and [li, ri] is the segment where this query is performed (1 β€ ti β€ 2, 1 β€ li β€ ri β€ n).
The last line contains m integer numbers b1, b2, ..., bm (1 β€ bi β€ n) β important indices of the array.
Output
Print m numbers, i-th of which is equal to the number at index bi after all queries are done.
Example
Input
6 3 5
1 2 3 4 5 6
2 1 3
2 3 6
1 1 6
2 2 1 5 3
Output
3 3 1 5 2
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct node {
node *ch[2] = {0}, *p = 0;
int cnt = 1, val;
bool flip = 0;
node(int val, node* l = 0, node* r = 0) : ch{l, r}, val(val) {}
};
node* update(node* x);
void prop(node* x);
int cnt(node* x) { return x ? x->cnt : 0; }
int dir(node* p, node* x) { return p && p->ch[0] != x; }
void setLink(node* p, node* x, int d) {
if (p) p->ch[d] = x;
if (x) x->p = p;
}
void rotate(node* x, int d) {
if (!x || !x->ch[d]) return;
node *y = x->ch[d], *z = x->p;
setLink(x, y->ch[d ^ 1], d);
setLink(y, x, d ^ 1);
setLink(z, y, dir(z, x));
update(x);
update(y);
}
node* splay(node* x) {
while (x && x->p) {
node *y = x->p, *z = y->p;
int dy = dir(y, x), dz = dir(z, y);
if (!z)
rotate(y, dy);
else if (dy == dz)
rotate(z, dz), rotate(y, dy);
else
rotate(y, dy), rotate(z, dz);
}
return x;
}
node* nodeAt(node* x, int pos) {
if (!x || pos < 0 || pos >= cnt(x)) return 0;
while (prop(x), cnt(x->ch[0]) != pos)
if (pos < cnt(x->ch[0]))
x = x->ch[0];
else
pos -= cnt(x->ch[0]) + 1, x = x->ch[1];
return splay(x);
}
node* merge(node* l, node* r) {
if (!l || !r) return l ?: r;
l = nodeAt(l, cnt(l) - 1);
setLink(l, r, 1);
return update(l);
}
pair<node*, node*> split(node* t, int pos) {
if (pos <= 0 || !t) return {0, t};
if (pos >= cnt(t)) return {t, 0};
node *l = nodeAt(t, pos - 1), *r = l ? l->ch[1] : 0;
if (r) l->ch[1] = r->p = 0;
return {update(l), update(r)};
}
node* insert(node* t, int pos, int val) {
auto [l, r] = split(t, pos);
return update(new node(val, l, r));
}
template <class F>
void each(node* x, F f) {
if (x) prop(x), each(x->ch[0], f), f(x), each(x->ch[1], f);
}
node* update(node* x) {
if (!x) return 0;
x->cnt = 1 + cnt(x->ch[0]) + cnt(x->ch[1]);
setLink(x, x->ch[0], 0), setLink(x, x->ch[1], 1);
return x;
}
void prop(node* x) {
if (!x || !x->flip) return;
if (x->ch[0]) x->ch[0]->flip ^= x->flip;
if (x->ch[1]) x->ch[1]->flip ^= x->flip;
swap(x->ch[0], x->ch[1]);
x->flip = 0;
update(x);
}
void solve() {
int n, q, m;
cin >> n >> q >> m;
node* root = NULL;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
root = insert(root, i, x);
}
for (int i = 0; i < q; i++) {
int t, x, y;
cin >> t >> x >> y;
x--, y--;
node *l, *c, *r;
tie(l, r) = split(root, x);
tie(c, r) = split(r, y - x + 1);
if (t == 1) {
auto [cl, cr] = split(c, cnt(c) - 1);
c = merge(cr, cl);
} else
c->flip ^= 1;
root = merge(l, merge(c, r));
}
vector<int> a(n);
int k = 0;
each(root, [&](node* x) { a[k++] = x->val; });
for (int i = 0; i < m; i++) {
int x;
cin >> x;
cout << a[x - 1] << " ";
}
cout << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
|
A very brave explorer Petya once decided to explore Paris catacombs. Since Petya is not really experienced, his exploration is just walking through the catacombs.
Catacombs consist of several rooms and bidirectional passages between some pairs of them. Some passages can connect a room to itself and since the passages are built on different depths they do not intersect each other. Every minute Petya arbitrary chooses a passage from the room he is currently in and then reaches the room on the other end of the passage in exactly one minute. When he enters a room at minute i, he makes a note in his logbook with number ti:
* If Petya has visited this room before, he writes down the minute he was in this room last time;
* Otherwise, Petya writes down an arbitrary non-negative integer strictly less than current minute i.
Initially, Petya was in one of the rooms at minute 0, he didn't write down number t0.
At some point during his wandering Petya got tired, threw out his logbook and went home. Vasya found his logbook and now he is curious: what is the minimum possible number of rooms in Paris catacombs according to Petya's logbook?
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β then number of notes in Petya's logbook.
The second line contains n non-negative integers t1, t2, ..., tn (0 β€ ti < i) β notes in the logbook.
Output
In the only line print a single integer β the minimum possible number of rooms in Paris catacombs.
Examples
Input
2
0 0
Output
2
Input
5
0 1 0 1 3
Output
3
Note
In the first sample, sequence of rooms Petya visited could be, for example 1 β 1 β 2, 1 β 2 β 1 or 1 β 2 β 3. The minimum possible number of rooms is 2.
In the second sample, the sequence could be 1 β 2 β 3 β 1 β 2 β 1.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
while (t--) {
long long n, i;
cin >> n;
map<long long, long long> mp;
long long s = 0;
for (i = 1; i <= n; i++) {
long long x;
cin >> x;
mp[x]++;
}
for (auto i : mp) {
if (i.first == 0)
s += i.second;
else
s += i.second - 1;
}
cout << s << endl;
}
return 0;
}
|
You are given an unweighted tree with n vertices. Then n - 1 following operations are applied to the tree. A single operation consists of the following steps:
1. choose two leaves;
2. add the length of the simple path between them to the answer;
3. remove one of the chosen leaves from the tree.
Initial answer (before applying operations) is 0. Obviously after n - 1 such operations the tree will consist of a single vertex.
Calculate the maximal possible answer you can achieve, and construct a sequence of operations that allows you to achieve this answer!
Input
The first line contains one integer number n (2 β€ n β€ 2Β·105) β the number of vertices in the tree.
Next n - 1 lines describe the edges of the tree in form ai, bi (1 β€ ai, bi β€ n, ai β bi). It is guaranteed that given graph is a tree.
Output
In the first line print one integer number β maximal possible answer.
In the next n - 1 lines print the operations in order of their applying in format ai, bi, ci, where ai, bi β pair of the leaves that are chosen in the current operation (1 β€ ai, bi β€ n), ci (1 β€ ci β€ n, ci = ai or ci = bi) β choosen leaf that is removed from the tree in the current operation.
See the examples for better understanding.
Examples
Input
3
1 2
1 3
Output
3
2 3 3
2 1 1
Input
5
1 2
1 3
2 4
2 5
Output
9
3 5 5
4 3 3
4 1 1
4 2 2
|
#include <bits/stdc++.h>
using namespace std;
namespace Acc {
const long long N = 2e5 + 10;
basic_string<long long> G[N];
long long n, st, bg, l, ed, f[N], dis[N], ans, pos, tag[N], stk[2][N], cnt;
void dfs(long long u, long long fa, long long d) {
if (dis[u] = st ? d : 0, f[u] = fa, d > l) l = d, pos = u;
for (auto v : G[u])
if (v != fa) dfs(v, u, d + 1);
}
void print(long long u, long long fa, long long d) {
for (auto v : G[u])
if (v != fa) print(v, u, d + 1);
if (!tag[u])
ans += max(dis[u], d), cnt++, stk[0][cnt] = u,
stk[1][cnt] = dis[u] > d ? bg : ed;
else
ans += d;
}
void work() {
cin >> n;
for (long long i = 1, x, y; i < n; i++) cin >> x >> y, G[x] += y, G[y] += x;
dfs(1, 0, 0), bg = pos, st = 1, l = 0, dfs(bg, 0, 0), ed = pos, tag[bg] = 1;
for (long long u = ed; u != bg; u = f[u]) tag[u] = 1;
print(ed, 0, 0), cout << ans << endl;
for (long long i = 1; i <= cnt; i++)
cout << stk[0][i] << ' ' << stk[1][i] << ' ' << stk[0][i] << '\n';
for (long long u = ed; u != bg; u = f[u])
cout << u << ' ' << bg << ' ' << u << '\n';
}
} // namespace Acc
int main() { return Acc::work(), 0; }
|
Everything red frightens Nian the monster. So do red paper and... you, red on Codeforces, potential or real.
Big Banban has got a piece of paper with endless lattice points, where lattice points form squares with the same area. His most favorite closed shape is the circle because of its beauty and simplicity. Once he had obtained this piece of paper, he prepares it for paper-cutting.
<image>
He drew n concentric circles on it and numbered these circles from 1 to n such that the center of each circle is the same lattice point and the radius of the k-th circle is <image> times the length of a lattice edge.
Define the degree of beauty of a lattice point as the summation of the indices of circles such that this lattice point is inside them, or on their bounds. Banban wanted to ask you the total degree of beauty of all the lattice points, but changed his mind.
Defining the total degree of beauty of all the lattice points on a piece of paper with n circles as f(n), you are asked to figure out <image>.
Input
The first line contains one integer m (1 β€ m β€ 1012).
Output
In the first line print one integer representing <image>.
Examples
Input
5
Output
387
Input
233
Output
788243189
Note
A piece of paper with 5 circles is shown in the following.
<image>
There are 5 types of lattice points where the degree of beauty of each red point is 1 + 2 + 3 + 4 + 5 = 15, the degree of beauty of each orange point is 2 + 3 + 4 + 5 = 14, the degree of beauty of each green point is 4 + 5 = 9, the degree of beauty of each blue point is 5 and the degree of beauty of each gray point is 0. Therefore, f(5) = 5Β·15 + 4Β·14 + 4Β·9 + 8Β·5 = 207.
Similarly, f(1) = 5, f(2) = 23, f(3) = 50, f(4) = 102 and consequently <image>.
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int mod = 1e9 + 7, N = 1e6 + 1;
const int rev2 = 500000004, rev3 = 333333336, rev6 = 1ll * rev2 * rev3 % mod;
int s2[N], s4[N], s6[N];
LL q2(LL i) {
i %= mod;
return i * i % mod;
}
LL q4(LL i) {
i %= mod;
return i * i % mod * i % mod * i % mod;
}
LL q6(LL i) {
i %= mod;
return i * i % mod * i % mod * i % mod * i % mod * i % mod;
}
int main() {
for (int i = 1; i < N; i++) {
s2[i] = (s2[i - 1] + q2(i)) % mod;
s4[i] = (s4[i - 1] + q4(i)) % mod;
s6[i] = (s6[i - 1] + q6(i)) % mod;
}
LL n, ans = 0;
cin >> n;
LL nn = n % mod;
for (int i = 1, m = N; 1ll * i * i <= n; i++) {
while (1ll * m * m > n - 1ll * i * i) m--;
ans = (ans +
(nn * (nn + 1) % mod * (nn + 2) % mod + q2(i) * (3 * nn + 4) % mod -
q4(i) * (3 * nn + 6) % mod + mod + 2 * q6(i)) %
mod * (m + 1)) %
mod;
ans =
(ans + (3 * nn + 4 - q2(i) * 2 * (3 * nn + 6) % mod + mod + 6 * q4(i)) %
mod * s2[m]) %
mod;
ans = (ans + (-(3 * nn + 6) % mod + mod + 6 * q2(i)) % mod * s4[m]) % mod;
ans = (ans + 2 * s6[m]) % mod;
}
ans = (ans * 4 % mod + nn * (nn + 1) % mod * (nn + 2) % mod) * rev6 % mod;
cout << ans << endl;
return 0;
}
|
A has a string consisting of some number of lowercase English letters 'a'. He gives it to his friend B who appends some number of letters 'b' to the end of this string. Since both A and B like the characters 'a' and 'b', they have made sure that at this point, at least one 'a' and one 'b' exist in the string.
B now gives this string to C and he appends some number of letters 'c' to the end of the string. However, since C is a good friend of A and B, the number of letters 'c' he appends is equal to the number of 'a' or to the number of 'b' in the string. It is also possible that the number of letters 'c' equals both to the number of letters 'a' and to the number of letters 'b' at the same time.
You have a string in your hands, and you want to check if it is possible to obtain the string in this way or not. If it is possible to obtain the string, print "YES", otherwise print "NO" (without the quotes).
Input
The first and only line consists of a string S ( 1 β€ |S| β€ 5 000 ). It is guaranteed that the string will only consist of the lowercase English letters 'a', 'b', 'c'.
Output
Print "YES" or "NO", according to the condition.
Examples
Input
aaabccc
Output
YES
Input
bbacc
Output
NO
Input
aabc
Output
YES
Note
Consider first example: the number of 'c' is equal to the number of 'a'.
Consider second example: although the number of 'c' is equal to the number of the 'b', the order is not correct.
Consider third example: the number of 'c' is equal to the number of 'b'.
|
import java.io.*;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;
public class Solution {
public static void main(String[] args) throws Exception {
new Solution().go();
}
PrintWriter out;
Reader in;
BufferedReader br;
Solution() throws IOException {
try {
//br = new BufferedReader( new FileReader("input.txt") );
//in = new Reader("input.txt");
in = new Reader("input.txt");
out = new PrintWriter( new BufferedWriter(new FileWriter("output.txt")) );
}
catch (Exception e) {
//br = new BufferedReader( new InputStreamReader( System.in ) );
in = new Reader();
out = new PrintWriter( new BufferedWriter(new OutputStreamWriter(System.out)) );
}
}
void go() throws Exception {
long time = System.currentTimeMillis();
//int t = in.nextInt();
int cs = 1;
int t = 1;
while (t > 0) {
//out.print("Case #" + cs + ": ");
solve();
//out.println();
t--;
cs++;
}
//System.err.println(System.currentTimeMillis() - time);
out.flush();
out.close();
}
int inf = 2000000000;
int mod = 1000000007;
double eps = 0.000000001;
int n;
int m;
void solve() throws IOException {
String s = in.next();
boolean ok = true;
int cntA = 0;
int cntB = 0;
int cntC = 0;
int ind = 0;
while (ind < s.length() && s.charAt(ind) == 'a') {
cntA++;
ind++;
}
while (ind < s.length() && s.charAt(ind) == 'b') {
cntB++;
ind++;
}
while (ind < s.length() && s.charAt(ind) == 'c') {
cntC++;
ind++;
}
ok &= cntA > 0 && cntB > 0 && cntC > 0;
ok &= cntA + cntB + cntC == s.length();
ok &= cntC == cntA || cntC == cntB;
out.println(ok ? "YES" : "NO");
}
class Pair implements Comparable<Pair>{
int a;
int b;
Pair(int a, int b) {
this.a = a;
this.b = b;
}
public int compareTo(Pair p) {
if (a > p.a) return 1;
if (a < p.a) return -1;
//if (b > p.b) return 1;
//if (b < p.b) return -1;
return 0;
}
}
class Item {
int a;
int b;
int c;
Item(int a, int b, int c) {
this.a = a;
this.b = b;
this.c = c;
}
}
class Reader {
BufferedReader br;
StringTokenizer tok;
Reader(String file) throws IOException {
br = new BufferedReader( new FileReader(file) );
}
Reader() throws IOException {
br = new BufferedReader( new InputStreamReader(System.in) );
}
String next() throws IOException {
while (tok == null || !tok.hasMoreElements())
tok = new StringTokenizer(br.readLine());
return tok.nextToken();
}
int nextInt() throws NumberFormatException, IOException {
return Integer.valueOf(next());
}
long nextLong() throws NumberFormatException, IOException {
return Long.valueOf(next());
}
double nextDouble() throws NumberFormatException, IOException {
return Double.valueOf(next());
}
String nextLine() throws IOException {
return br.readLine();
}
}
static class InputReader
{
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public InputReader()
{
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public InputReader(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();
}
}
}
|
Some company is going to hold a fair in Byteland. There are n towns in Byteland and m two-way roads between towns. Of course, you can reach any town from any other town using roads.
There are k types of goods produced in Byteland and every town produces only one type. To hold a fair you have to bring at least s different types of goods. It costs d(u,v) coins to bring goods from town u to town v where d(u,v) is the length of the shortest path from u to v. Length of a path is the number of roads in this path.
The organizers will cover all travel expenses but they can choose the towns to bring goods from. Now they want to calculate minimum expenses to hold a fair in each of n towns.
Input
There are 4 integers n, m, k, s in the first line of input (1 β€ n β€ 10^{5}, 0 β€ m β€ 10^{5}, 1 β€ s β€ k β€ min(n, 100)) β the number of towns, the number of roads, the number of different types of goods, the number of different types of goods necessary to hold a fair.
In the next line there are n integers a_1, a_2, β¦, a_n (1 β€ a_{i} β€ k), where a_i is the type of goods produced in the i-th town. It is guaranteed that all integers between 1 and k occur at least once among integers a_{i}.
In the next m lines roads are described. Each road is described by two integers u v (1 β€ u, v β€ n, u β v) β the towns connected by this road. It is guaranteed that there is no more than one road between every two towns. It is guaranteed that you can go from any town to any other town via roads.
Output
Print n numbers, the i-th of them is the minimum number of coins you need to spend on travel expenses to hold a fair in town i. Separate numbers with spaces.
Examples
Input
5 5 4 3
1 2 4 3 2
1 2
2 3
3 4
4 1
4 5
Output
2 2 2 2 3
Input
7 6 3 2
1 2 3 3 2 2 1
1 2
2 3
3 4
2 5
5 6
6 7
Output
1 1 1 2 2 1 1
Note
Let's look at the first sample.
To hold a fair in town 1 you can bring goods from towns 1 (0 coins), 2 (1 coin) and 4 (1 coin). Total numbers of coins is 2.
Town 2: Goods from towns 2 (0), 1 (1), 3 (1). Sum equals 2.
Town 3: Goods from towns 3 (0), 2 (1), 4 (1). Sum equals 2.
Town 4: Goods from towns 4 (0), 1 (1), 5 (1). Sum equals 2.
Town 5: Goods from towns 5 (0), 4 (1), 3 (2). Sum equals 3.
|
/**
* Created by Baelish on 5/29/2018.
*/
import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.util.stream.Stream;
import static java.lang.Math.*;
public class D {
public static void main(String[] args) throws Exception {
FastReader in = new FastReader(System.in);
PrintWriter pw = new PrintWriter(System.out);
int n = in.nextInt(), m = in.nextInt(), s = in.nextInt(), k = in.nextInt();
int from[] = new int[m], to[] = new int[m];
vis = new int[n+1];
q = new int[n+1];
list = genArrayList(s+1);
cost = new int[n+1][s+1];
int inf = (int)1e8;
for (int i = 1; i <= n; i++) {
int c = in.nextInt();
list[c].add(i);
Arrays.fill(cost[i], inf);
}
for (int i = 0; i < m; i++) {
int u = in.nextInt();
int v = in.nextInt();
from[i] = u; to[i] = v;
}
g = packU(n+1, from, to);
for(int i = 1; i <= s; i++){
bfs(i, n);
}
for(int i = 1; i <= n; i++){
Arrays.sort(cost[i]);
long ans = 0;
for(int j = 0; j < k; j++){
ans += cost[i][j];
}
pw.print(ans+" ");
}
pw.println();
pw.close();
}
static List<Integer> list[];
static int g[][];
static int cost[][];
static int vis[], q[];
static void bfs(int color, int n){
Arrays.fill(vis, -1);
int qs = 0, qe = 0;
for(int i : list[color]){
vis[i] = 0;
q[qe++] = i;
cost[i][color] = 0;
}
while (qs < qe){
int p = q[qs++];
for(int u : g[p]){
if(vis[u] == -1){
vis[u] = vis[p]+1;
cost[u][color] = vis[u];
q[qe++] = u;
}
}
}
}
static int[][] packU(int n, int[] from, int[] to) {
int[][] g = new int[n][];
int[] p = new int[n];
for (int f : from)
p[f]++;
for (int t : to)
p[t]++;
for (int i = 0; i < n; i++)
g[i] = new int[p[i]];
for (int i = 0; i < from.length; i++) {
g[from[i]][--p[from[i]]] = to[i];
g[to[i]][--p[to[i]]] = from[i];
}
return g;
}
public static <E> List<E>[] genArrayList(int size) {
return Stream.generate(ArrayList::new).limit(size).toArray(List[]::new);
}
static void debug(Object... obj) {
System.err.println(Arrays.deepToString(obj));
}
static class FastReader {
InputStream is;
private byte[] inbuf = new byte[1024];
private int lenbuf = 0, ptrbuf = 0;
static final int ints[] = new int[128];
public FastReader(InputStream is) {
for (int i = '0'; i <= '9'; i++) ints[i] = i - '0';
this.is = is;
}
public int readByte() {
if (lenbuf == -1) throw new InputMismatchException();
if (ptrbuf >= lenbuf) {
ptrbuf = 0;
try {
lenbuf = is.read(inbuf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0) return -1;
}
return inbuf[ptrbuf++];
}
public boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
public int skip() {
int b;
while ((b = readByte()) != -1 && isSpaceChar(b)) ;
return b;
}
public String next() {
int b = skip();
StringBuilder sb = new StringBuilder();
while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
int num = 0, b;
boolean minus = false;
while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
if (b == '-') {
minus = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') {
num = (num << 3) + (num << 1) + ints[b];
} else {
return minus ? -num : num;
}
b = readByte();
}
}
public long nextLong() {
long num = 0;
int b;
boolean minus = false;
while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
if (b == '-') {
minus = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') {
num = (num << 3) + (num << 1) + ints[b];
} else {
return minus ? -num : num;
}
b = readByte();
}
}
public double nextDouble() {
return Double.parseDouble(next());
}
/* public char nextChar() {
return (char)skip();
}*/
public char[] next(int n) {
char[] buf = new char[n];
int b = skip(), p = 0;
while (p < n && !(isSpaceChar(b))) {
buf[p++] = (char) b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
/*private char buff[] = new char[1005];
public char[] nextCharArray(){
int b = skip(), p = 0;
while(!(isSpaceChar(b))){
buff[p++] = (char)b;
b = readByte();
}
return Arrays.copyOf(buff, p);
}*/
}
}
|
Bob has just learned bit manipulation and is very excited about it. He goes to his friend Alice to show off his skills who is new to programming, and thus Bob challenges Alice to solve the following problem. Given two positive integers L and R, find L ^ (L+1) ^ (L+2) ^ ....... ^ (R-1) ^ R.
Alice needs to answer k such queries.
Since Alice is new to programming, she seeks your help.
NOTE: Here a^b represents XOR of 2 numbers a and b.
Input Format :
The first line contains a number k, the number of queries.
Each of the next k lines, contain two positive integers L and R.
Output Format:
For each query, output a single line, the required answer.
Constraints:
1 β€ k β€ 10^5
1 β€ L β€ R β€ 10^9
SAMPLE INPUT
2
2 3
3 5
SAMPLE OUTPUT
1
2
Explanation
For the first query, 2^3 = 1
For the second query, 3^4^5 = 2
|
def f(a):
res=[]
res.append(a)
res.append(1)
res.append(a+1)
res.append(0)
return res[a%4]
if __name__=='__main__':
T = int(raw_input())
for i in range(T):
M,N=map(int,raw_input().split())
print f(N)^f(M-1)
|
In Byteland,people don't use standard e-mail services like gmail,yahoo-mail etc.Instead they have their own e-mail service know as Bytemail.In Bytemail, encryption of e-mails is done using a special algorithm known as Bytecryption algorithm.It works as follows:
1)All the text is converted into lower-case alphabets only('a'-'z') using some algorithm Q .
2)Now , for each string str(say) in the text,the Bytecryption algorithms encrypts the string as follows:
Start with the given string str and an empty string k. The algorithm runs in multiple steps.For each step,str and k are modified as follows:
a) If the length of str is odd, the middle character of s is added to the end of k, and then deleted from str.
b)If the length of str is even, the two characters in the middle of str are compared. The smaller one of them (either one in case of a tie) is added to the end of k, and then deleted from str.
If after some step the string str is empty, the algorithm terminates. The output of the algorithm is the final string t.
Now your job is to encrypt a string str and output it.
Input
The first line of input contains T,the number of test cases.The next T lines contain a string str which you need to encrypt.
Output
Output T lines each corresponding to the encrypted string.
Constraints
1)Size of the string str β€ 50 and β₯1
2)Each character in str is a lowercase letter('a'-'z').
SAMPLE INPUT
2
aaaaaaaa
adappadsdsdas
SAMPLE OUTPUT
aaaaaaaa
dasdppsadadas
|
#Sudhanshu Patel
if __name__=='__main__':
t=int(raw_input())
for i in range(t):
st=raw_input()
st=st.lower()
r=''
while(st!=''):
l=len(st)
if l%2!=0:
r=r+st[l/2]
st=st[0:l/2]+st[(l/2)+1:]
else:
x=l/2
y=x-1
if st[x]<=st[y]:
r=r+st[x]
r=r+st[y]
st=st[:y]+st[x+1:]
else:
r=r+st[y]
r=r+st[x]
st=st[:y]+st[x+1:]
print r
|
You'll be given an array A of N integers as input. For each element of the array A[i], print A[i]-1.
Input:
There will be N+1 iines of input each consisting of a single integer.
Integer in first line denotes N
For the following N lines the integer in i^{th} line denotes the integer A[i-1]
Output:
For each element of the array A[i], print A[i]-1 in a new line.
Constraints:
1 β€ N β€ 10
1 β€ A[i] β€ 10
SAMPLE INPUT
2
2
6
SAMPLE OUTPUT
1
5
|
totalCases = int(raw_input())
for i in xrange(totalCases):
print int(raw_input()) -1
|
There is a special game played in remote part of Rajasthan, where all people assemble with their all wealth and try to earn more wealth on the account of their current wealth.
Suppose you are also a part of this game.
The game is like, there are N people playing the game where everyone has its wealth. You are given with the information about the wealth of all other people.
There is also a M number of groups, where each person is assigned a group id and the top half of the group in terms of wealth move forward to the next level of the game.
The group id is assigned by first arranging all the persons in decreasing order their wealth, like person with highest wealth get group id 1 ,the next one 2 and similarly upto M then again the cycle repeats.
You wish to win in your group, so you wonder how many more wealthier people you have in your group. Print the number of people in your group who have more wealth than you.
Input:
First line of input contains an integer T which denoted the number of test cases, each test case contains two lines of input where first line of test case contains two space separated integers nR nG where nR is the number of people and nG is the number of groups available for assignment.
The next line of test case contains nR space separated integers wealth[i], which represents the wealth of ith person playing the game where the first number represents your own wealth.
Output:
For each test case output the number of wealthier person than you in your own group in a line.
Constraint:
1 β€ T β€ 10,000
1 β€ nG β€ nR β€ 100
β€ wealth[i] β€ 5000
SAMPLE INPUT
3
12 11
1640 3997 4133 4282 3130 3938 4628 1138 4474 4534 2218 1293
1 1
2491
15 6
1242 3342 4797 4252 811 4955 76 4298 3753 1104 168 17 2364 1207 4764
SAMPLE OUTPUT
0
0
1
|
for i in range(input()):
s=raw_input().split(" ")
t=raw_input().split(" ")
l=[];
for k in t:
z=str(k)+".0"
l.append(int(float(z)))
l.sort()
l.reverse()
c=l.index(int(t[0]))
l2=[]
l2.append(int(t[0]))
cd=c
while True:
cd=cd-int(s[1])
if cd<0:
break
l2.append(l[cd])
cd=c
while True:
cd=cd+int(s[1])
if cd>len(l)-1:
break
l2.append(l[cd])
l2.sort()
l2.reverse()
print l2.index(int(t[0]))
|
Pradeep Khicchar , a very influential ,dominating ,smart and definitely an intelligent guy, is very eager to get his patent on his first project which he is about to complete. Only assistance that he needs from his friend Amit Chahal from IT department is the only thing that his friend know (:p :P) i.e. coding .
But his friend is very lazy and do nothing until he is forced to do so . So khicchar plans of a strategy to make him work , and only threatening he knows is "Hostel Out Kara dunga , being a mess member and beyond ;)"..
Now his friend is in great trouble .So , he is really men at work .No sooner he start reading the problem ,he realize it is nothing but a cup of tea, ...
Khicchar want to select the largest number that can completely divide four canal-numbers selected from the large number of canals that flows in his field and one motor-number selected from his small collection of motors.
Now as I told you earlier his friends is quite lazy so he ask you to write code on his behalf. He is good at giving as well . He will give you 100 points as a reward.
Input : First line of input will contain an integer t, number of test cases. Description of t test cases follow.
Each test cases will consist of 5 numbers (a,b,c,d,e) in five different lines. where a,b,c,d are the canal numbers and e is the motor number.
Output : Print the answer for each testcase in a new line.
Constraints :
1 β€ t β€ 20
1 β€ a,b,c,d β€ 10^250
1 β€ e β€ 40000
*Problem Setter :Faraz Ghazi
Problem Tester :Abhishek Azad *
SAMPLE INPUT
1
10
20
30
10
5
SAMPLE OUTPUT
5
|
def gcd(a,b):
if b==0:
return a
else:
return gcd(b,a%b)
for _ in xrange(input()):
l=[]
for i in xrange(5):
l.append(int(raw_input()))
print gcd(l[0],gcd(l[1],gcd(l[2],gcd(l[3],l[4]))))
|
As we all know that power sets of any set are formed by taking i elements (where i is from 1 to n) and then random shuffling them like this power set of {1,2,3} are {EMPTY SET},{1},{2},{3},{1,2}{1,3}{2,3}{1,2,3} .
Now we have a MODIfied POWER SET which contains only those subsets which have consecutive elements from set and does not contains an empty set.Suppse in above example {1,2,3} number of MODIfied POWER SETS would be 6 we will eliminate {1,3} from power set since 1 and 3 are now consecutive numbers in the set(they are seperated by 2) & secondly by deleting empty set from it.Now you have knowledge of power set .Now,MANAN wants you to solve a simple problems stated as:_
Given a string now we have to form a SET(Lets make it clear again we have to form a SET) from this string.And output the number of MODIfied POWER SETs of that SET.
NOTE:-
Please note that if the set if {1,3,2} then MODIfied Power sets will be {1},{3},{2},{1,3},{3,2},{1,3,2} as 1 and 2 are not consecutive elements from the set.
INPUT FORMAT:-
First Line of input contains an integer t denoting number of test cases.
Each of the test case would contain a string containing numerals & alphabets.
OUTPUT FORMAT:-
Output for each test case is a single value denoting number of MODIfied POWER SETS.
Constraints:-
1 β€ t β€ 100
1 β€ |length of string| β€ 10^6SAMPLE INPUT
2
abcde
abc
SAMPLE OUTPUT
15
6
|
from collections import OrderedDict
t=input()
while t:
t-=1
s=raw_input()
l= list(OrderedDict.fromkeys(s))
l=len(l)
print (l*(l+1))/2
|
Panda had recently learnt about Bit manipulation and logic gates,now he is very excited about it.One day he came across a very interesting question: Given two numbers,xor them and then in resulting number find the number of set bits.If number of set bits are even then print "YES" otherwise "NO".As he is unable to solve it,he is asking you for help.
Input:
First line of input contains T the number of test cases,then next T lines contains two space separated integers A and B.
Output:
for each testcase print "YES" if number of set bits are even otherwise "NO" in new line.
Constraints:
1 β€ T β€ 500
1 β€ A,B β€ 10^9
SAMPLE INPUT
2
6 5
10 11
SAMPLE OUTPUT
YES
NO
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
T=long(raw_input(''))
while(T>0):
[A,B]=map(long,raw_input().split(' '))
C=A^B
count=0
while C>0:
C-=C&(-1*C)
count+=1
if(count&1):
print "NO"
else:
print "YES"
T-=1
|
To round an integer a, it is customary to round to some multiple of a power of 10, and you will round it accordingly. This time, rules have changed. Given an int n and an int b, round n to the nearest value which is a multiple of b.
If n is exactly halfway between two multiples of b, print the larger value.
INPUT
First line of input gives T, the number of test cases.
T lines follow, each line contains n and b.
OUTPUT
For every test case, round n to the nearest value which is a multiple of b.
CONSTRAINTS
n will be between 1 and 1000000, inclusive.
b will be between 2 and 500, inclusive.
1 β€ T β€ 50
SAMPLE INPUT
2
5 10
100 3
SAMPLE OUTPUT
10
99
Explanation
CASE 1: We round up because 5 is an equal distance between 0 and 10.
CASE 2: 100 is closer to 99 than 102.
|
T = int(raw_input())
for i in range(T):
n,b = (raw_input()).split()
n,b = int(n), int(b)
div_a = (n//b)*b
div_b = div_a + b
if(n - div_a == div_b - n) :
print div_b
elif(n - div_a < div_b - n) :
print div_a
else :
print div_b
|
Dark completed with studying Strings last night and trying to solve the problem of primes numbers from last three months but did not succeed every time he preferred to ask your help and same goes this time.
He likes to play a game with PRIMES AND STRINGS and he named the game as "PRIME ASCII CHARACTERS".
The rules are as simple as finding the primes.
He wants you to read a string and delete all the characters whose ASCII VALUES is found to be a prime number.
Input:
The first line contains T, the number of test cases.
Followed by T lines each contains a single string 'S'.
Output:
For every test case print the string by removing the PRIME ASCII CHARACTERS.
print "NULL" If all the characters of a string are prime ascii characters.
Constraints:
1 β€ T β€ 10000
1 β€ |S| β€ 100000
Author : Darshak Mehta
Note: String contains only Alphabets both UPPER & LOWER CASES.
SAMPLE INPUT
4
MEHTA
Mehta
HELLO
hello
SAMPLE OUTPUT
MEHTA
Mht
HELL
hllo
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
def isPrime(n):
for i in range(2,n):
if n% i == 0:
return 1
return 0
n = int(raw_input())
i=0
str = []
out = []
while i < n:
str.append(raw_input())
i+=1
for s in str:
temp=""
for c in s:
if isPrime(ord(c)) == 1:
temp+=c
out.append(temp)
for i in out:
if i:
print i
else:
print "NULL"
|
Admin is provided with infinite supply of Unusual blocks and now he has being assigned the task to fill the rectangular floor(completely) of Area A with one of these Unusual blocks.
The Property of Unusual Blocks being :-
Property 1 :- Both of it's dimensions are integers
Property 2 :- When both of it's dimensions are even then they must be same.
Let say , the dimension of Unusual block can be 8X8 but not 8X4.
Help Admin to find how many different possible choices he has for a given area(A).
Note: The block with mXn dimension is same as that of nXm, So they must be counted as one.
INPUT:
First line contains the number of test-cases T.(1 β€ T β€ 10^5)
Following "T" lines will contain a single integer A (1 β€ A β€ 10^5) .
OUTPUT:
Output the different possible choices in which he can choose a Unusual block size that will cover the exact area(A) for each test-case in separate line.
SAMPLE INPUT
1
4
SAMPLE OUTPUT
2
Explanation
The possible ways are 1x4 (or 4x1 , since both are same) and 2x2.
|
def s(n):
x=[]
c=0
for i in xrange(1,int(n**.5)+1):
if n%i==0:
if i%2==0 and (n/i)%2==0:
if i==n/i:
c+=1
else:
c+=1
return c
for _ in xrange(input()):
n=input()
print s(n)
|
Letβs take a prime P = 200\,003. You are given N integers A_1, A_2, \ldots, A_N. Find the sum of ((A_i \cdot A_j) \bmod P) over all N \cdot (N-1) / 2 unordered pairs of elements (i < j).
Please note that the sum isn't computed modulo P.
Constraints
* 2 \leq N \leq 200\,000
* 0 \leq A_i < P = 200\,003
* All values in input are integers.
Input
Input is given from Standard Input in the following format.
N
A_1 A_2 \cdots A_N
Output
Print one integer β the sum over ((A_i \cdot A_j) \bmod P).
Examples
Input
4
2019 0 2020 200002
Output
474287
Input
5
1 1 2 2 100000
Output
600013
|
#include<bits/stdc++.h>
#define LL long long
using namespace std;
const int mod=200003,G=5,N=8e5+50;
const double pi=acos(-1);
int n,id[N],r[N],lim=1,val[N];LL ans;
struct node{
double x,y;
node friend operator +(node a,node b){return node{a.x+b.x,a.y+b.y};}
node friend operator -(node a,node b){return node{a.x-b.x,a.y-b.y};}
node friend operator *(node a,node b){return node{a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x};}
}c[N];
void FFT(node *a,int n,int op){
for(int i=0;i<n;i++)r[i]=r[i>>1]>>1^(i&1?n>>1:0);
for(int i=0;i<n;i++)if(i<r[i])swap(a[i],a[r[i]]);
for(int i=1;i<n;i<<=1){
node Wn=node{cos(pi/i),sin(pi/i)};
for(int j=0;j<n;j+=i<<1){
node w=node{1,0};
for(int k=0;k<i;k++,w=w*Wn){
node x=a[j+k],y=a[i+j+k]*w;
a[j+k]=x+y;a[i+j+k]=x-y;
}
}
}
if(op==-1){
reverse(a+1,a+n);
for(int i=0;i<n;i++)a[i].x/=n;
}
}
int power(int x,int y){
int z=1;
for(;y;y>>=1,x=1ll*x*x%mod)if(y&1)z=1ll*z*x%mod;
return z;
}
int main(){
for(int i=1,j=0;j<mod-1;i=1ll*i*G%mod,j++)id[i]=j,val[j]=i;
scanf("%d",&n);
for(int i=1,x;i<=n;i++){
scanf("%d",&x);
ans-=1ll*x*x%mod;
if(x)c[id[x]].x++;
}
while(lim<mod*2)lim<<=1;
FFT(c,lim,1);
for(int i=0;i<lim;i++)c[i]=c[i]*c[i];
FFT(c,lim,-1);
for(int i=0;i<mod*2;i++)
ans+=(LL)(c[i].x+0.5)*val[i%(mod-1)];
cout<<ans/2;
return 0;
}
|
Takahashi has decided to work on K days of his choice from the N days starting with tomorrow.
You are given an integer C and a string S. Takahashi will choose his workdays as follows:
* After working for a day, he will refrain from working on the subsequent C days.
* If the i-th character of S is `x`, he will not work on Day i, where Day 1 is tomorrow, Day 2 is the day after tomorrow, and so on.
Find all days on which Takahashi is bound to work.
Constraints
* 1 \leq N \leq 2 \times 10^5
* 1 \leq K \leq N
* 0 \leq C \leq N
* The length of S is N.
* Each character of S is `o` or `x`.
* Takahashi can choose his workdays so that the conditions in Problem Statement are satisfied.
Input
Input is given from Standard Input in the following format:
N K C
S
Output
Print all days on which Takahashi is bound to work in ascending order, one per line.
Examples
Input
11 3 2
ooxxxoxxxoo
Output
6
Input
5 2 3
ooxoo
Output
1
5
Input
5 1 0
ooooo
Output
Input
16 4 3
ooxxoxoxxxoxoxxo
Output
11
16
|
n,k,c=map(int, input().split())
s = input()
leftmost = []
cursor = 0
for _ in range(k):
while s[cursor] == 'x':
cursor += 1
leftmost.append(cursor)
cursor += c+1
rightmost = []
cursor = n-1
for _ in range(k):
while s[cursor] == 'x':
cursor -= 1
rightmost.append(cursor)
cursor -= c+1
rightmost.reverse()
for l, r in zip(leftmost, rightmost):
if l == r:
print(l+1)
#print(leftmost, rightmost)
|
Given are a sequence of N positive integers A_1, A_2, \ldots, A_N, and a positive integer K.
Find the number of non-empty contiguous subsequences in A such that the remainder when dividing the sum of its elements by K is equal to the number of its elements. We consider two subsequences different if they are taken from different positions, even if they are equal sequences.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2\times 10^5
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N K
A_1 A_2 \cdots A_N
Output
Print the number of subsequences that satisfy the condition.
Examples
Input
5 4
1 4 2 3 5
Output
4
Input
8 4
4 2 4 2 4 2 4 2
Output
7
Input
10 7
14 15 92 65 35 89 79 32 38 46
Output
8
|
from collections import defaultdict
def gets():
return list(map(int, input().split()))
N, K = gets()
A = gets()
S = [0] * (N + 1)
for i in range(N):
S[i + 1] = (S[i] + A[i] - 1) % K
cnt = defaultdict(int)
ans = 0
cnt[0] += 1
for i in range(1, N+1):
if i - K >= 0:
cnt[S[i - K]] -= 1
ans += cnt[S[i]]
cnt[S[i]] += 1
print(ans)
|
We have a permutation p = {p_1,\ p_2,\ ...,\ p_n} of {1,\ 2,\ ...,\ n}.
Print the number of elements p_i (1 < i < n) that satisfy the following condition:
* p_i is the second smallest number among the three numbers p_{i - 1}, p_i, and p_{i + 1}.
Constraints
* All values in input are integers.
* 3 \leq n \leq 20
* p is a permutation of {1,\ 2,\ ...,\ n}.
Input
Input is given from Standard Input in the following format:
n
p_1 p_2 ... p_n
Output
Print the number of elements p_i (1 < i < n) that satisfy the condition.
Examples
Input
5
1 3 5 4 2
Output
2
Input
9
9 6 3 2 5 8 7 4 1
Output
5
|
N = int(input())
p = list(map(int,input().split()))
s = 0
for i in range(1,N-1):
s += p[i-1] < p[i] < p[i+1] or p[i-1] > p[i] > p[i+1]
print(s)
|
Determine if we can choose K different integers between 1 and N (inclusive) so that no two of them differ by 1.
Constraints
* 1\leq N,K\leq 100
* N and K are integers.
Input
Input is given from Standard Input in the following format:
N K
Output
If we can choose K integers as above, print `YES`; otherwise, print `NO`.
Examples
Input
3 2
Output
YES
Input
5 5
Output
NO
Input
31 10
Output
YES
Input
10 90
Output
NO
|
N, K = list(map(int, input().split(" ")))
print("YES") if 2*K-1 <= N else print("NO")
|
There is an N-car train.
You are given an integer i. Find the value of j such that the following statement is true: "the i-th car from the front of the train is the j-th car from the back."
Constraints
* 1 \leq N \leq 100
* 1 \leq i \leq N
Input
Input is given from Standard Input in the following format:
N i
Output
Print the answer.
Examples
Input
4 2
Output
3
Input
1 1
Output
1
Input
15 11
Output
5
|
n,i = map(int,input().split())
ans = n+1-i
print(ans)
|
Takahashi has an N \times M grid, with N horizontal rows and M vertical columns. Determine if we can place A 1 \times 2 tiles (1 vertical, 2 horizontal) and B 2 \times 1 tiles (2 vertical, 1 horizontal) satisfying the following conditions, and construct one arrangement of the tiles if it is possible:
* All the tiles must be placed on the grid.
* Tiles must not stick out of the grid, and no two different tiles may intersect.
* Neither the grid nor the tiles may be rotated.
* Every tile completely covers exactly two squares.
Constraints
* 1 \leq N,M \leq 1000
* 0 \leq A,B \leq 500000
* N, M, A and B are integers.
Input
Input is given from Standard Input in the following format:
N M A B
Output
If it is impossible to place all the tiles, print `NO`. Otherwise, print the following:
YES
c_{11}...c_{1M}
:
c_{N1}...c_{NM}
Here, c_{ij} must be one of the following characters: `.`, `<`, `>`, `^` and `v`. Represent an arrangement by using each of these characters as follows:
* When c_{ij} is `.`, it indicates that the square at the i-th row and j-th column is empty;
* When c_{ij} is `<`, it indicates that the square at the i-th row and j-th column is covered by the left half of a 1 \times 2 tile;
* When c_{ij} is `>`, it indicates that the square at the i-th row and j-th column is covered by the right half of a 1 \times 2 tile;
* When c_{ij} is `^`, it indicates that the square at the i-th row and j-th column is covered by the top half of a 2 \times 1 tile;
* When c_{ij} is `v`, it indicates that the square at the i-th row and j-th column is covered by the bottom half of a 2 \times 1 tile.
Examples
Input
3 4 4 2
Output
YES
<><>
^<>^
v<>v
Input
4 5 5 3
Output
YES
<>..^
^.<>v
v<>.^
<><>v
Input
7 9 20 20
Output
NO
|
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef complex<double> point;
#define xx real()
#define yy imag()
#define REP(i, a, b) for(int i = (a); i < (int)(b); i++)
#define REPN(i, a, b) for(int i = (a); i <= (int)(b); i++)
#define FA(it, x) for(__typeof((x).begin()) it = (x).begin(); it != (x).end(); it++)
#define SZ(x) (int)(x).size()
#define BE(x) (x).begin(), (x).end()
#define SORT(x) sort(BE(x))
#define _1 first
#define _2 second
#define x1 gray_cat_x1
#define y1 gray_cat_y1
template<class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define file "I1"
const double EPS = 1e-9;
const double PI = acos(-1.);
const int INF = 1e9;
const ll MOD = 1e9 + 7;
const int MAXN = 1e3 + 5;
char c[MAXN][MAXN];
void solve(){
int n, m, a, b;
scanf("%d%d%d%d", &n, &m, &a, &b);
REP(i, 0, n) {
REP(j, 0, m) {
c[i][j] = '.';
}
}
int n1 = n, m1 = m;
if (n % 2 == 1) {
REP(i, 0, m / 2) {
if (a == 0) {
break;
}
c[n - 1][2 * i] = '<';
c[n - 1][2 * i + 1] = '>';
a--;
}
n--;
}
if (m % 2 == 1) {
REP(i, 0, n / 2) {
if (b == 0) {
break;
}
c[2 * i][m - 1] = '^';
c[2 * i + 1][m - 1] = 'v';
b--;
}
m--;
}
if (2 * (a + b) > n * m) {
printf("NO\n");
return;
}
if (2 * (a + b) == n * m && a % 2 == 1) {
if (n1 % 2 == 1 && m1 % 2 == 1) {
c[n1 - 1][m1 - 1] = 'v';
c[n1 - 2][m1 - 1] = '^';
c[n1 - 3][m1 - 1] = '>';
c[n1 - 3][m1 - 2] = '<';
c[n1 - 2][m1 - 3] = 'v';
c[n1 - 3][m1 - 3] = '^';
a--;
b--;
} else {
printf("NO\n");
return;
}
}
REP(i, 0, n / 2) {
REP(j, 0, m / 2) {
if (a > 0) {
c[2 * i][2 * j] = '<';
c[2 * i][2 * j + 1] = '>';
a--;
if (a > 0) {
c[2 * i + 1][2 * j] = '<';
c[2 * i + 1][2 * j + 1] = '>';
a--;
}
} else if (b > 0) {
c[2 * i][2 * j] = '^';
c[2 * i + 1][2 * j] = 'v';
b--;
if (b > 0) {
c[2 * i][2 * j + 1] = '^';
c[2 * i + 1][2 * j + 1] = 'v';
b--;
}
}
}
}
printf("YES\n");
REP(i, 0, n1) {
printf("%s\n", c[i]);
}
}
int main(){
//freopen(file".in", "r", stdin); freopen(file".out", "w", stdout);
int t = 1;
//cin >> t;
while(t--){
solve();
}
}
|
Snuke prepared 6 problems for a upcoming programming contest. For each of those problems, Rng judged whether it can be used in the contest or not.
You are given a string S of length 6. If the i-th character of s is `1`, it means that the i-th problem prepared by Snuke is accepted to be used; `0` means that the problem is not accepted.
How many problems prepared by Snuke are accepted to be used in the contest?
Constraints
* The length of S is 6.
* S consists of `0` and `1`.
Inputs
Input is given from Standard Input in the following format:
S
Outputs
Print the number of problems prepared by Snuke that are accepted to be used in the contest.
Examples
Input
111100
Output
4
Input
001001
Output
2
Input
000000
Output
0
|
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
cout<<count(s.begin(),s.end(),'1');
}
|
You are given an array A of length N. Your task is to divide it into several contiguous subarrays. Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order. At least how many subarrays do you need to divide A into?
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* Each A_i is an integer.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible number of subarrays after division of A.
Examples
Input
6
1 2 3 2 2 1
Output
2
Input
9
1 2 1 2 1 2 1 2 1
Output
5
Input
7
1 2 3 2 1 999999999 1000000000
Output
3
|
N = int(input())
A = list(map(int, input().split()))
sgn = 0
answer = 1
for i in range(N-1):
cur = A[i+1] - A[i]
if cur * sgn < 0:
answer += 1
sgn = 0
continue
if cur != 0:
sgn = cur
print(answer)
|
There is an undirected connected graph with N vertices numbered 1 through N. The lengths of all edges in this graph are 1. It is known that for each i (1β¦iβ¦N), the distance between vertex 1 and vertex i is A_i, and the distance between vertex 2 and vertex i is B_i. Determine whether there exists such a graph. If it exists, find the minimum possible number of edges in it.
Constraints
* 2β¦Nβ¦10^5
* 0β¦A_i,B_iβ¦N-1
Input
The input is given from Standard Input in the following format:
N
A_1 B_1
A_2 B_2
:
A_N B_N
Output
If there exists a graph satisfying the conditions, print the minimum possible number of edges in such a graph. Otherwise, print `-1`.
Examples
Input
4
0 1
1 0
1 1
2 1
Output
4
Input
3
0 1
1 0
2 2
Output
-1
|
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <cmath>
#include <cassert>
#include <functional>
#include <numeric>
#include <limits>
using namespace std;
#define all(c) (c).begin(), (c).end()
#define iter(c) __typeof((c).begin())
#define cpresent(c, e) (find(all(c), (e)) != (c).end())
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define tr(c, i) for (iter(c) i = (c).begin(); i != (c).end(); ++i)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
int N;
int A[100010], B[100010];
int solve() {
try {
rep (i, N) {
if ((A[i] == 0) != (i == 0)) throw 0;
if ((B[i] == 0) != (i == 1)) throw 0;
}
int D = B[0];
if (A[1] != D) throw 0;
map<pair<int, int>, int> cnt;
rep (i, N) cnt[mp(A[i], B[i])] += 1;
map<int, map<int, int>> taba;
rep (i, N) {
taba[A[i] + B[i]][A[i]] += 1;
}
for (int d = 0; d < D; ++d) {
if (taba.count(d)) throw 0;
}
int ans = N - 1;
for (auto &i : taba) {
int d = i.first;
map<int, int> &m = i.second;
int request = 0; // request from left
for (const auto &j : m) {
int a = j.first, b = d - a, c = j.second;
if (a > 0 && cnt[mp(a - 1, b - 1)] + cnt[mp(a - 1, b)] + cnt[mp(a - 1, b + 1)] == 0) {
throw 0;
}
int hige;
if (cnt[mp(a - 1, b - 1)]) hige = max(0, c - request);
else hige = 0;
c -= hige;
ans += max(0, request - c);
if (cnt[(mp(a + 1, b - 1))] > 0) {
request = c;
} else if (b > 0) {
if (cnt[mp(a - 1, b - 1)] + cnt[mp(a, b - 1)] + cnt[mp(a + 1, b - 1)] == 0) {
throw 0;
}
ans += c;
request = 0;
}
}
}
return ans;
} catch (...) {
return -1;
}
}
int main() {
scanf("%d", &N);
rep (i, N) {
scanf("%d%d", &A[i], &B[i]);
}
int ans1 = solve();
rep (i, N) swap(A[i], B[i]);
swap(A[0], A[1]);
swap(B[0], B[1]);
int ans2 = solve();
assert(ans1 == ans2);
printf("%d\n", ans1);
return 0;
}
|
Let's play Amidakuji.
In the following example, there are five vertical lines and four horizontal lines. The horizontal lines can intersect (jump across) the vertical lines.
<image>
In the starting points (top of the figure), numbers are assigned to vertical lines in ascending order from left to right. At the first step, 2 and 4 are swaped by the first horizontal line which connects second and fourth vertical lines (we call this operation (2, 4)). Likewise, we perform (3, 5), (1, 2) and (3, 4), then obtain "4 1 2 5 3" in the bottom.
Your task is to write a program which reads the number of vertical lines w and configurations of horizontal lines and prints the final state of the Amidakuji. In the starting pints, numbers 1, 2, 3, ..., w are assigne to the vertical lines from left to right.
Hint
Try it. -->
Input
w
n
a1,b1
a2,b2
.
.
an,bn
w (w β€ 30) is the number of vertical lines. n (n β€ 30) is the number of horizontal lines. A pair of two integers ai and bi delimited by a comma represents the i-th horizontal line.
Output
The number which should be under the 1st (leftmost) vertical line
The number which should be under the 2nd vertical line
:
The number which should be under the w-th vertical line
Example
Input
5
4
2,4
3,5
1,2
3,4
Output
4
1
2
5
3
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int w = sc.nextInt();
int n = sc.nextInt();
int[] values = new int[w];
for (int i = 0; i < values.length; i++) {
values[i] = i + 1;
}
for (int i = 0; i < n; i++) {
String str = sc.next();
String[] ab = str.split(",");
int a = Integer.parseInt(ab[0]) - 1;
int b = Integer.parseInt(ab[1]) - 1;
int num;
num=values[a];
values[a]=values[b];
values[b]=num;
}
for(int x=0;x<w;x++){
System.out.println(values[x]);
}
}
}
|
ZhinΓΌ was a child of the Emperor, but he was weaving the machine even if he opened it at the request of his father.
It was a pleasure of the Emperor to wear clothes made of a splendid cloth called Unnishiki woven by ZhinΓΌ. Unnishiki has a short lifespan and deteriorates quickly, but there was no problem because the hard-working weaver weaves it every day. ZhinΓΌ kept her father's instructions and continued to weave Unnishiki every day, so she had no boyfriend. Poor father introduced a hard worker called a cowboy who lives on the other side of the Milky Way and married him.
Then, Orijo is absorbed in the joy of marriage, and is amazed at playing with the cowboy, without weaving. The shangdi's favorite Unnishiki's clothes have also become tattered because they cannot be newly tailored.
My father was angry at this and wanted to bring ZhinΓΌ back to the palace. However, it is not possible to appear in tattered clothes in front of the human cow. I thought about blocking the two people who were playful with a triangular wall so that everything but myself could not come and go. Then, without being found by the cow, he meets the weaver and declares that he will weave the machine seriously or will be forced to bring him back.
<image>
The Emperor decided to develop a triangular wall generator to carry out this operation. Enter the positions of the three vertices of the triangle (xp1, yp1), (xp2, yp2), (xp3, yp3), the position of the cowboy (xk, yk), and the position of the weaver (xs, ys), and the triangle is Determine whether or not the cow and the weaver are blocked, and create a program that outputs OK if it can be blocked and NG if it cannot be blocked. However, blocking means that either the cow or the weaver is inside the triangle and the other is outside. It is assumed that the cow and the weaver are not on the apex or side of the triangle.
Since the weaver and the cowboy change places from moment to moment, the program has to enter various location information and answer the questions.
Input
The input is given in the following format:
n
query1
query2
::
queryn
The number of pieces of information we want to determine on the first line is n (n β€ 10000), and the following n lines are given the i-th question queryi. Each question is given in the following format:
xp1 yp1 xp2 yp2 xp3 yp3 xk yk xs ys
For each question, the positions of the three vertices of the triangle, the position of the cow, and the position of the weaver (-1000 β€ xp1, yp1, xp2, yp2, xp3, yp3, xk, yk, xs, ys β€ 1000) are on one line. Given. All inputs are integers.
Output
For each question, output the judgment result OK or NG on one line.
Example
Input
5
2 5 9 2 8 9 2 11 6 5
2 5 9 2 8 9 2 11 12 6
2 5 9 2 8 9 2 11 11 9
14 1 25 7 17 12 17 9 20 5
14 1 25 7 17 12 22 13 20 5
Output
OK
NG
NG
NG
OK
|
#include<bits/stdc++.h>
#define EPS (1e-10)
#define equals(a,b)(fabs((a)-(b))<EPS)
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;
struct Point {
double x, y;
Point(double x = 0, double y = 0) :x(x), y(y) {}
Point operator*(double a) { return Point(a*x, a*y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
double norm() { return x*x + y*y; }
};
typedef Point Vector;
typedef vector<Point>Polygon;
struct Segment {
Point p1, p2;
};
double cross(Point a, Point b) {
return a.x*b.y - a.y*b.x;
}
double dot(Point a, Point b) {
return a.x*b.x + a.y*b.y;
}
bool isPrallel(Segment s1, Segment s2) {
return equals(cross(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}
bool isOrthogonal(Segment s1, Segment s2) {
return equals(dot(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}
int contains(Polygon g, Point p) {
int n = g.size();
bool x = false;
rep(i, n) {
Point a = g[i] - p, b = g[(i + 1) % n] - p;
if (abs(cross(a, b)) < EPS&&dot(a, b) < EPS)return 1;
if (a.y > b.y)swap(a, b);
if (a.y < EPS&&EPS<b.y&&cross(a, b)>EPS)x = !x;
}
return x ? 2 : 0;
}
int ccw(Point p0, Point p1, Point p2) {
Point a = p1 - p0;
Point b = p2 - p0;
if (cross(a, b) > EPS)return 1;
if (cross(a, b) < -EPS)return -1;
if (dot(a, b) < -EPS)return 2;
if (a.norm() < b.norm())return -2;
return 0;
}
bool intersect(Point p1, Point p2, Point p3, Point p4) {
return (ccw(p1, p2, p3)*ccw(p1, p2, p4) <= 0 &&
ccw(p3, p4, p1)*ccw(p3, p4, p2) <= 0);
}
bool intersect(Segment s1, Segment s2) {
return intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}
Point project(Segment s, Point p) {
Point base = s.p2 - s.p1;
double r = dot(p - s.p1, base) / base.norm();
return s.p1 + base*r;
}
Point reflect(Segment s, Point p) {
return p + (project(s, p) - p)*2.0;
}
bool isconvex(Polygon g) {
int back = 3;
rep(i, g.size()) {
int d = ccw(g[(i + g.size() - 1) % g.size()], g[i], g[(i + 1) % g.size()]);
if (back != 3 && d != back)
return false;
else back = d;
}
return true;
}
double area(Polygon g) {
double cnt = 0;
rep(i, g.size())
cnt += g[i].x*g[(i + 1) % g.size()].y - g[(i + 1) % g.size()].x*g[i].y;
return abs(cnt) / 2;
}
int main() {
int n; scanf("%d", &n);
rep(i, n) {
double xp1, yp1, xp2, yp2, xp3, yp3, xk, yk, xs, ys;
cin >> xp1 >> yp1 >> xp2 >> yp2 >> xp3 >> yp3 >> xk >> yk >> xs >> ys;
Point a(xp1, yp1), b(xp2, yp2), c(xp3, yp3), k(xk, yk), s(xs, ys);
Vector AB = b - a, BP = k - b, BC = c - b, CP = k - c, CA = a - c, AP = k - a;
bool flag = false;
double c1 = cross(CA, AP), c2 = cross(BC, CP), c3 = cross(AB, BP);
if ((c1 > 0 && c2 > 0 && c3 > 0) || (c1 < 0 && c2 < 0 && c3 < 0))flag = true;
BP = s - b, CP = s - c, AP = s - a;
c1 = cross(CA, AP), c2 = cross(BC, CP), c3 = cross(AB, BP);
if ((c1 > 0 && c2 > 0 && c3 > 0) || (c1 < 0 && c2 < 0 && c3 < 0))flag ^= true;
puts(flag ? "OK" : "NG");
}
}
|
At Akabe High School, which is a programmer training school, the roles of competition programmers in team battles are divided into the following three types.
C: | Coder | I am familiar with the language and code.
--- | --- | ---
A: | Algorithm | I am good at logical thinking and think about algorithms.
N: | Navigator | Good at reading comprehension, analyze and debug problems.
At this high school, a team of three people is formed in one of the following formations.
CCA: | Well-balanced and stable
--- | ---
CCC: | Fast-paced type with high risk but expected speed
CAN: | Careful solving of problems accurately
As a coach of the Competitive Programming Department, you take care every year to combine these members and form as many teams as possible. Therefore, create a program that outputs the maximum number of teams that can be created when the number of coders, the number of algorithms, and the number of navigators are given as inputs.
input
The input consists of one dataset. Input data is given in the following format.
Q
c1 a1 n1
c2 a2 n2
::
cQ aQ nQ
Q (0 β€ Q β€ 100) on the first line is the number of years for which you want to find the number of teams. The number of people by role in each year is given to the following Q line. Each row is given the number of coders ci (0 β€ ci β€ 1000), the number of algorithms ai (0 β€ ai β€ 1000), and the number of navigators ni (0 β€ ni β€ 1000).
output
Output the maximum number of teams that can be created on one line for each year.
Example
Input
4
3 0 0
1 1 1
9 4 1
0 1 2
Output
1
1
4
0
|
#include<bits/stdc++.h>
using namespace std;
signed main(){
cin.tie(NULL);
ios::sync_with_stdio(false);
long long Q,team=0,C,A,N;
cin>>Q;
for(int i=0;i<Q;i++){
cin>>C>>A>>N;
while(true){
if(C>0 && A>0 && N>0){
team++;
C--;
A--;
N--;
continue;
}
else if(C>=2 && A>=1){
team++;
C-=2;
A--;
continue;
}
else if(C>=3){
team++;
C-=3;
continue;
}
else{
cout<<team<<'\n';
team=0;
break;
}
}
}
return(0);
}
|
problem
One day, Taro, who lives in JOI town, decided to take a walk as a daily routine to improve his health. In JOI town, where Taro lives, he runs in the east-west direction as shown in the figure (H + 1). The road and the north-south direction (W + 1) run through the road in a grid pattern. Taro's house is at the northwestern intersection, and the walk starts from here.
Hereafter, the ath intersection from the north and the bth intersection from the west are represented by (a, b). For example, the intersection where Taro's house is located is (1, 1).
<image>
Figure: JOI town map (for H = 3, W = 4). The top of the figure corresponds to the north and the left corresponds to the west.
Taro thought that it would be more interesting if the walking route was different every day, so he wrote the letters "east" or "south" at the H x W intersections from (1, 1) to (H, W). , I decided to take a walk every day according to the following rules.
* If you are at an intersection with letters, rewrite the letters from "east" to "south" and "south" to "east", and the direction of the originally written letters. Proceed to the next intersection at.
* End the walk when you reach the easternmost or southernmost road.
After thinking about this plan, Taro was wondering what route he would take in his future walks. For Taro, he predicted the route for Taro's Nth walk. Create a program to do.
input
The input consists of multiple datasets. Each dataset is given in the following format.
On the first line, three positive integers are separated by blanks. These are the values ββof the three numbers H, W, N in the problem statement. H, W, N are 1 β€ H β€, respectively. 1000, 1 β€ W β€ 1000, 1 β€ N β€ 10000000 = 107. From the 2nd line to H + 1st line, W integers are written separated by blanks. Represents the information of the character written at the intersection first. If the jth integer of i + 1st line is 0, the character written at the intersection (i, j) is "south", and if it is 1, the intersection Indicates that the character written in (i, j) is "east".
Of the scoring data, 30% of the points are satisfied with H β€ 100, W β€ 100, and N β€ 1000.
When H, W, N are all 0, it indicates the end of input. The number of data sets does not exceed 10.
output
Output in the following format for each data set.
When the intersection where Taro finishes the walk in the Nth walk is (i, j), output i and j separated by a blank in this order.
Example
Input
3 4 3
1 0 1 1
0 1 0 0
1 0 1 0
0 0 0
Output
1 5
|
#include <iostream>
using namespace std;
int DP[1001][1001];
int pt[1001][1001];
int main() {
while(true){
int H,W,N;
int lastX=1,lastY=1;
cin >> H >> W >> N;
if(H==0)
break;
for(int i=1;i<=H;i++)
for(int j=1;j<=W;j++)
cin >> pt[j][i];
DP[1][1]=N-1;
for(int i=1;i<=H;i++)
for(int j=1;j<=W;j++)
if(i!=1|| j!=1 ){
DP[j][i]=DP[j][i-1]/2+DP[j-1][i]/2;
if(pt[j][i-1]==0 && DP[j][i-1] %2 ==1)
DP[j][i]++;
if(pt[j-1][i]==1 && DP[j-1][i] %2 ==1)
DP[j][i]++;
}
while(lastX<=W && lastY<=H){
if((DP[lastX][lastY]+pt[lastX][lastY])%2==1)
lastX++;
else
lastY++;
}
cout << lastY << " " << lastX << endl;
}
return 0;
}
|
Problem H: Squid Multiplication
Squid Eiko loves mathematics. Especially she loves to think about integer. One day, Eiko found a math problem from a website.
"A sequence b ={ai + aj | i < j } is generated from a sequence a ={a0 , ... , an | ai is even if i is 0, otherwise ai is odd}. Given the sequence b , find the sequence a ."
This problem is easy for Eiko and she feels boring. So, she made a new problem by modifying this problem .
"A sequence b ={ai *aj | i < j } is generated from a sequence a ={ a0, ... , an | ai is even if i is 0, otherwise ai is odd}. Given the sequence b , find the sequence a ."
Your task is to solve the problem made by Eiko.
Input
Input consists of multiple datasets.
Each dataset is given by following formats.
n
b0 b1 ... bn*(n+1)/2-1
n is the number of odd integers in the sequence a. The range of n is 2 β€ n β€ 250. bi is separated by a space. Each bi is 1 β€ bi β€ 263-1. The end of the input consists of a single 0.
Output
For each dataset, you should output two lines. First line contains a0, an even number in the sequence a. The second line contains n odd elements separated by a space. The odd elements are sorted by increasing order. You can assume that the result is greater than or equal to 1 and less than or equal to 231-1.
Example
Input
3
6 10 14 15 21 35
2
30 42 35
0
Output
2
3 5 7
6
5 7
|
#include<cstdio>
#include<algorithm>
#include<vector>
#include<cmath>
#define MAXX 65555
unsigned long long gcd(const unsigned long long &a,const unsigned long long &b)
{
return b?gcd(b,a%b):a;
}
unsigned long long n,i,j,k,m;
unsigned long long num[MAXX],g;
std::vector<unsigned long long>ev,od;
int main()
{
ev.reserve(MAXX);
od.reserve(MAXX);
while(scanf("%llu",&n),n)
{
m=n*(n+1)/2;
ev.resize(0);
od.resize(0);
for(i=0;i<m;++i)
{
scanf("%llu",num+i);
if(!(num[i]&1))
ev.push_back(num[i]);
else
od.push_back(num[i]);
}
std::sort(ev.begin(),ev.end());
std::sort(od.begin(),od.end());
g=ev[0];
for(i=1;i<ev.size();++i)
g=gcd(g,ev[i]);
k=od[0]/(ev[0]/g)/(ev[1]/g);
g/=sqrt(k);
printf("%llu\n%llu",g,ev[0]/g);
for(i=1;i<ev.size();++i)
printf(" %llu",ev[i]/g);
puts("");
}
return 0;
}
|
Bill is a boss of security guards. He has pride in that his men put on wearable computers on their duty. At the same time, it is his headache that capacities of commercially available batteries are far too small to support those computers all day long. His men come back to the office to charge up their batteries and spend idle time until its completion. Bill has only one battery charger in the office because it is very expensive.
Bill suspects that his men spend much idle time waiting in a queue for the charger. If it is the case, Bill had better introduce another charger. Bill knows that his men are honest in some sense and blindly follow any given instructions or rules. Such a simple-minded way of life may lead to longer waiting time, but they cannot change their behavioral pattern.
Each battery has a data sheet attached on it that indicates the best pattern of charging and consuming cycle. The pattern is given as a sequence of pairs of consuming time and charging time. The data sheet says the pattern should be followed cyclically to keep the battery in quality. A guard, trying to follow the suggested cycle strictly, will come back to the office exactly when the consuming time passes out, stay there until the battery has been charged for the exact time period indicated, and then go back to his beat.
The guards are quite punctual. They spend not a second more in the office than the time necessary for charging up their batteries. They will wait in a queue, however, if the charger is occupied by another guard, exactly on first-come-first-served basis. When two or more guards come back to the office at the same instance of time, they line up in the order of their identifi- cation numbers, and, each of them, one by one in the order of that line, judges if he can use the charger and, if not, goes into the queue. They do these actions in an instant.
Your mission is to write a program that simulates those situations like Billβs and reports how much time is wasted in waiting for the charger.
Input
The input consists of one or more data sets for simulation.
The first line of a data set consists of two positive integers separated by a space character: the number of guards and the simulation duration. The number of guards does not exceed one hundred. The guards have their identification numbers starting from one up to the number of guards. The simulation duration is measured in minutes, and is at most one week, i.e., 10080 (min.).
Patterns for batteries possessed by the guards follow the first line. For each guard, in the order of identification number, appears the pattern indicated on the data sheet attached to his battery. A pattern is a sequence of positive integers, whose length is a multiple of two and does not exceed fifty. The numbers in the sequence show consuming time and charging time alternately. Those times are also given in minutes and are at most one day, i.e., 1440 (min.). A space character or a newline follows each number. A pattern is terminated with an additional zero followed by a newline.
Each data set is terminated with an additional empty line. The input is terminated with an additional line that contains two zeros separated by a space character.
Output
For each data set your program should simulate up to the given duration. Each guard should repeat consuming of his battery (i.e., being on his beat) and charging of his battery according to the given pattern cyclically. At the beginning, all the guards start their cycle simultaneously, that is, they start their beats and, thus, start their first consuming period.
For each data set, your program should produce one line containing the total wait time of the guards in the queue up to the time when the simulation duration runs out. The output should not contain any other characters.
For example, consider a data set:
3 25
3 1 2 1 4 1 0
1 1 0
2 1 3 2 0
The guard 1 tries to repeat 3 min. consuming, 1 min. charging, 2 min. consuming, 1 min. charging, 4 min. consuming, and 1 min. charging, cyclically. Yet he has to wait sometimes to use the charger, when he is on his duty together with the other guards 2 and 3. Thus, the actual behavior of the guards looks like:
0 10 20
| | | | | |
guard 1: ***.**.****.***.**-.****.
guard 2: *.*-.*-.*-.*.*.*.*--.*.*-
guard 3: **.***--..**-.***..**.***
where β*β represents a minute spent for consuming, β.β for charging, and β-β for waiting in the queue. At time 3, the guards 1 and 2 came back to the office and the guard 1 started charging while the guard 2 went into the queue. At time 6, all the guards came back to the office and the guard 1 started charging while the others went to the queue. When the charger got available at time 7, the guard 2 started charging, leaving the guard 3 in the queue. All those happened are consequences of rules stated above. And the total time wasted in waiting for the charger becomes 10 minutes.
Example
Input
3 25
3 1 2 1 4 1 0
1 1 0
2 1 3 2 0
4 1000
80 20 80 20 80 20 80 20 0
80
20
0
80 20 90
10 80
20
0
90 10
0
0 0
Output
10
110
|
#include<bits/stdc++.h>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
using namespace std;
typedef pair<int,int> ii;
struct Data{
int id,stamp;
bool operator < ( const Data& data ) const {
if( stamp != data.stamp ) return stamp > data.stamp;
return id > data.id;
}
};
vector<ii> cycle[110];
int n,m,run_time[110],indices[110],charger,charge_id;
bool inQueue[110];
int simulate(){
rep(i,n) run_time[i] = cycle[i][0].first, indices[i] = 0, inQueue[i] = false;
charger = 0, charge_id = -1;
priority_queue<Data> Q;
int ret = 0;
rep(_,m){
rep(i,n) {
if( run_time[i] <= 0 && !inQueue[i] ) {
Q.push((Data){i,_});
inQueue[i] = true;
}
run_time[i]--;
}
if( charger == 0 && !Q.empty() ) {
charge_id = Q.top().id; Q.pop();
charger = cycle[charge_id][indices[charge_id]].second;
}
if( charger ) {
--charger;
if( charger <= 0 ) {
inQueue[charge_id] = false;
( indices[charge_id] += 1 ) %= (int)cycle[charge_id].size();
run_time[charge_id] = cycle[charge_id][indices[charge_id]].first;
}
}
ret += (int)Q.size();
}
return ret;
}
int main(){
while( cin >> n >> m, n | m ){
rep(i,n) {
int a,b;
cycle[i].clear();
while( cin >> a , a ){
cin >> b;
cycle[i].push_back(ii(a,b));
}
}
cout << simulate() << endl;
}
return 0;
}
|
Example
Input
6 3
((()))
4
3
1
Output
2
2
1
|
import java.util.*;
class Main{
int n, m, sz;
char[] kakko;
int[] a, bkt, add;
void solve(){
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
m = sc.nextInt();
kakko = sc.next().toCharArray();
sz = Math.max(1, (int)Math.sqrt(n) - 1);
a = new int[n];
bkt = new int[n/sz+10];
add = new int[n/sz+10];
TreeSet<Integer> set = new TreeSet<Integer>();
for(int i=0; i<n; i++){
if(i==0) a[i] = 1;
else{
if(kakko[i]=='(') a[i] = a[i-1] + 1;
else{
a[i] = a[i-1] - 1;
set.add(i);
}
}
bkt[i/sz] = Math.min(a[i], bkt[i/sz]);
}
for(int i=0; i<m; i++){
int q = sc.nextInt()-1;
int idx = 0;
if(kakko[q]=='('){
kakko[q] = ')';
set.add(q);
add(q, n, -2);
//idx = set.higher(new Integer(-1));
idx = set.pollFirst();
kakko[idx] = '(';
set.remove(idx);
add(idx, n, 2);
}else{
kakko[q] = '(';
set.remove(q);
add(q, n, 2);
idx = search(q);
kakko[idx] = ')';
add(idx, n, -2);
set.add(idx);
}
//System.out.println(Arrays.toString(kakko));
System.out.println(idx+1);
}
}
void add(int start, int last, int num){
int from = start - start%sz;
int to = from + sz;
for(int i=start/sz; i * sz <=last; i++){
if(start<=from && to<=last){
add[i] += num;
}else{
for(int j=Math.max(from, start); j<to && j<last; j++){
a[j] += num;
}
int min = Integer.MAX_VALUE;
for(int j=from; j<to && j<a.length; j++){
min = Math.min(min, a[j]);
}
bkt[i] = min;
}
from = to;
to += sz;
}
}
int search(int f){
int from = f - f%sz;
int to = from + sz;
for(int i=f/sz; i>=0; i--){
if(bkt[i]+add[i]<=1){
for(int j=Math.min(f-1, to-1); j>=from; j--){
if(a[j]+add[i]==1) return j+1;
}
}
to = from;
from -= sz;
}
return 0;
}
public static void main(String[] args){
new Main().solve();
}
}
|
Problem
You've come to an n x n x n cubic Rubik's Cube dungeon.
You are currently in the room (x1, y1, z1).
The target treasure is in the room (x2, y2, z2).
You can move to adjacent rooms in front, back, left, right, up and down in unit time.
<image>
Each room has 6 buttons, and by pressing each button, you can perform the following operations like a Rubik's cube in a unit time:
* All rooms with the same x-coordinate value as the current room can be rotated 90 degrees clockwise or counterclockwise.
<image>
* All rooms with the same y-coordinate value as the current room can be rotated 90 degrees clockwise or counterclockwise.
<image>
* All rooms with the same z-coordinate value as the current room can be rotated 90 degrees clockwise or counterclockwise.
<image>
You cannot move to another room while rotating.
Find the time to move to the room with the treasure in the shortest time.
Constraints
* 2 β€ n β€ 105
* 0 β€ x1, y1, z1, x2, y2, z2 β€ nβ1
* (x1, y1, z1) β (x2, y2, z2)
Input
n
x1 y1 z1
x2 y2 z2
All inputs are given as integers.
N is given on the first line.
The coordinates of the current location (x1, y1, z1) are given on the second line, and the coordinates of the room with the treasure (x2, y2, z2) are given on the third line, separated by spaces.
Output
Output the shortest time.
Examples
Input
3
0 0 0
1 2 2
Output
3
Input
3
0 0 0
0 0 2
Output
2
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,x1,y1,z1,x2,y2,z2;
cin >> n >> x1 >> y1 >> z1 >> x2 >> y2 >> z2;
int ans=1<<29;
for(int i=0; i<4; i++) {
for(int j=0; j<4; j++) {
for(int k=0; k<4; k++) {
int a[3]={0,1,2};
do {
int x=x1,y=y1,z=z1,d=0;
for(int l=0; l<3; l++) {
if(a[l]==0) {
if(i&&x==x2) d+=2;
for(int h=0; h<i; h++) {swap(y,z);z=n-z-1;}
} else if(a[l]==1) {
if(j&&y==y2) d+=2;
for(int h=0; h<j; h++) {swap(z,x);x=n-x-1;}
} else {
if(k&&z==z2) d+=2;
for(int h=0; h<k; h++) {swap(x,y);y=n-y-1;}
}
}
d+=abs(x-x2)+abs(y-y2)+abs(z-z2)+(i<3?i:1)+(j<3?j:1)+(k<3?k:1);
ans=min(ans,d);
} while(next_permutation(a,a+3));
}
}
}
cout << ans << endl;
return 0;
}
|
Mr. Hoge is in trouble. He just bought a new mansion, but itβs haunted by a phantom. He asked a famous conjurer Dr. Huga to get rid of the phantom. Dr. Huga went to see the mansion, and found that the phantom is scared by its own mirror images. Dr. Huga set two flat mirrors in order to get rid of the phantom.
As you may know, you can make many mirror images even with only two mirrors. You are to count up the number of the images as his assistant. Given the coordinates of the mirrors and the phantom, show the number of images of the phantom which can be seen through the mirrors.
Input
The input consists of multiple test cases. Each test cases starts with a line which contains two positive integers, px and py (1 β€ px, py β€ 50), which are the x- and y-coordinate of the phantom. In the next two lines, each line contains four positive integers ux, uy, vx and vy (1 β€ ux, uy, vx, vy β€ 50), which are the coordinates of the mirror.
Each mirror can be seen as a line segment, and its thickness is negligible. No mirror touches or crosses with another mirror. Also, you can assume that no images will appear within the distance of 10-5 from the endpoints of the mirrors.
The input ends with a line which contains two zeros.
Output
For each case, your program should output one line to the standard output, which contains the number of images recognized by the phantom. If the number is equal to or greater than 100, print βTOO MANYβ instead.
Example
Input
4 4
3 3 5 3
3 5 5 6
4 4
3 3 5 3
3 5 5 5
0 0
Output
4
TOO MANY
|
#include<bits/stdc++.h>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define EPS (1e-7)
#define equals(a,b) (fabs((a)-(b)) < EPS)
#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 0
using namespace std;
class Point{
public:
double x,y;
Point(double x = 0,double y = 0): x(x),y(y){}
Point operator + (Point p){return Point(x+p.x,y+p.y);}
Point operator - (Point p){return Point(x-p.x,y-p.y);}
Point operator * (double a){return Point(a*x,a*y);}
Point operator / (double a){return Point(x/a,y/a);}
Point operator * (Point a){ return Point(x * a.x - y * a.y, x * a.y + y * a.x); }
bool operator < (const Point& p) const{ return !equals(x,p.x)?x<p.x:(!equals(y,p.y)&&y<p.y); }
bool operator == (const Point& p)const{ return fabs(x-p.x) < EPS && fabs(y-p.y) < EPS; }
};
struct Segment{
Point p1,p2;
Segment(Point p1 = Point(),Point p2 = Point()):p1(p1),p2(p2){}
bool operator < (const Segment& s) const { return ( p2 == s.p2 ) ? p1 < s.p1 : p2 < s.p2; }
bool operator == (const Segment& s) const { return ( s.p1 == p1 && s.p2 == p2 ) || ( s.p1 == p2 && s.p2 == p1 ); }
};
typedef Point Vector;
typedef Segment Line;
double dot(Point a,Point b){ return a.x*b.x + a.y*b.y; }
double cross(Point a,Point b){ return a.x*b.y - a.y*b.x; }
double norm(Point a){ return a.x*a.x+a.y*a.y; }
double abs(Point a){ return sqrt(norm(a)); }
Point rotate(Point a,double rad){ return Point(cos(rad)*a.x - sin(rad)*a.y,sin(rad)*a.x + cos(rad)*a.y); }
double toRad(double agl){ return agl*M_PI/180.0; }
int ccw(Point p0,Point p1,Point p2){
Point a = p1-p0;
Point b = p2-p0;
if(cross(a,b) > EPS)return COUNTER_CLOCKWISE;
if(cross(a,b) < -EPS)return CLOCKWISE;
if(dot(a,b) < -EPS)return ONLINE_BACK;
if(norm(a) < norm(b))return ONLINE_FRONT;
return ON_SEGMENT;
}
bool intersectLL(Line l, Line m) {
return abs(cross(l.p2-l.p1, m.p2-m.p1)) > EPS || // non-parallel
abs(cross(l.p2-l.p1, m.p1-l.p1)) < EPS; // same line
}
bool intersectLS(Line l, Line s) {
return cross(l.p2-l.p1, s.p1-l.p1)* // s[0] is left of l
cross(l.p2-l.p1, s.p2-l.p1) < EPS; // s[1] is right of l
}
bool intersectLP(Line l,Point p) { return abs(cross(l.p2-p, l.p1-p)) < EPS; }
bool intersectSS(Line s, Line t) {
return ccw(s.p1,s.p2,t.p1)*ccw(s.p1,s.p2,t.p2) <= 0 &&
ccw(t.p1,t.p2,s.p1)*ccw(t.p1,t.p2,s.p2) <= 0;
}
bool intersectSP(Line s, Point p) { return abs(s.p1-p)+abs(s.p2-p)-abs(s.p2-s.p1) < EPS; }
Point projection(Line l,Point p) {
double t = dot(p-l.p1, l.p1-l.p2) / norm(l.p1-l.p2);
return l.p1 + (l.p1-l.p2)*t;
}
Point reflection(Line l,Point p) { return p + (projection(l, p) - p) * 2; }
double distanceSP(Line s, Point p) {
Point r = projection(s, p);
if (intersectSP(s, r)) return abs(r - p);
return min(abs(s.p1 - p), abs(s.p2 - p));
}
Point crosspoint(Line l,Line m){
double A = cross(l.p2-l.p1,m.p2-m.p1);
double B = cross(l.p2-l.p1,l.p2-m.p1);
if(abs(A) < EPS && abs(B) < EPS){
vector<Point> vec;
vec.push_back(l.p1),vec.push_back(l.p2),vec.push_back(m.p1),vec.push_back(m.p2);
sort(vec.begin(),vec.end());
assert(vec[1] == vec[2]); //???????????Β°??????????????????
return vec[1];
//return m.p1;
}
if(abs(A) < EPS)assert(false);
return m.p1 + (m.p2-m.p1)*(B/A);
}
// --------
inline bool LT(double a,double b) { return !equals(a,b) && a < b; }
inline bool LTE(double a,double b) { return equals(a,b) || a < b; }
const double PI2 = M_PI * 2.0;
struct AngleRange {
Point o; // ?????????, ???????????????????Β§???? ????????Β¨???????????????????????????,????????????
double mini,maxi; // mini <= maxi | 0 <= mini,maxi <= 720
// ?????Β°?????????????????Β§abs(maxi-mini)???180??????
AngleRange( Point p, Segment seg ) {
o = p;
seg.p1 = seg.p1 - o, seg.p2 = seg.p2 - o;
complex<double> p1(seg.p1.x,seg.p1.y);
complex<double> p2(seg.p2.x,seg.p2.y);
double tmp = arg( p1 / p2 ); // ???????????? p1 ??Β¨ p2 ??????????Β§? arg( p1 / p2 )
mini = LT(0.0,tmp) ? arg(p2) : arg(p1);
if( LT(mini,0) ) mini += PI2;
maxi = abs(tmp) + mini;
}
bool fail(){ return equals(mini,maxi); }
// mini < a < maxi
bool contains(double a) const {
return ( LT(mini,a-PI2) && LT(a-PI2,maxi) ) || ( LT(mini,a) && LT(a,maxi) ) || ( LT(mini,a+PI2) && LT(a+PI2,maxi) );
}
bool contains(Point p) const {
p = p - o;
complex<double> cp(p.x,p.y);
return contains(arg(cp));
}
void update( AngleRange ar ) {
if( contains(ar.mini) ) {
if( contains(ar.maxi) ) mini = ar.mini, maxi = ar.maxi;
else mini = ar.mini;
} else {
if( contains(ar.maxi) ) maxi = ar.maxi;
else if( !ar.contains(mini) && !equals(mini,ar.mini) ) maxi = mini;
}
if( LT(maxi-mini,0) ) maxi += PI2;
if( LTE(PI2,maxi-mini) ) maxi -= PI2;
}
};
ostream& operator << (ostream& os,const AngleRange& a){ os << "[ " << a.mini*180.0/M_PI << " , " << a.maxi*180.0/M_PI << " ]"; }
Segment reflection(Line line, Segment seg){
return Segment(reflection(line,seg.p1),reflection(line,seg.p2));
}
double distance(Segment s,Point p1,Point p2){
Segment t = Segment(p1,p2);
Point cp = crosspoint(s,Line(p1,p2));
return abs(p1-cp);
}
Point vp;
double distance2(Segment s,double rad){
Vector e = Point(10,0);
e = rotate(e,rad);
Point cp = crosspoint(s,Line(vp,vp+e));
return abs(cp-vp);
}
const int loop_limit = 100000;
void compute(Point phantom,Segment mirror1,Segment mirror2){
vp = phantom;
Point iPhantom[2] = { reflection(mirror1,phantom), reflection(mirror2,phantom) };
Segment nmirror[2] = { mirror1, mirror2 };
AngleRange range[2] = { AngleRange(phantom,mirror1), AngleRange(phantom,mirror2) };
int cnt = 0;
int i = 0;
while( i < loop_limit && cnt <= 100 && !( range[0].fail() && range[1].fail() ) ){
if( !range[0].fail() )
if( !intersectSS(Segment(phantom,iPhantom[0]),mirror2) || !LT(distance(mirror2,phantom,iPhantom[0]),distance(mirror1,phantom,iPhantom[0])) ) {
if( range[0].contains(iPhantom[0]) ) ++cnt;
}
if( !range[1].fail() )
if( !intersectSS(Segment(phantom,iPhantom[1]),mirror1) || !LT(distance(mirror1,phantom,iPhantom[1]),distance(mirror2,phantom,iPhantom[1])) ) {
if( range[1].contains(iPhantom[1]) ) ++cnt;
}
Segment tmp1 = reflection(mirror1,nmirror[1]);
Segment tmp2 = reflection(mirror2,nmirror[0]);
Point tmp3 = reflection(mirror1,iPhantom[1]);
Point tmp4 = reflection(mirror2,iPhantom[0]);
AngleRange tmpR(phantom,tmp1);
range[0].update(tmpR);
tmpR = AngleRange(phantom,tmp2);
range[1].update(tmpR);
double mid = ( range[0].mini + range[0].maxi ) / 2;
if( !range[0].fail() && LT(distance2(tmp1,mid),distance2(nmirror[0],mid)) ) range[0].mini = range[0].maxi = 0;
mid = ( range[1].mini + range[1].maxi ) / 2;
if( !range[1].fail() && LT(distance2(tmp2,mid),distance2(nmirror[1],mid)) ) range[1].mini = range[1].maxi = 0;
nmirror[0] = tmp1;
nmirror[1] = tmp2;
iPhantom[0] = tmp3;
iPhantom[1] = tmp4;
++i;
}
if( cnt > 100 ) puts("TOO MANY");
else cout << cnt << endl;
}
int main(){
int sx,sy;
while( cin >> sx >> sy, sx | sy ){
Point sp = Point(sx,sy);
Segment segs[2];
rep(i,2) cin >> segs[i].p1.x >> segs[i].p1.y >> segs[i].p2.x >> segs[i].p2.y;
compute(sp,segs[0],segs[1]);
}
return 0;
}
|
Description
KMC sells CDs every year at a coterie spot sale called Comic Market. F was supposed to sell CDs at the comic market, but due to the popularity of F, the KMC sales floor was flooded with people, and the calculation of change could not keep up. So F decided to write a program that would output the change as soon as he entered the amount.
KMC prepares only 100-yen coins, 500-yen coins, and 1000-yen coins as change. You can think of these coins and bills as infinite. Choose change so that the number of coins and bills is minimized. Also, the price of CDs sold by KMC is a multiple of 100, and the amount paid by the purchaser is also a multiple of 100.
Input
The input consists of multiple test cases.
Each test case consists of two positive integers A and B. A is the price of the CD and B is the amount paid by the purchaser. A and B are multiples of 100 and do not exceed 100000000. Also, A β€ B.
The input ends with 0 0.
Output
For each test case, the number and number of 100-yen coins, 500-yen coins, and 1000-yen coins that should be presented as change are output in this order in one line. Insert a space between each number.
Example
Input
500 1000
100 10000
400 700
600 5000
10000 10000
0 0
Output
0 1 0
4 1 9
3 0 0
4 0 4
0 0 0
|
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<set>
using namespace std;
int main() {
int a, b;
while(cin>>a>>b&&a!=0&&b!=0){
int h = 0, g = 0, s = 0,o=b-a;
while (o >= 1000) {
s++;
o -= 1000;
}
while (o >= 500) {
g++;
o -= 500;
}
while (o >= 100) {
h++;
o -= 100;
}
cout << h << " " << g << " " << s << endl;
}
}
|
Example
Input
6 3 1.0
1 2 3
4 5 6
0 0
1 0
2 0
0 1
1 1
2 1
Output
3
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define rep1(i,n) for(int i=1;i<=(int)(n);i++)
#define reps(i,s,n) for(int i=s;i<n+s;i++)
#define ireps(i,s,n) for(int i=s+n-1;i>=s;i--)
#define all(c) c.begin(),c.end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << x << endl
#define chmin(x,y) x=min(x,y)
#define chmax(x,y) x=max(x,y)
using namespace std;
inline bool B(int t,int i){return (t>>i)&1;}
typedef double D;
int N,K,Y,s[3],t[3],x[102],y[102],oid[102];
vector<int> ys;
vector<int> y2id[102]; //ashed y -> ids
D R,e[102][102],inf=1e9,eps=1e-8;
void changeid(){
int iv[102];
rep(i,N) iv[oid[i]]=i;
rep(i,K) s[i]=iv[s[i]],t[i]=iv[t[i]];
}
bool kon(int i,int j,int k){
if(i>j) swap(i,j);
if(k<i||j<k) return 0;
int c=(y[k]-y[i])*(x[j]-x[i]) - (x[k]-x[i])*(y[j]-y[i]);
return c==0;
}
D dp[102][102][102],ndp[102][102][102],tmp3[102][102][102],tmp2[102][102],tmp1[102];
int t3[8][3]={
{2,1,0},
{2,1,0},
{2,1,0},
{1,2,0},
{0,2,1},
{0,1,2},
{0,1,2},
{0,1,2}
};
D changeith(int a,int b,int c,int& na,int& nb,int& nc,int i,int ad,int o,int S){
if(a>b) swap(a,b);
if(b>c) swap(b,c);
if(a>b) swap(a,b);
int x=0;
if(i==0) x=a;
if(i==1) x=b;
if(i==2) x=c;
int nx=x+ad;
if(nx==o-1||nx==o+S) return inf;
D ret=e[x][nx];
if(x==na) na+=ad;
if(x==nb) nb+=ad;
if(x==nc) nc+=ad;
if(na==nb||nb==nc||nc==na) return inf;
return ret;
}
void dothree(int y){
// printf("dothree %d\n",y);
vector<int> vc=y2id[y];
int S=vc.size(),o=vc[0];
rep(t,8){
reps(i,o,S) reps(j,o,S) reps(k,o,S) tmp3[i][j][k]=dp[i][j][k];
rep(i_,3){
int i=t3[t][i_]; //i-th leftest move
if(B(t,2-i)){ //right
reps(a,o,S) reps(b,o,S) reps(c,o,S) if(a!=b&&b!=c&&a!=c){
int na=a,nb=b,nc=c;
D cost=changeith(a,b,c,na,nb,nc,i,1,o,S);
chmin(tmp3[na][nb][nc],tmp3[a][b][c]+cost);
}
}else{ //left
ireps(a,o,S) ireps(b,o,S) ireps(c,o,S) if(a!=b&&b!=c&&a!=c){
int na=a,nb=b,nc=c;
D cost=changeith(a,b,c,na,nb,nc,i,-1,o,S);
chmin(tmp3[na][nb][nc],tmp3[a][b][c]+cost);
}
}
}
reps(i,o,S) reps(j,o,S) reps(k,o,S) chmin(ndp[i][j][k],tmp3[i][j][k]);
}
}
int t2[4][2]={
{1,0},
{1,0},
{1,0},
{0,1}
};
D changeith2(int a,int b,int& na,int &nb,int i,int ad,int o,int S){
if(a>b) swap(a,b);
int x=0;
if(i==0) x=a;
if(i==1) x=b;
int nx=x+ad;
if(nx==o-1||nx==o+S) return inf;
D ret=e[x][nx];
if(x==na) na+=ad;
if(x==nb) nb+=ad;
if(na==nb) return inf;
return ret;
}
void dotwo(int y){
// printf("dotwo %d\n",y);
vector<int> vc=y2id[y];
int S=vc.size(),o=vc[0];
{ //a: not y
rep(t,4){
rep(a,N){
if(o<=a&&a<o+S) continue;
reps(j,o,S) reps(k,o,S) tmp2[j][k]=dp[a][j][k];
rep(i_,2){
int i=t2[t][i_]; //i-th leftest move
if(B(t,1-i)){ //right
reps(b,o,S) reps(c,o,S) if(b!=c){
int nb=b,nc=c;
D cost=changeith2(b,c,nb,nc,i,1,o,S);
chmin(tmp2[nb][nc],tmp2[b][c]+cost);
}
}else{ //left
ireps(b,o,S) ireps(c,o,S) if(b!=c){
int nb=b,nc=c;
D cost=changeith2(b,c,nb,nc,i,-1,o,S);
chmin(tmp2[nb][nc],tmp2[b][c]+cost);
}
}
}
reps(j,o,S) reps(k,o,S) chmin(ndp[a][j][k],tmp2[j][k]);
}
}
}
{ //b: not y
rep(t,4){
rep(b,N){
if(o<=b&&b<o+S) continue;
reps(j,o,S) reps(k,o,S) tmp2[j][k]=dp[j][b][k];
rep(i_,2){
int i=t2[t][i_]; //i-th leftest move
if(B(t,1-i)){ //right
reps(a,o,S) reps(c,o,S) if(a!=c){
int na=a,nc=c;
D cost=changeith2(a,c,na,nc,i,1,o,S);
chmin(tmp2[na][nc],tmp2[a][c]+cost);
}
}else{ //left
ireps(a,o,S) ireps(c,o,S) if(a!=c){
int na=a,nc=c;
D cost=changeith2(a,c,na,nc,i,-1,o,S);
chmin(tmp2[na][nc],tmp2[a][c]+cost);
}
}
}
reps(j,o,S) reps(k,o,S) chmin(ndp[j][b][k],tmp2[j][k]);
}
}
}
{ //c: not y
rep(t,4){
rep(c,N){
if(o<=c&&c<o+S) continue;
reps(j,o,S) reps(k,o,S) tmp2[j][k]=dp[j][k][c];
rep(i_,2){
int i=t2[t][i_]; //i-th leftest move
if(B(t,1-i)){ //right
reps(a,o,S) reps(b,o,S) if(a!=b){
int na=a,nb=b;
D cost=changeith2(a,b,na,nb,i,1,o,S);
chmin(tmp2[na][nb],tmp2[a][b]+cost);
}
}else{ //left
ireps(a,o,S) ireps(b,o,S) if(a!=b){
int na=a,nb=b;
D cost=changeith2(a,b,na,nb,i,-1,o,S);
chmin(tmp2[na][nb],tmp2[a][b]+cost);
}
}
}
reps(j,o,S) reps(k,o,S) chmin(ndp[j][k][c],tmp2[j][k]);
}
}
}
}
void doone(int y){
vector<int> vc=y2id[y];
int S=vc.size(),o=vc[0];
{
rep(b,N) rep(c,N){
if(o<=b&&b<o+S) continue;
if(o<=c&&c<o+S) continue;
reps(a,o,S) tmp1[a]=dp[a][b][c];
reps(a,o,S) if(a+1!=o+S) chmin(tmp1[a+1],tmp1[a]+e[a][a+1]);
ireps(a,o,S) if(a-1!=o-1) chmin(tmp1[a-1],tmp1[a]+e[a][a-1]);
reps(a,o,S) chmin(ndp[a][b][c],tmp1[a]);
}
}
{
rep(a,N) rep(c,N){
if(o<=a&&a<o+S) continue;
if(o<=c&&c<o+S) continue;
reps(b,o,S) tmp1[b]=dp[a][b][c];
reps(b,o,S) if(b+1!=o+S) chmin(tmp1[b+1],tmp1[b]+e[b][b+1]);
ireps(b,o,S) if(b-1!=o-1) chmin(tmp1[b-1],tmp1[b]+e[b][b-1]);
reps(b,o,S) chmin(ndp[a][b][c],tmp1[b]);
}
}
{
rep(a,N) rep(b,N){
if(o<=a&&a<o+S) continue;
if(o<=b&&b<o+S) continue;
reps(c,o,S) tmp1[c]=dp[a][b][c];
reps(c,o,S) if(c+1!=o+S) chmin(tmp1[c+1],tmp1[c]+e[c][c+1]);
ireps(c,o,S) if(c-1!=o-1) chmin(tmp1[c-1],tmp1[c]+e[c][c-1]);
reps(c,o,S) chmin(ndp[a][b][c],tmp1[c]);
}
}
}
int main(){
cin>>N>>K>>R;
rep(i,K) cin>>s[i],s[i]--;
rep(i,K) cin>>t[i],t[i]--;
rep(i,N) cin>>x[i]>>y[i];
while(K<3){
x[N]=N,y[N]=10001;
s[K]=N,t[K]=N;
N++;
K++;
}
rep(i,N) oid[i]=i;
rep(i,N-1) rep(j,N-1) if( y[j]>y[j+1] || (y[j]==y[j+1]&&x[j]>x[j+1]) ) swap(x[j],x[j+1]),swap(y[j],y[j+1]),swap(oid[j],oid[j+1]);
changeid();
// rep(i,K) printf("s[%d],t[%d]=%d,%d\n",i,i,s[i],t[i]);
rep(i,N) rep(j,N) if(i!=j){
e[i][j]=sqrt( (x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]) );
if(e[i][j]>R+eps) e[i][j]=inf;
rep(k,N) if(k!=i&&k!=j){
if(kon(i,j,k)) e[i][j]=inf;
}
}
rep(i,N) ys.pb(y[i]);
sort(all(ys));
ys.erase(unique(ys.begin(),ys.end()),ys.end());
rep(i,N) y2id[ lower_bound(all(ys),y[i])-ys.begin() ].pb(i);
Y=ys.size();
rep(i,N) rep(j,N) rep(k,N) dp[i][j][k]=inf;
dp[s[0]][s[1]][s[2]]=0;
rep(yid,Y){
rep(a,N) rep(b,N) rep(c,N) if(dp[a][b][c]<inf){ // a:<y -> y
if(y[a]<ys[yid]){
for(int n:y2id[yid]) if(n!=b&&n!=c) chmin(dp[n][b][c],dp[a][b][c]+e[a][n]);
}
}
rep(a,N) rep(b,N) rep(c,N) if(dp[a][b][c]<inf){ // b:<y -> y
if(y[b]<ys[yid]){
for(int n:y2id[yid]) if(n!=a&&n!=c) chmin(dp[a][n][c],dp[a][b][c]+e[b][n]);
}
}
rep(a,N) rep(b,N) rep(c,N) if(dp[a][b][c]<inf){ // c:<y -> y
if(y[c]<ys[yid]){
for(int n:y2id[yid]) if(n!=a&&n!=b) chmin(dp[a][b][n],dp[a][b][c]+e[c][n]);
}
}
rep(a,N) rep(b,N) rep(c,N) ndp[a][b][c]=dp[a][b][c];
dothree(yid);
dotwo(yid);
doone(yid);
rep(a,N) rep(b,N) rep(c,N) dp[a][b][c]=ndp[a][b][c];
}
// rep(i,N) rep(j,N){
// printf("e[%d][%d]=%lf\n",i,j,e[i][j]);
// }
// rep(i,N) rep(j,N) rep(k,N) if(dp[i][j][k]!=inf){
// printf("dp[%d][%d][%d]=%f\n",i,j,k,dp[i][j][k]);
// }
D ans=dp[t[0]][t[1]][t[2]];
if(ans==inf) ans=-1;
printf("%.12f\n",ans);
}
|
E - Minimum Spanning Tree
Problem Statement
You are given an undirected weighted graph G with n nodes and m edges. Each edge is numbered from 1 to m.
Let G_i be an graph that is made by erasing i-th edge from G. Your task is to compute the cost of minimum spanning tree in G_i for each i.
Input
The dataset is formatted as follows.
n m
a_1 b_1 w_1
...
a_m b_m w_m
The first line of the input contains two integers n (2 \leq n \leq 100{,}000) and m (1 \leq m \leq 200{,}000). n is the number of nodes and m is the number of edges in the graph. Then m lines follow, each of which contains a_i (1 \leq a_i \leq n), b_i (1 \leq b_i \leq n) and w_i (0 \leq w_i \leq 1{,}000{,}000). This means that there is an edge between node a_i and node b_i and its cost is w_i. It is guaranteed that the given graph is simple: That is, for any pair of nodes, there is at most one edge that connects them, and a_i \neq b_i for all i.
Output
Print the cost of minimum spanning tree in G_i for each i, in m line. If there is no spanning trees in G_i, print "-1" (quotes for clarity) instead.
Sample Input 1
4 6
1 2 2
1 3 6
1 4 3
2 3 1
2 4 4
3 4 5
Output for the Sample Input 1
8
6
7
10
6
6
Sample Input 2
4 4
1 2 1
1 3 10
2 3 100
3 4 1000
Output for the Sample Input 2
1110
1101
1011
-1
Sample Input 3
7 10
1 2 1
1 3 2
2 3 3
2 4 4
2 5 5
3 6 6
3 7 7
4 5 8
5 6 9
6 7 10
Output for the Sample Input 3
27
26
25
29
28
28
28
25
25
25
Sample Input 4
3 1
1 3 999
Output for the Sample Input 4
-1
Example
Input
4 6
1 2 2
1 3 6
1 4 3
2 3 1
2 4 4
3 4 5
Output
8
6
7
10
6
6
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005 , maxm = 400005;
const long long inf = 41351356514454ll;
typedef pair<int , long long> pii;
#define x first
#define y second
struct edge{
int u , v , p;
long long w;
edge(){}
void read(int i){scanf("%d%d%lld" , &u , &v , &w);p=i;}
friend bool operator < (const edge &a , const edge &b){return a.w < b.w;}
}e[25][maxm] , t[maxm] , d[maxm];
pii q[maxm];
int n , m , qc;
long long sum[maxn] , f[maxn] , sz[maxn] , c[maxm] , a[maxm];
long long ans[maxm];
void reset(edge *s , int tot)
{
for (int i = 1 ; i <= tot ; i++)
f[s[i].u] = s[i].u , f[s[i].v] = s[i].v;
}
int set_find(int u){return f[u] == u ? u : f[u] = set_find(f[u]);}
void set_merge(int u , int v){f[set_find(u)] = set_find(v);}
void cont(int &tot , long long &cnt)
{
int tmp = 0;
reset(d , tot);
sort(&d[1] , &d[tot + 1]);
for (int i = 1 ; i <= tot ; i++)
if (set_find(d[i].u) != set_find(d[i].v))
set_merge(d[i].u , d[i].v) , t[++tmp] = d[i];
reset(t , tmp);
for (int i = 1 ; i <= tmp ; i++)
if (t[i].w != -inf && set_find(t[i].u) != set_find(t[i].v))
set_merge(t[i].u , t[i].v) , cnt+=t[i].w;
tmp = 0;
for (int i = 1 ; i <= tot ; i++)
if (set_find(d[i].u) != set_find(d[i].v))
t[c[d[i].p] = ++tmp] = d[i],
t[tmp].u = f[d[i].u],
t[tmp].v = f[d[i].v];
for (int i = 1 ; i <= tmp ; i++)
d[i] = t[i];
tot = tmp;
}
void redu(int &tot)
{
int tmp = 0;
reset(d , tot);
sort(&d[1] , &d[tot + 1]);
for (int i = 1 ; i <= tot ; i++)
if (set_find(d[i].u) != set_find(d[i].v))
set_merge(d[i].u , d[i].v),
t[c[d[i].p] = ++tmp] = d[i];
else if (d[i].w == inf)
t[c[d[i].p] = ++tmp] = d[i];
for (int i = 1 ; i <= tmp ; i++) d[i] = t[i];
tot = tmp;
}
void solv(int l , int r , int lay , long long cnt)
{
int tot = sum[lay];
if (l == r) a[q[l].x] = q[l].y;
for (int i = 1 ; i <= tot ; i++) e[lay][i].w = a[e[lay][i].p];
for (int i = 1 ; i <= tot ; i++) d[i] = e[lay][i] , c[d[i].p] = i;
if (l == r)
{
ans[l] = cnt;
reset(d , tot);
sort(&d[1] , &d[tot + 1]);
for (int i = 1 ; i <= tot ; i++)
if (set_find(d[i].u) != set_find(d[i].v))
set_merge(d[i].u , d[i].v) , ans[l] += d[i].w;
return;
}
for (int i = l ; i <= r ; i++) d[c[q[i].x]].w = -inf;
cont(tot , cnt);
for (int i = l ; i <= r ; i++) d[c[q[i].x]].w = inf;
redu(tot);
for (int i = 1 ; i <= tot ; i++) e[lay + 1][i] = d[i];
sum[lay + 1] = tot;
int mid = (l + r) / 2;
solv(l , mid , lay + 1 , cnt);
solv(mid + 1 , r , lay + 1 , cnt);
}
int main()
{
scanf("%d%d" , &n , &m);
for (int i = 1 ; i <= m ; i++)
{
e[0][i].read(i);a[i] = e[0][i].w;
q[++qc] = pii(i , (long long)1e13);
q[++qc] = pii(i , e[0][i].w);
}
sum[0] = m;
solv(1 , qc , 0 , 0);
for (int i = 1 ; i <= qc ; i += 2)
printf("%lld\n" , ans[i] < 1e13 ? ans[i] : -1ll);
return 0;
}
|
Tunnel formula
One day while exploring an abandoned mine, you found a long formula S written in the mine. If you like large numbers, you decide to take out the choke and add `(` or `)` so that the result of the formula calculation is as large as possible. If it has to be a mathematical formula even after adding it, how many can it be at the maximum?
There is enough space between the letters, and you can add as many `(` or `)` as you like. If the final formula is a formula, you may write `(` or `)` so that the correspondence of the first parenthesis is broken (see Sample 2). Also, here, <expr> defined by the following BNF is called a mathematical formula. All numbers in the formula are single digits.
<expr> :: = "(" <expr> ")"
| <term> "+" <term>
| <term> "-" <term>
<term> :: = <digit> | <expr>
<digit> :: = "0" | "1" | "2" | "3" | "4"
| "5" | "6" | "7" | "8" | "9"
Constraints
* 3 β€ | S | β€ 200
S represents a mathematical formula.
Input Format
Input is given from standard input in the following format.
S
Output Format
Output the answer as an integer.
Sample Input 1
1- (2 + 3-4 + 5)
Sample Output 1
Five
1- (2 + 3- (4 + 5)) is the maximum.
Sample Input 2
1- (2 + 3 + 4)
Sample Output 2
0
(1- (2 + 3) + 4) is the maximum.
Sample Input 3
1- (2 + 3)
Sample Output 3
-Four
Note that 1- (2) + (3) is not the formula here.
Example
Input
1-(2+3-4+5)
Output
5
|
#include <bits/stdc++.h>
using namespace std;
int dp[201][201][2];
int main() {
string s;
cin >> s;
int n=s.size();
for(int i=0;i<n;i++){
for(int j=0;j<n;j++)dp[i][j][0]=1<<29,dp[i][j][1]=-(1<<29);
if(isdigit(s[i]))dp[i][i][0]=dp[i][i][1]=s[i]-'0';
}
for(int i=0; i<n; i++){
for(int j=0;j<n-i;j++){
if(s[j]=='(')dp[j][j+i][0]=min(dp[j][j+i][0],dp[j+1][j+i][0]),dp[j][j+i][1]=max(dp[j][j+i][1],dp[j+1][j+i][1]);
if(s[j+i]==')')dp[j][j+i][0]=min(dp[j][j+i][0],dp[j][j+i-1][0]),dp[j][j+i][1]=max(dp[j][j+i][1],dp[j][j+i-1][1]);
}
for(int j=0;j<n-i;j++){
if(s[j]=='+'||s[j]=='-'||s[j+i]=='+'||s[j+i]=='-')continue;
for(int k=j+1;k<=j+i-1;k++){
if((j+2<=k&&s[k-2]=='(')||(k<=j+i-2&&s[k+2]==')'))continue;
if(s[k]=='+'||s[k]=='-'){
for(int x=0;x<2;x++)for(int y=0;y<2;y++){
if(abs(dp[j][k-1][x])>=(1<<29)||abs(dp[k+1][j+i][y])>=(1<<29))continue;
dp[j][j+i][0]=min(dp[j][j+i][0],dp[j][k-1][x]+dp[k+1][j+i][y]*(s[k]=='+'?1:-1));
dp[j][j+i][1]=max(dp[j][j+i][1],dp[j][k-1][x]+dp[k+1][j+i][y]*(s[k]=='+'?1:-1));
}
}
}
}
}
cout<<dp[0][n-1][1]<<endl;
return 0;
}
|
You are supposed to play the rock-paper-scissors game. There are $N$ players including you.
This game consists of multiple rounds. While the rounds go, the number of remaining players decreases. In each round, each remaining player will select an arbitrary shape independently. People who show rocks win if all of the other people show scissors. In this same manner, papers win rocks, scissors win papers. There is no draw situation due to the special rule of this game: if a round is tied based on the normal rock-paper-scissors game rule, the player who has the highest programming contest rating (this is nothing to do with the round!) will be the only winner of the round. Thus, some players win and the other players lose on each round. The losers drop out of the game and the winners proceed to a new round. They repeat it until only one player becomes the winner.
Each player is numbered from $1$ to $N$. Your number is $1$. You know which shape the other $N-1$ players tend to show, that is to say, you know the probabilities each player shows rock, paper and scissors. The $i$-th player shows rock with $r_i\%$ probability, paper with $p_i\%$ probability, and scissors with $s_i\%$ probability. The rating of programming contest of the player numbered $i$ is $a_i$. There are no two players whose ratings are the same. Your task is to calculate your probability to win the game when you take an optimal strategy based on each player's tendency and rating.
Input
The input consists of a single test case formatted as follows.
$N$
$a_1$
$a_2$ $r_2$ $p_2$ $s_2$
...
$a_N$ $r_N$ $p_N$ $s_N$
The first line consists of a single integer $N$ ($2 \leq N \leq 14$). The second line consists of a single integer $a_i$ ($1 \leq a_i \leq N$). The ($i+1$)-th line consists of four integers $a_i, r_i, p_i$ and $s_i$ ($1 \leq a_i \leq N, 0 \leq r_i, p_i, s_i \leq 100,$ $r_i + p_i + s_i = 100$) for $i=2, ..., N$. It is guaranteed that $a_1, ..., a_N$ are pairwise distinct.
Output
Print the probability to win the game in one line. Your answer will be accepted if its absolute or relative error does not exceed $10^{-6}$.
Examples
Input
2
2
1 40 40 20
Output
0.8
Input
2
1
2 50 50 0
Output
0.5
Input
3
2
1 50 0 50
3 0 0 100
Output
1
Input
3
2
3 40 40 20
1 30 10 60
Output
0.27
Input
4
4
1 34 33 33
2 33 34 33
3 33 33 34
Output
0.6591870816
|
#include<bits/stdc++.h>
using namespace std;
signed main(){
int n,x;
cin>>n>>x;
n--;
int a[n];
double r[n],p[n],s[n];
for(int i=0;i<n;i++) cin>>a[i]>>r[i]>>p[i]>>s[i];
for(int i=0;i<n;i++){
r[i]/=100;p[i]/=100;s[i]/=100;
}
double dp[1<<n];
for(int i=0;i<(1<<n);i++)
dp[i]=-1;
function<double(int)> dfs=[&](int b){
if(__builtin_popcount(b)==n) return 1.0;
if(dp[b]>=0) return dp[b];
vector<int> v;
int y=-1;
for(int i=0;i<n;i++){
if(!((b>>i)&1)){
v.push_back(i);
y=max(y,a[i]);
}
}
int m=v.size();
double dp2[m+1][1<<3][1<<3];
for(int i=0;i<=m;i++)
for(int j=0;j<(1<<3);j++)
for(int k=0;k<(1<<3);k++)
dp2[i][j][k]=0;
dp2[0][0][0]=1;
for(int i=0;i<m;i++){
for(int j=0;j<(1<<3);j++){
for(int k=0;k<(1<<3);k++){
dp2[i+1][j|1][k|((a[v[i]]>x)<<0)]+=dp2[i][j][k]*r[v[i]];
dp2[i+1][j|2][k|((a[v[i]]>x)<<1)]+=dp2[i][j][k]*p[v[i]];
dp2[i+1][j|4][k|((a[v[i]]>x)<<2)]+=dp2[i][j][k]*s[v[i]];
}
}
}
//cout<<m<<endl;
double dp3[1<<3];
for(int j=0;j<(1<<3);j++){
dp3[j]=0;
for(int k=0;k<(1<<3);k++)
dp3[j]+=dp2[m][j][k];
}
/*/
cout<<b<<":"<<endl;
for(int j=0;j<(1<<3);j++)
cout<<bitset<3>(j)<<":"<<dp3[j]<<endl;
//*/
//res=max(res,dp3[4]+(dp3[1]+dp3[6]));
//res=max(res,dp3[1]+(dp3[2]+dp3[5]));
//res=max(res,dp3[2]+(dp3[4]+dp3[3]));
double aa=dp3[4]+dp2[m][1][0]+dp3[6]*(y<x);
double bb=dp3[1]+dp2[m][2][0]+dp3[5]*(y<x);
double cc=dp3[2]+dp2[m][4][0]+dp3[3]*(y<x);
for(int i=1;i<(1<<m)-1;i++){
int k=b;
for(int j=0;j<m;j++)
if((i>>j)&1) k|=1<<v[j];
//cout<<bitset<3>(b)<<":"<<bitset<3>(i)<<endl;
//for(int j=0;j<m;j++) cout<<v[j]<<endl;
//cout<<b<<":"<<k<<endl;
assert(k!=b);
{
double d=1.0;
for(int j=0;j<m;j++){
if((i>>j)&1) d*=s[v[j]];
else d*=r[v[j]];
}
//res=max(res,d*dfs(k)+aa);
aa+=d*dfs(k);
}
{
double d=1.0;
for(int j=0;j<m;j++){
if((i>>j)&1) d*=r[v[j]];
else d*=p[v[j]];
}
//res=max(res,d*dfs(k)+bb);
bb+=d*dfs(k);
}
{
double d=1.0;
for(int j=0;j<m;j++){
if((i>>j)&1) d*=p[v[j]];
else d*=s[v[j]];
}
//res=max(res,d*dfs(k)+cc);
cc+=d*dfs(k);
}
}
//cout<<aa<<":"<<dp3[5]<<endl;
//cout<<bb<<":"<<dp3[3]<<endl;
//cout<<cc<<":"<<dp3[6]<<endl;
double res=max({aa,bb,cc});
if(y<x) res+=dp3[7];
//cout<<b<<":"<<res<<endl;
return dp[b]=res;
};
printf("%.12f\n",dfs(0));
return 0;
}
|
J: Horizontal-Vertical Permutation
Problem Statement
You are given a positive integer N. Your task is to determine if there exists a square matrix A whose dimension is N that satisfies the following conditions and provide an example of such matrices if it exists. A_{i, j} denotes the element of matrix A at the i-th row and j-th column.
* For all i, j (1 \leq i, j \leq N), A_{i, j} is an integer that satisfies 1 \leq A_{i, j} \leq 2N - 1.
* For all k = 1, 2, ..., N, a set consists of 2N - 1 elements from the k-th row or k-th column is \\{1, 2, ..., 2N - 1\\}.
If there are more than one possible matrices, output any of them.
Input
N
Input consists of one line, which contains the integer N that is the size of a square matrix to construct.
Constraint
* N is an integer that satisfies 1 \leq N \leq 500.
Output
Output `No` in a single line if such a square matrix does not exist.
If such a square matrix A exists, output `Yes` on the first line and A after that. More specifically, follow the following format.
Yes
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
:
A_{N, 1} A_{N, 2} ... A_{N, N}
Sample Input 1
4
Output for Sample Input 1
Yes
2 6 3 7
4 5 2 1
1 7 5 6
5 3 4 2
Sample Input 2
3
Output for Sample Input 2
No
Example
Input
4
Output
Yes
2 6 3 7
4 5 2 1
1 7 5 6
5 3 4 2
|
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
int c[N][N],n;
int main() {
scanf("%d",&n);
if(n==1) printf("Yes\n1\n");
else {
if(n&1) printf("No\n");
else {
printf("Yes\n");
for(int i=1;i<n;i++) c[i][1]=c[n-1][i+1]=i;
for(int i=n-2;i>=2;i--) {
for(int j=2;j<=i;j++) c[i][j]=c[i+1][j-1];
}
for(int i=1;i<n;i++) c[n][i]=c[i][i];
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
if(i<j) c[i][j]=c[j][i]+n-1;
for(int i=1;i<=n;i++) c[i][i]=2*n-1;
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++) printf("%d%c",c[i][j],j==n?'\n':' ');
}
}
return 0;
}
|
For given two sequences $X$ and $Y$, a sequence $Z$ is a common subsequence of $X$ and $Y$ if $Z$ is a subsequence of both $X$ and $Y$. For example, if $X = \\{a,b,c,b,d,a,b\\}$ and $Y = \\{b,d,c,a,b,a\\}$, the sequence $\\{b,c,a\\}$ is a common subsequence of both $X$ and $Y$. On the other hand, the sequence $\\{b,c,a\\}$ is not a longest common subsequence (LCS) of $X$ and $Y$, since it has length 3 and the sequence $\\{b,c,b,a\\}$, which is also common to both $X$ and $Y$, has length 4. The sequence $\\{b,c,b,a\\}$ is an LCS of $X$ and $Y$, since there is no common subsequence of length 5 or greater.
Write a program which finds the length of LCS of given two sequences $X$ and $Y$. The sequence consists of alphabetical characters.
Constraints
* $1 \leq q \leq 150$
* $1 \leq$ length of $X$ and $Y$ $\leq 1,000$
* $q \leq 20$ if the dataset includes a sequence whose length is more than 100
Input
The input consists of multiple datasets. In the first line, an integer $q$ which is the number of datasets is given. In the following $2 \times q$ lines, each dataset which consists of the two sequences $X$ and $Y$ are given.
Output
For each dataset, print the length of LCS of $X$ and $Y$ in a line.
Example
Input
3
abcbdab
bdcaba
abc
abc
abc
bc
Output
4
3
2
|
def lcs(x,y):
L=[]
for chk in y:
bg_i=0
for i,chr_i in enumerate(L):
cur_i=x.find(chk,bg_i)+1
if not cur_i:
break
L[i]=min(cur_i,chr_i)
bg_i=chr_i
else:
cur_i=x.find(chk,bg_i)+1
if cur_i:
L.append(cur_i)
return len(L)
n=int(input())
ans=[]
for i in range(n):
x=input()
y=input()
ans.append(lcs(x,y))
for i in ans:
print(i)
|
You have final scores of an examination for n students. Calculate standard deviation of the scores s1, s2 ... sn.
The variance Ξ±2 is defined by
Ξ±2 = (βni=1(si - m)2)/n
where m is an average of si. The standard deviation of the scores is the square root of their variance.
Constraints
* n β€ 1000
* 0 β€ si β€ 100
Input
The input consists of multiple datasets. Each dataset is given in the following format:
n
s1 s2 ... sn
The input ends with single zero for n.
Output
For each dataset, print the standard deviation in a line. The output should not contain an absolute error greater than 10-4.
Example
Input
5
70 80 100 90 20
3
80 80 80
0
Output
27.85677655
0.00000000
|
import math
n = int(input())
while not n == 0:
ss = [float(i) for i in input().split(' ')]
m = sum(ss)/n
a2 = sum([(i-m)**2 for i in ss]) / n
print(math.sqrt(a2))
n = int(input())
|
Bhallaladeva was an evil king who ruled the kingdom of Maahishmati. He wanted to erect a 100ft golden statue of himself and he looted gold from several places for this. He even looted his own people, by using the following unfair strategy:
There are N houses in Maahishmati, and the i^th house has Ai gold plates. Each gold plate costs exactly 1 Nimbda, which is the unit of currency in the kingdom of Maahishmati. Bhallaladeva would choose an integer K, and loots all the houses in several steps. In each step:
He would choose a house i which hasn't been looted yet, pay the owner exactly Ai Nimbdas, and take away all the gold plates in that house (Hence, he also ends up looting this house).
He would now choose atmost K houses which haven't been looted yet and take away all the gold plates from these houses without paying a single Nimbda (Yes, he takes all of them for free).
He repeats the above steps until all the N houses have been looted. Your task is to devise a strategy for Bhallaladeva to loot the houses in some order, so that the number of nimbdas he has to pay is minimium. You'll also be given multiple values of K (Q of them to be precise), and you need to find the minimum number of nimbdas for each of these values.
Input
The first line of input consists of a single integer N denoting the number of houses in Maahishmati. The second line of input consists of N space separated integers denoting A1, A2, ..., AN, where Ai denotes the number of gold plates in the i^th house. The third line of input consists of a single integer Q denoting the number of values of K to follow. Each of the following Q lines consist of a single integer, where the value on the i^th line denotes the value of K for the i^th query.
Output
Output exactly Q integers on separate lines, where the output on the i^th line denotes the answer for the i^th value of K.
Constraints
1 β€ N β€ 10^5
1 β€ Q β€ 10^5
0 β€ K β€ N-1
1 β€ Ai β€ 10^4
Example
Input:
4
3 2 1 4
2
0
2
Output:
10
3
Explanation
For the first query, K = 0. Hence, Bhallaladeva cannot take gold plates from any of the houses for free. It will cost him 3 + 2 + 1 + 4 = 10 nimbdas.
For the second query, K = 2. In the first step Bhallaladeva can pay 2 nimbdas for gold plates in house number 2, and take the gold in houses 1 and 4 for free (Note that house 1 has 3 gold plates and house 4 has 4 gold plates). Now, he has looted houses 1, 2 & 4. Now in the second step, he loots house 3, by paying 1 nimbda. Hence, the total cost = 1 + 2 = 3. Note that there might be multiple ways to achieve the minimum cost, and we have explained only one of them.
|
import sys
n = input()
lists = map(int,sys.stdin.readline().split())
lists.sort()
pref = [0]*(n+1)
pref[0] = lists[0]
for i in range(1,n) :
pref[i] = pref[i-1]
pref[i] += lists[i]
for __ in range(input()) :
k = input()
print pref[n/(k+1)] if n%(k+1) else pref[(n/(k+1)-1)]
|
Chef likes cooking. But more than that, he likes to give gifts. And now he wants to give his girlfriend an unforgettable gift. But unfortunately he forgot the password to the safe where the money he saved for the gift is kept.
But he knows how to hack the safe. To do this, you need to correctly answer questions asked by the embedded computer. The computer is very strange, and asks special questions, sometimes it can ask about 10000 question (really weird). Because of this, Chef wants you to write a program that will help him to crack the safe.
The questions are different, but there is only one type of question. Several numbers are given and between them one of three characters: *, +, - can be inserted. Note that in this case there is no priority for the operators, that is, if + is the before multiplication, you must first execute the operation of addition, and then multiplication (1 - 2 * 3 must be interpreted as (1 - 2) * 3 = -3 and not -5). The computer asks the minimum possible value of any valid expression.
Β
Input
The first line of the input contains an integer T denoting the number of test cases. The first line of each test case contains a positive integer N. The second line contains N space separated integers A1, A2, ..., AN denoting the expression without the operators.
Β
Output
For each test case, output a single line containing the minimal value of given expression.
Β
Constraints
1 β€ T β€ 10^5
1 β€ N β€ 10
-9 β€ Ai β€ 9
.
Β
Example
Input:
2
3
1 2 3
1
9
Output:
-4
9
Β
Explanation
Example case 1: 1-2-3 = -4
Scoring
Subtask 1 (15 points): 1 β€ T β€ 10
Subtask 2 (10 points): 1 β€ N β€ 3
Subtask 3 (20 points): 1 β€ Ai β€ 5.
Subtask 4 (35 points): 1 β€ T β€ 10^4
Subtask 5 (20 points): Look at constraints.
|
import sys
def readtestcase():
n = int(sys.stdin.readline())
num = map(int, sys.stdin.readline().split())
mini = num[0]
maxi = num[0]
for i in range(1,len(num)):
omini = mini
mini = min([ mini-num[i], mini+num[i], mini*num[i], maxi-num[i], maxi+num[i], maxi*num[i]])
maxi = max([ omini-num[i], omini+num[i], omini*num[i], maxi-num[i], maxi+num[i], maxi*num[i]])
print mini
t = int(sys.stdin.readline())
for i in range(0,t):
readtestcase()
|
Arunava has learnt to find the sum of first N natural numbers using the expression N(N+1)/2.But now Kartik Sir has asked him to find the sum of floor(N/2) for first N natural numbers where floor(X) is the greatest integer less than or equal to a given real number X.Arunava has not memorized any formula for this. So can you help him.
Input
1st line has an Integer T denoting the number of test cases
Each test Case Contains:
A single integer N on a new line denoting the number of natural number upto which it needs to be summed.
Output
For each test case output a single line containing required sum as the output
Example
Input:
5
1
2
3
4
5
Output:
0
1
2
4
6
CONSTRAINTS:
1 β€ T β€ 100000
1 β€ N β€ 10000
0 β€ S β€ 214783647
Explanation of the fifth test case N=5,
The required sum is floor(1/2)+ floor(2/2)+ floor(3/2)+ floor(4/2)+ floor(5/2)=0+1+1+2+2=6
|
import sys
def main():
answers = [0]*10000
val = 0
for i in xrange(1,5000):
d = i*2
val += d
answers[d] = val-i
answers[d+1] = val
t = int(raw_input())
inp = map(int, sys.stdin.read().split())
out = ""
for _ in inp:
out+=str(answers[_])+"\n"
print out[:-1]
main()
|
Chef wants you to write a calculator program for carrying out some simple mathematical operations. Chef calls the program Calculator Plus Plus.
Input
First line contains an operation in the form : a operator b
Output
Output in a single line the result of the mathematical operation. Print "Invalid Operator" if input operator is none of these +, -, *, /
Constraints
-(10^50)<=a,b<=(10^50)
Example
Input:
10 + 30
Output:
40
Input:
1 % 1
Output:
Invalid Operator
Explanation
In first example, 10 + 30 simply evaluates to 40
In second example, '%' is not a valid opeartor according to our Calculator plus plus program.
|
A=raw_input().split(); op_1=int(A[0]); op_2=int(A[2]);
if A[1]=='+':
print op_1+op_2;
elif A[1]=='-':
print op_1-op_2;
elif A[1]=='*':
print op_1*op_2;
elif A[1]=='/':
print op_1/op_2;
else:
print 'Invalid Operator';
|
Raavan abducted sita in the past, at that time when Ram went to save her wife , he was posed a question by Raavan in binomial theorem :
given N Ram has to find the number of odd coefficients in the expansion of (1+x)^n . As the number given by Raavan was huge, Ram was unable to calculate at that time , so he was forced to save sita through war which resulted in loss of huge troop of monkeys and humans. Now you are given a time machine to travel back to that age. can you solve the question posed by Raavan and avoid the war and save many lives including Raavan.
Input
one line consisting of a number N .
Output
single line denoting your answer to Raavan.
Constraints
1 β€ N β€ 10000000
Example
Input:
3
Output:
4
Explanation
The coefficients for binomial expansion of (1+x)^3 are 1 3 3 1, out of which all are odd ,so answer is 4.
|
print 2**(bin(int(raw_input())).count('1'))
|
Chef recently saw the movie Matrix. He loved the movie overall but he didn't agree with some things in it. Particularly he didn't agree with the bald boy when he declared - There is no spoon. Being a chef, he understands the importance of the spoon and realizes that the universe can't survive without it. Furthermore, he is sure there is a spoon; he saw it in his kitchen this morning. So he has set out to prove the bald boy is wrong and find a spoon in the matrix. He has even obtained a digital map already. Can you help him?
Formally you're given a matrix of lowercase and uppercase Latin letters. Your job is to find out if the word "Spoon" occurs somewhere in the matrix or not. A word is said to be occurred in the matrix if it is presented in some row from left to right or in some column from top to bottom. Note that match performed has to be case insensitive.
Input
The first line of input contains a positive integer T, the number of test cases. After that T test cases follow. The first line of each test case contains two space separated integers R and C, the number of rows and the number of columns of the matrix M respectively. Thereafter R lines follow each containing C characters, the actual digital map itself.
Output
For each test case print one line. If a "Spoon" is found in Matrix, output "There is a spoon!" else output "There is indeed no spoon!" (Quotes only for clarity).
Constraints
1 β€ T β€ 100
1 β€ R, C β€ 100
Sample Input
3
3 6
abDefb
bSpoon
NIKHil
6 6
aaaaaa
ssssss
xuisdP
oooooo
ioowoo
bdylan
6 5
bdfhj
cacac
opqrs
ddddd
india
yucky
Sample Output
There is a spoon!
There is a spoon!
There is indeed no spoon!
Explanation
In the first test case, "Spoon" occurs in the second row. In the second test case, "spOon" occurs in the last column.
|
tc = int(raw_input()) #number of test cases
for t in range(tc):
r, c = map(int,raw_input().split())
L = []
for r1 in range(r):
L.append(raw_input().strip().lower())
findCase = False
for e in L:
if 'spoon' in e:
findCase = True
break
nL = ['']*c
for e in range(c):
for r1 in range(len(L)):
nL[e] += L[r1][e]
for e in nL:
if 'spoon' in e:
findCase = True
break
if findCase:
print 'There is a spoon!'
else:
print 'There is indeed no spoon!'
|
Mishka got an integer array a of length n as a birthday present (what a surprise!).
Mishka doesn't like this present and wants to change it somehow. He has invented an algorithm and called it "Mishka's Adjacent Replacements Algorithm". This algorithm can be represented as a sequence of steps:
* Replace each occurrence of 1 in the array a with 2;
* Replace each occurrence of 2 in the array a with 1;
* Replace each occurrence of 3 in the array a with 4;
* Replace each occurrence of 4 in the array a with 3;
* Replace each occurrence of 5 in the array a with 6;
* Replace each occurrence of 6 in the array a with 5;
* ...
* Replace each occurrence of 10^9 - 1 in the array a with 10^9;
* Replace each occurrence of 10^9 in the array a with 10^9 - 1.
Note that the dots in the middle of this algorithm mean that Mishka applies these replacements for each pair of adjacent integers (2i - 1, 2i) for each i β\{1, 2, β¦, 5 β
10^8\} as described above.
For example, for the array a = [1, 2, 4, 5, 10], the following sequence of arrays represents the algorithm:
[1, 2, 4, 5, 10] β (replace all occurrences of 1 with 2) β [2, 2, 4, 5, 10] β (replace all occurrences of 2 with 1) β [1, 1, 4, 5, 10] β (replace all occurrences of 3 with 4) β [1, 1, 4, 5, 10] β (replace all occurrences of 4 with 3) β [1, 1, 3, 5, 10] β (replace all occurrences of 5 with 6) β [1, 1, 3, 6, 10] β (replace all occurrences of 6 with 5) β [1, 1, 3, 5, 10] β ... β [1, 1, 3, 5, 10] β (replace all occurrences of 10 with 9) β [1, 1, 3, 5, 9]. The later steps of the algorithm do not change the array.
Mishka is very lazy and he doesn't want to apply these changes by himself. But he is very interested in their result. Help him find it.
Input
The first line of the input contains one integer number n (1 β€ n β€ 1000) β the number of elements in Mishka's birthday present (surprisingly, an array).
The second line of the input contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9) β the elements of the array.
Output
Print n integers β b_1, b_2, ..., b_n, where b_i is the final value of the i-th element of the array after applying "Mishka's Adjacent Replacements Algorithm" to the array a. Note that you cannot change the order of elements in the array.
Examples
Input
5
1 2 4 5 10
Output
1 1 3 5 9
Input
10
10000 10 50605065 1 5 89 5 999999999 60506056 1000000000
Output
9999 9 50605065 1 5 89 5 999999999 60506055 999999999
Note
The first example is described in the problem statement.
|
if __name__ == "__main__":
_ = int(input())
arr = [int(num) for num in input().split()]
for i in arr:
if i % 2 == 0:
print(i - 1, end=" ")
else:
print(i, end=" ")
|
There is an infinite board of square tiles. Initially all tiles are white.
Vova has a red marker and a blue marker. Red marker can color a tiles. Blue marker can color b tiles. If some tile isn't white then you can't use marker of any color on it. Each marker must be drained completely, so at the end there should be exactly a red tiles and exactly b blue tiles across the board.
Vova wants to color such a set of tiles that:
* they would form a rectangle, consisting of exactly a+b colored tiles;
* all tiles of at least one color would also form a rectangle.
Here are some examples of correct colorings:
<image>
Here are some examples of incorrect colorings:
<image>
Among all correct colorings Vova wants to choose the one with the minimal perimeter. What is the minimal perimeter Vova can obtain?
It is guaranteed that there exists at least one correct coloring.
Input
A single line contains two integers a and b (1 β€ a, b β€ 10^{14}) β the number of tiles red marker should color and the number of tiles blue marker should color, respectively.
Output
Print a single integer β the minimal perimeter of a colored rectangle Vova can obtain by coloring exactly a tiles red and exactly b tiles blue.
It is guaranteed that there exists at least one correct coloring.
Examples
Input
4 4
Output
12
Input
3 9
Output
14
Input
9 3
Output
14
Input
3 6
Output
12
Input
506 2708
Output
3218
Note
The first four examples correspond to the first picture of the statement.
Note that for there exist multiple correct colorings for all of the examples.
In the first example you can also make a rectangle with sides 1 and 8, though its perimeter will be 18 which is greater than 8.
In the second example you can make the same resulting rectangle with sides 3 and 4, but red tiles will form the rectangle with sides 1 and 3 and blue tiles will form the rectangle with sides 3 and 3.
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e14;
const long long oo = (1ll << 63) - 1;
long long a, b, ab;
vector<long long> A, B, AB;
int tknp(const long long& a, const long long& b) {
int l = lower_bound(AB.begin(), AB.end(), a) - AB.begin(), r = AB.size() - 1;
while (l < r) {
int m = l + r + 1 >> 1;
if (ab / AB[m] < b)
r = m - 1;
else
l = m;
}
return AB[l] >= a && ab / AB[l] >= b ? l : -1;
}
long long sol() {
long long res = oo;
for (int i = 0, _n = (A.size()); i < _n; i++) {
long long x = A[i], y = a / x;
long long t = tknp(x, y);
if (t < 0) continue;
res = min(res, AB[t] + ab / AB[t]);
}
return res;
}
void calc() {
long long lim = sqrt(a + b);
for (long long i = 1; i <= lim; i++) {
if (a % i == 0) A.push_back(i);
if (b % i == 0) B.push_back(i);
if (ab % i == 0) AB.push_back(i);
}
sort(A.begin(), A.end());
sort(B.begin(), B.end());
sort(AB.begin(), AB.end());
}
int main() {
cin >> a >> b;
ab = a + b;
calc();
long long t1 = sol();
swap(a, b);
swap(A, B);
cout << min(t1, sol()) * 2;
}
|
As you know, the most intelligent beings on the Earth are, of course, cows. This conclusion was reached long ago by the Martian aliens, as well as a number of other intelligent civilizations from outer space.
Sometimes cows gather into cowavans. This seems to be seasonal. But at this time the cows become passive and react poorly to external stimuli. A cowavan is a perfect target for the Martian scientific saucer, it's time for large-scale abductions, or, as the Martians say, raids. Simply put, a cowavan is a set of cows in a row.
If we number all cows in the cowavan with positive integers from 1 to n, then we can formalize the popular model of abduction, known as the (a, b)-Cowavan Raid: first they steal a cow number a, then number a + b, then β number a + 2Β·b, and so on, until the number of an abducted cow exceeds n. During one raid the cows are not renumbered.
The aliens would be happy to place all the cows on board of their hospitable ship, but unfortunately, the amount of cargo space is very, very limited. The researchers, knowing the mass of each cow in the cowavan, made p scenarios of the (a, b)-raid. Now they want to identify the following thing for each scenario individually: what total mass of pure beef will get on board of the ship. All the scenarios are independent, in the process of performing the calculations the cows are not being stolen.
<image>
Input
The first line contains the only positive integer n (1 β€ n β€ 3Β·105) β the number of cows in the cowavan.
The second number contains n positive integer wi, separated by spaces, where the i-th number describes the mass of the i-th cow in the cowavan (1 β€ wi β€ 109).
The third line contains the only positive integer p β the number of scenarios of (a, b)-raids (1 β€ p β€ 3Β·105).
Each following line contains integer parameters a and b of the corresponding scenario (1 β€ a, b β€ n).
Output
Print for each scenario of the (a, b)-raid the total mass of cows, that can be stolen using only this scenario.
Please, do not use the %lld specificator to read or write 64-bit integers in Π‘++. It is recommended to use the cin, cout streams of the %I64d specificator.
Examples
Input
3
1 2 3
2
1 1
1 2
Output
6
4
Input
4
2 3 5 7
3
1 3
2 3
2 2
Output
9
3
10
|
#include <bits/stdc++.h>
using namespace std;
struct reqest {
long long a, b, ind;
};
bool comp(reqest a, reqest b) {
if (a.b == b.b) return a.a < b.a;
return a.b < b.b;
}
int main() {
long long n;
scanf("%lld", &n);
vector<long long> w(n);
for (int i = 0; i < n; ++i) scanf("%lld", &w[i]);
long long m;
scanf("%lld", &m);
vector<reqest> req(m);
for (int i = 0; i < m; ++i) {
scanf("%lld%lld", &req[i].a, &req[i].b);
--req[i].a;
req[i].ind = i;
}
sort(req.begin(), req.end(), comp);
long long c = sqrt(n);
vector<long long> ans(m);
vector<long long> dp(n);
for (int i = 0; i < req.size(); ++i) {
if (req[i].b > c) {
long long sum = 0;
for (int j = req[i].a; j < n; j += req[i].b) {
sum += w[j];
}
ans[req[i].ind] = sum;
} else {
long long res = 0;
if (i != 0 && req[i - 1].b == req[i].b) {
res = dp[req[i].a];
} else {
res = dp[req[i].a];
dp.assign(n, 0);
for (int j = n - 1; j >= 0; --j) {
dp[j] = w[j];
if (j + req[i].b < n) {
dp[j] += dp[j + req[i].b];
}
}
res = dp[req[i].a];
}
ans[req[i].ind] = res;
}
}
for (int i = 0; i < ans.size(); ++i) printf("%lld\n", ans[i]);
puts("");
return 0;
}
|
You are given a string s, consisting of n lowercase Latin letters.
A substring of string s is a continuous segment of letters from s. For example, "defor" is a substring of "codeforces" and "fors" is not.
The length of the substring is the number of letters in it.
Let's call some string of length n diverse if and only if there is no letter to appear strictly more than \frac n 2 times. For example, strings "abc" and "iltlml" are diverse and strings "aab" and "zz" are not.
Your task is to find any diverse substring of string s or report that there is none. Note that it is not required to maximize or minimize the length of the resulting substring.
Input
The first line contains a single integer n (1 β€ n β€ 1000) β the length of string s.
The second line is the string s, consisting of exactly n lowercase Latin letters.
Output
Print "NO" if there is no diverse substring in the string s.
Otherwise the first line should contain "YES". The second line should contain any diverse substring of string s.
Examples
Input
10
codeforces
Output
YES
code
Input
5
aaaaa
Output
NO
Note
The first example has lots of correct answers.
Please, restrain yourself from asking if some specific answer is correct for some specific test or not, these questions always lead to "No comments" answer.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
string s;
cin >> n >> s;
for (int i = 1; i < n; ++i) {
if (s[i] != s[i - 1]) {
cout << "YES" << endl;
cout << s.substr(i - 1, 2);
return 0;
}
}
cout << "NO" << endl;
return 0;
}
|
Polycarp loves ciphers. He has invented his own cipher called repeating.
Repeating cipher is used for strings. To encrypt the string s=s_{1}s_{2} ... s_{m} (1 β€ m β€ 10), Polycarp uses the following algorithm:
* he writes down s_1 ones,
* he writes down s_2 twice,
* he writes down s_3 three times,
* ...
* he writes down s_m m times.
For example, if s="bab" the process is: "b" β "baa" β "baabbb". So the encrypted s="bab" is "baabbb".
Given string t β the result of encryption of some string s. Your task is to decrypt it, i. e. find the string s.
Input
The first line contains integer n (1 β€ n β€ 55) β the length of the encrypted string. The second line of the input contains t β the result of encryption of some string s. It contains only lowercase Latin letters. The length of t is exactly n.
It is guaranteed that the answer to the test exists.
Output
Print such string s that after encryption it equals t.
Examples
Input
6
baabbb
Output
bab
Input
10
ooopppssss
Output
oops
Input
1
z
Output
z
|
try:
t = int(input())
s = input()
_ = 1
i = 0
l = []
while((i)<=(len(s)-1)):
#print(i)
l.append(s[i])
_+=1
i = i+_
s = "".join(l)
print(s)
except:
pass
|
An array b is called to be a subarray of a if it forms a continuous subsequence of a, that is, if it is equal to a_l, a_{l + 1}, β¦, a_r for some l, r.
Suppose m is some known constant. For any array, having m or more elements, let's define it's beauty as the sum of m largest elements of that array. For example:
* For array x = [4, 3, 1, 5, 2] and m = 3, the 3 largest elements of x are 5, 4 and 3, so the beauty of x is 5 + 4 + 3 = 12.
* For array x = [10, 10, 10] and m = 2, the beauty of x is 10 + 10 = 20.
You are given an array a_1, a_2, β¦, a_n, the value of the said constant m and an integer k. Your need to split the array a into exactly k subarrays such that:
* Each element from a belongs to exactly one subarray.
* Each subarray has at least m elements.
* The sum of all beauties of k subarrays is maximum possible.
Input
The first line contains three integers n, m and k (2 β€ n β€ 2 β
10^5, 1 β€ m, 2 β€ k, m β
k β€ n) β the number of elements in a, the constant m in the definition of beauty and the number of subarrays to split to.
The second line contains n integers a_1, a_2, β¦, a_n (-10^9 β€ a_i β€ 10^9).
Output
In the first line, print the maximum possible sum of the beauties of the subarrays in the optimal partition.
In the second line, print k-1 integers p_1, p_2, β¦, p_{k-1} (1 β€ p_1 < p_2 < β¦ < p_{k-1} < n) representing the partition of the array, in which:
* All elements with indices from 1 to p_1 belong to the first subarray.
* All elements with indices from p_1 + 1 to p_2 belong to the second subarray.
* β¦.
* All elements with indices from p_{k-1} + 1 to n belong to the last, k-th subarray.
If there are several optimal partitions, print any of them.
Examples
Input
9 2 3
5 2 5 2 4 1 1 3 2
Output
21
3 5
Input
6 1 4
4 1 3 2 2 3
Output
12
1 3 5
Input
2 1 2
-1000000000 1000000000
Output
0
1
Note
In the first example, one of the optimal partitions is [5, 2, 5], [2, 4], [1, 1, 3, 2].
* The beauty of the subarray [5, 2, 5] is 5 + 5 = 10.
* The beauty of the subarray [2, 4] is 2 + 4 = 6.
* The beauty of the subarray [1, 1, 3, 2] is 3 + 2 = 5.
The sum of their beauties is 10 + 6 + 5 = 21.
In the second example, one optimal partition is [4], [1, 3], [2, 2], [3].
|
from operator import itemgetter
from itertools import accumulate
from sys import stdin, stdout
n, m, k = [int(x) for x in stdin.readline().split()]
a = [int(x) for x in stdin.readline().split()]
id = [x for x in range(n)]
b = list(zip(a, id))
a.sort(reverse = True)
b.sort(reverse = True)
c = [p[1] for p in b[:m*k]]
c.sort()
print(list(accumulate(a[:m*k]))[-1])
for x in [x + 1 for x in c][m-1::m][:k-1]:
print(x, end = ' ')
|
Recently Vasya learned that, given two points with different x coordinates, you can draw through them exactly one parabola with equation of type y = x^2 + bx + c, where b and c are reals. Let's call such a parabola an U-shaped one.
Vasya drew several distinct points with integer coordinates on a plane and then drew an U-shaped parabola through each pair of the points that have different x coordinates. The picture became somewhat messy, but Vasya still wants to count how many of the parabolas drawn don't have any drawn point inside their internal area. Help Vasya.
The internal area of an U-shaped parabola is the part of the plane that lies strictly above the parabola when the y axis is directed upwards.
Input
The first line contains a single integer n (1 β€ n β€ 100 000) β the number of points.
The next n lines describe the points, the i-th of them contains two integers x_i and y_i β the coordinates of the i-th point. It is guaranteed that all points are distinct and that the coordinates do not exceed 10^6 by absolute value.
Output
In the only line print a single integer β the number of U-shaped parabolas that pass through at least two of the given points and do not contain any of the given points inside their internal area (excluding the parabola itself).
Examples
Input
3
-1 0
0 2
1 0
Output
2
Input
5
1 0
1 -1
0 -1
-1 0
-1 -1
Output
1
Note
On the pictures below all U-shaped parabolas that pass through at least two given points are drawn for each of the examples. The U-shaped parabolas that do not have any given point inside their internal area are drawn in red.
<image> The first example. <image> The second example.
|
#include <bits/stdc++.h>
using namespace std;
long long mod = (1000000007LL);
inline long long Mod(long long a, long long b) { return (a % b); }
inline long long poww(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
long long gcd(long long a, long long b) {
while (b) {
a %= b, swap(a, b);
}
return a;
}
void read(vector<long long> &w, long long n) {
w.resize(n);
for (long long i = 0; i < n; i++) cin >> w[i];
}
void print(vector<long long> &w) {
for (long long i = 0; i < (long long)(w).size(); i++) {
if (i == (long long)(w).size() - 1)
cout << w[i] << "\n";
else
cout << w[i] << " ";
}
}
long long prodmod(vector<long long> w);
long long summod(vector<long long> w);
long long n;
long long cross(pair<long long, long long> A, pair<long long, long long> B,
pair<long long, long long> O) {
return (A.first - O.first) * (B.second - O.second) -
(A.second - O.second) * (B.first - O.first);
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
vector<pair<long long, long long> > v;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
v.push_back(pair<long long, long long>(x, y - x * x));
}
vector<pair<long long, long long> > upper;
sort(begin(v), end(v));
v.erase(unique(begin(v), end(v)), v.end());
for (long long i = 0; i < (long long)(v).size(); i++) {
while ((long long)(upper).size() >= 2 and
cross(upper[(long long)(upper).size() - 2], v[i], upper.back()) <= 0)
upper.pop_back();
upper.push_back(v[i]);
}
long long ans = 0;
for (long long i = 0; i < (long long)(upper).size() - 1; i++)
if (upper[i].first != upper[i + 1].first) ans++;
cout << ans << "\n";
}
long long summod(vector<long long> w) {
long long curr = 0;
for (long long i = 0; i < (long long)(w).size(); i++) {
curr = (curr + w[i]) % mod;
if (curr < 0) curr += mod;
}
return curr;
}
long long prodmod(vector<long long> w) {
long long curr = 1;
for (long long i = 0; i < (long long)(w).size(); i++) {
if (w[i] >= mod) w[i] %= mod;
curr = (curr * w[i]) % mod;
if (curr < 0) curr += mod;
}
return curr;
}
|
Alice and Bob are playing a game with n piles of stones. It is guaranteed that n is an even number. The i-th pile has a_i stones.
Alice and Bob will play a game alternating turns with Alice going first.
On a player's turn, they must choose exactly n/2 nonempty piles and independently remove a positive number of stones from each of the chosen piles. They can remove a different number of stones from the piles in a single turn. The first player unable to make a move loses (when there are less than n/2 nonempty piles).
Given the starting configuration, determine who will win the game.
Input
The first line contains one integer n (2 β€ n β€ 50) β the number of piles. It is guaranteed that n is an even number.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 50) β the number of stones in the piles.
Output
Print a single string "Alice" if Alice wins; otherwise, print "Bob" (without double quotes).
Examples
Input
2
8 8
Output
Bob
Input
4
3 1 4 1
Output
Alice
Note
In the first example, each player can only remove stones from one pile (2/2=1). Alice loses, since Bob can copy whatever Alice does on the other pile, so Alice will run out of moves first.
In the second example, Alice can remove 2 stones from the first pile and 3 stones from the third pile on her first move to guarantee a win.
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100;
int a[maxn];
int n;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
for (int i = 2; i <= n / 2 + 1; i++) {
if (a[i] != a[i - 1]) {
cout << "Alice" << endl;
return 0;
}
}
cout << "Bob" << endl;
return 0;
}
|
This problem is actually a subproblem of problem G from the same contest.
There are n candies in a candy box. The type of the i-th candy is a_i (1 β€ a_i β€ n).
You have to prepare a gift using some of these candies with the following restriction: the numbers of candies of each type presented in a gift should be all distinct (i. e. for example, a gift having two candies of type 1 and two candies of type 2 is bad).
It is possible that multiple types of candies are completely absent from the gift. It is also possible that not all candies of some types will be taken to a gift.
Your task is to find out the maximum possible size of the single gift you can prepare using the candies you have.
You have to answer q independent queries.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer q (1 β€ q β€ 2 β
10^5) β the number of queries. Each query is represented by two lines.
The first line of each query contains one integer n (1 β€ n β€ 2 β
10^5) β the number of candies.
The second line of each query contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ n), where a_i is the type of the i-th candy in the box.
It is guaranteed that the sum of n over all queries does not exceed 2 β
10^5.
Output
For each query print one integer β the maximum possible size of the single gift you can compose using candies you got in this query with the restriction described in the problem statement.
Example
Input
3
8
1 4 8 4 5 6 3 8
16
2 1 3 3 4 3 4 4 1 3 2 2 2 4 1 1
9
2 2 4 4 4 7 7 7 7
Output
3
10
9
Note
In the first query, you can prepare a gift with two candies of type 8 and one candy of type 5, totalling to 3 candies.
Note that this is not the only possible solution β taking two candies of type 4 and one candy of type 6 is also valid.
|
for _ in range(int(raw_input())):
n=int(raw_input())
l=[int(i) for i in raw_input().split()]
from collections import Counter
c=Counter(l)
# print(c)
l=[c[i] for i in c]
l.sort(reverse=1)
from collections import defaultdict
d=defaultdict(int)
for i in l:
if not d[i]:
d[i]=1
else:
while i>0 and d[i]:
i-=1
d[i]=1
sm=0
for i in d:
sm+=i
print(sm)
|
Amugae has a sentence consisting of n words. He want to compress this sentence into one word. Amugae doesn't like repetitions, so when he merges two words into one word, he removes the longest prefix of the second word that coincides with a suffix of the first word. For example, he merges "sample" and "please" into "samplease".
Amugae will merge his sentence left to right (i.e. first merge the first two words, then merge the result with the third word and so on). Write a program that prints the compressed word after the merging process ends.
Input
The first line contains an integer n (1 β€ n β€ 10^5), the number of the words in Amugae's sentence.
The second line contains n words separated by single space. Each words is non-empty and consists of uppercase and lowercase English letters and digits ('A', 'B', ..., 'Z', 'a', 'b', ..., 'z', '0', '1', ..., '9'). The total length of the words does not exceed 10^6.
Output
In the only line output the compressed word after the merging process ends as described in the problem.
Examples
Input
5
I want to order pizza
Output
Iwantorderpizza
Input
5
sample please ease in out
Output
sampleaseinout
|
/*loltyleronedotcomdiscountcodealpha*/
import java.io.*;
import java.util.*;
public class Main {
public static void main (String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
StringBuilder sb = new StringBuilder();
for(int i=0;i<n;i++) {
String s = sc.next();
int[] lps = getLps(s + "?" + sb.substring(Math.max(0, sb.length() - s.length())));
sb.append(s.substring(lps[lps.length-1]));
}
System.out.println(sb);
}
static int[] getLps(String pattern) {
int len = pattern.length();
int[] lps = new int[len];
int j = 0;
for(int i=1;i<len;i++) {
while(j > 0 && pattern.charAt(i) != pattern.charAt(j)) {
j = lps[j - 1];
}
if(pattern.charAt(i) == pattern.charAt(j)) {
j++;
}
lps[i] = j;
}
return lps;
}
}
|
Three planets X, Y and Z within the Alpha planetary system are inhabited with an advanced civilization. The spaceports of these planets are connected by interplanetary space shuttles. The flight scheduler should decide between 1, 2 and 3 return flights for every existing space shuttle connection. Since the residents of Alpha are strong opponents of the symmetry, there is a strict rule that any two of the spaceports connected by a shuttle must have a different number of flights.
For every pair of connected spaceports, your goal is to propose a number 1, 2 or 3 for each shuttle flight, so that for every two connected spaceports the overall number of flights differs.
You may assume that:
1) Every planet has at least one spaceport
2) There exist only shuttle flights between spaceports of different planets
3) For every two spaceports there is a series of shuttle flights enabling traveling between them
4) Spaceports are not connected by more than one shuttle
Input
The first row of the input is the integer number N (3 β€ N β€ 100 000), representing overall number of spaceports. The second row is the integer number M (2 β€ M β€ 100 000) representing number of shuttle flight connections.
Third row contains N characters from the set \\{X, Y, Z\}. Letter on I^{th} position indicates on which planet is situated spaceport I. For example, "XYYXZZ" indicates that the spaceports 0 and 3 are located at planet X, spaceports 1 and 2 are located at Y, and spaceports 4 and 5 are at Z.
Starting from the fourth row, every row contains two integer numbers separated by a whitespace. These numbers are natural numbers smaller than N and indicate the numbers of the spaceports that are connected. For example, "12\ 15" indicates that there is a shuttle flight between spaceports 12 and 15.
Output
The same representation of shuttle flights in separate rows as in the input, but also containing a third number from the set \{1, 2, 3\} standing for the number of shuttle flights between these spaceports.
Example
Input
10
15
XXXXYYYZZZ
0 4
0 5
0 6
4 1
4 8
1 7
1 9
7 2
7 5
5 3
6 2
6 9
8 2
8 3
9 3
Output
0 4 2
0 5 2
0 6 2
4 1 1
4 8 1
1 7 2
1 9 3
7 2 2
7 5 1
5 3 1
6 2 1
6 9 1
8 2 3
8 3 1
9 3 1
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int N, M;
int x[MAXN], y[MAXN];
vector<pair<int, int> > adj[MAXN], ch[MAXN];
char part[MAXN];
int label[MAXN];
int clr[MAXN];
int ans[MAXN];
void load() {
scanf("%d%d%s", &N, &M, part);
for (int i = 0; i < M; i++) {
scanf("%d%d", x + i, y + i);
adj[x[i]].push_back({y[i], i});
adj[y[i]].push_back({x[i], i});
}
}
pair<int, int> dfs(int x, int p, int c) {
clr[x] = c;
pair<int, int> res = {-1, -1};
for (auto it : adj[x])
if (clr[it.first] == -1) {
ch[x].push_back(it);
pair<int, int> tmp = dfs(it.first, x, c ^ 1);
if (tmp.first != -1) res = tmp;
} else if (clr[it.first] == clr[x])
res = {x, it.second};
return res;
}
void add(int &x, int y) {
x += y;
if (x >= 3)
x -= 3;
else if (x < 0)
x += 3;
}
int calc(int x) {
int curr = label[x];
for (auto it : ch[x]) {
int tmp = calc(it.first);
ans[it.second] = tmp;
add(curr, -tmp);
}
return curr;
}
void finish() {
vector<int> sum(N, 0);
for (int i = 0; i < M; i++) {
if (!ans[i]) ans[i] = 3;
printf("%d %d %d\n", x[i], y[i], ans[i]);
sum[x[i]] += ans[i];
sum[y[i]] += ans[i];
}
for (int i = 0; i < M; i++) assert(sum[x[i]] != sum[y[i]]);
exit(0);
}
void bipartite() {
vector<int> v[2];
for (int i = 0; i < N; i++) v[clr[i]].push_back(i);
int big = v[0].size() > v[1].size() ? 0 : 1;
int sz = v[big].size();
int twos = sz % 2 ? (sz - 3) / 2 : sz / 2;
for (int i = 0; i < sz; i++) label[v[big][i]] = (i < twos) + 1;
assert(!calc(0));
finish();
}
void solve() {
for (int i = 0; i < N; i++) label[i] = part[i] - 'X';
memset(clr, -1, sizeof clr);
pair<int, int> edge = dfs(0, -1, 0);
if (edge.first == -1) bipartite();
for (int i = 0; i < 3; i++) {
ans[edge.second] = i;
int u = edge.first;
int v = x[edge.second] ^ y[edge.second] ^ u;
add(label[u], -i);
add(label[v], -i);
if (!calc(0)) finish();
add(label[u], i);
add(label[v], i);
}
assert(false);
}
int main() {
load();
solve();
return 0;
}
|
Ujan needs some rest from cleaning, so he started playing with infinite sequences. He has two integers n and k. He creates an infinite sequence s by repeating the following steps.
1. Find k smallest distinct positive integers that are not in s. Let's call them u_{1}, u_{2}, β¦, u_{k} from the smallest to the largest.
2. Append u_{1}, u_{2}, β¦, u_{k} and β_{i=1}^{k} u_{i} to s in this order.
3. Go back to the first step.
Ujan will stop procrastinating when he writes the number n in the sequence s. Help him find the index of n in s. In other words, find the integer x such that s_{x} = n. It's possible to prove that all positive integers are included in s only once.
Input
The first line contains a single integer t (1 β€ t β€ 10^{5}), the number of test cases.
Each of the following t lines contains two integers n and k (1 β€ n β€ 10^{18}, 2 β€ k β€ 10^{6}), the number to be found in the sequence s and the parameter used to create the sequence s.
Output
In each of the t lines, output the answer for the corresponding test case.
Example
Input
2
10 2
40 5
Output
11
12
Note
In the first sample, s = (1, 2, 3, 4, 5, 9, 6, 7, 13, 8, 10, 18, β¦). 10 is the 11-th number here, so the answer is 11.
In the second sample, s = (1, 2, 3, 4, 5, 15, 6, 7, 8, 9, 10, 40, β¦).
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e7 + 19;
long long h[M], g[M];
vector<int> buc;
int gethash(long long a) {
int x = a % M;
while (h[x] && h[x] != a) x = (x + 1) % M;
return x;
}
long long n, k, T;
long long lim = 1000000;
long long f(long long n) {
if (n < k * (k + 1) / 2) return 0;
int k1 = gethash(n);
if (h[k1]) return g[k1];
h[k1] = n;
buc.push_back(k1);
long long n1 = n - k * (k + 1) / 2, q = n1 % k;
long long x1 = n1 / k + k + (q != 0), x2 = q ? x1 - q : x1 - k;
if (q == 0) {
long long z = f(x1);
return g[k1] = (x1 - z) / k;
} else {
long long z1 = f(x1), z2 = f(x2 - 1);
long long ans = (x1 - z1) / k;
if (z1 == z2 && (x1 - z1) % k == 0) ans--;
return g[k1] = ans;
}
}
int main() {
scanf("%lld", &T);
for (; T--;) {
scanf("%lld%lld", &n, &k);
while (buc.size()) h[buc.back()] = g[buc.back()] = 0, buc.pop_back();
if (f(n) > f(n - 1)) {
printf("%lld\n", (k + 1) * f(n));
continue;
} else {
long long n1 = n - f(n), ans = n1 / k * (k + 1);
if (n1 % k == 0)
ans--;
else
ans += n1 % k;
printf("%lld\n", ans);
}
}
}
|
Your program fails again. This time it gets "Wrong answer on test 233"
.
This is the easier version of the problem. In this version 1 β€ n β€ 2000. You can hack this problem only if you solve and lock both problems.
The problem is about a test containing n one-choice-questions. Each of the questions contains k options, and only one of them is correct. The answer to the i-th question is h_{i}, and if your answer of the question i is h_{i}, you earn 1 point, otherwise, you earn 0 points for this question. The values h_1, h_2, ..., h_n are known to you in this problem.
However, you have a mistake in your program. It moves the answer clockwise! Consider all the n answers are written in a circle. Due to the mistake in your program, they are shifted by one cyclically.
Formally, the mistake moves the answer for the question i to the question i mod n + 1. So it moves the answer for the question 1 to question 2, the answer for the question 2 to the question 3, ..., the answer for the question n to the question 1.
We call all the n answers together an answer suit. There are k^n possible answer suits in total.
You're wondering, how many answer suits satisfy the following condition: after moving clockwise by 1, the total number of points of the new answer suit is strictly larger than the number of points of the old one. You need to find the answer modulo 998 244 353.
For example, if n = 5, and your answer suit is a=[1,2,3,4,5], it will submitted as a'=[5,1,2,3,4] because of a mistake. If the correct answer suit is h=[5,2,2,3,4], the answer suit a earns 1 point and the answer suite a' earns 4 points. Since 4 > 1, the answer suit a=[1,2,3,4,5] should be counted.
Input
The first line contains two integers n, k (1 β€ n β€ 2000, 1 β€ k β€ 10^9) β the number of questions and the number of possible answers to each question.
The following line contains n integers h_1, h_2, ..., h_n, (1 β€ h_{i} β€ k) β answers to the questions.
Output
Output one integer: the number of answers suits satisfying the given condition, modulo 998 244 353.
Examples
Input
3 3
1 3 1
Output
9
Input
5 5
1 1 4 2 2
Output
1000
Note
For the first example, valid answer suits are [2,1,1], [2,1,2], [2,1,3], [3,1,1], [3,1,2], [3,1,3], [3,2,1], [3,2,2], [3,2,3].
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int MAXN = 2001;
int add(int a, int b) {
if (a + b < 0) return a + b + MOD;
if (a + b >= MOD) return a + b - MOD;
return a + b;
}
int mul(int a, int b) { return (long long)a * b % MOD; }
bool bio[MAXN][2 * MAXN];
int n, k;
int a[MAXN], memo[MAXN][2 * MAXN];
int dp(int i, int diff) {
if (bio[i][diff + n]) return memo[i][diff + n];
bio[i][diff + n] = true;
if (i == n) return memo[i][diff + n] = diff > 0;
int ret = 0;
if (a[i] == a[(i + 1) % n]) {
ret = add(ret, mul(k, dp(i + 1, diff)));
} else {
ret = add(ret, dp(i + 1, diff + 1));
ret = add(ret, dp(i + 1, diff - 1));
ret = add(ret, mul(k - 2, dp(i + 1, diff)));
}
return memo[i][diff + n] = ret;
}
int main(void) {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
printf("%d\n", dp(0, 0));
return 0;
}
|
Polycarp has decided to decorate his room because the New Year is soon. One of the main decorations that Polycarp will install is the garland he is going to solder himself.
Simple garlands consisting of several lamps connected by one wire are too boring for Polycarp. He is going to solder a garland consisting of n lamps and n - 1 wires. Exactly one lamp will be connected to power grid, and power will be transmitted from it to other lamps by the wires. Each wire connectes exactly two lamps; one lamp is called the main lamp for this wire (the one that gets power from some other wire and transmits it to this wire), the other one is called the auxiliary lamp (the one that gets power from this wire). Obviously, each lamp has at most one wire that brings power to it (and this lamp is the auxiliary lamp for this wire, and the main lamp for all other wires connected directly to it).
Each lamp has a brightness value associated with it, the i-th lamp has brightness 2^i. We define the importance of the wire as the sum of brightness values over all lamps that become disconnected from the grid if the wire is cut (and all other wires are still working).
Polycarp has drawn the scheme of the garland he wants to make (the scheme depicts all n lamp and n - 1 wires, and the lamp that will be connected directly to the grid is marked; the wires are placed in such a way that the power can be transmitted to each lamp). After that, Polycarp calculated the importance of each wire, enumerated them from 1 to n - 1 in descending order of their importance, and then wrote the index of the main lamp for each wire (in the order from the first wire to the last one).
The following day Polycarp bought all required components of the garland and decided to solder it β but he could not find the scheme. Fortunately, Polycarp found the list of indices of main lamps for all wires. Can you help him restore the original scheme?
Input
The first line contains one integer n (2 β€ n β€ 2 β
10^5) β the number of lamps.
The second line contains n - 1 integers a_1, a_2, ..., a_{n - 1} (1 β€ a_i β€ n), where a_i is the index of the main lamp for the i-th wire (wires are numbered in descending order of importance).
Output
If it is impossible to restore the original scheme, print one integer -1.
Otherwise print the scheme as follows. In the first line, print one integer k (1 β€ k β€ n) β the index of the lamp that is connected to the power grid. Then print n - 1 lines, each containing two integers x_i and y_i (1 β€ x_i, y_i β€ n, x_i β y_i) β the indices of the lamps connected by some wire. The descriptions of the wires (and the lamps connected by a wire) can be printed in any order. The printed description must correspond to a scheme of a garland such that Polycarp could have written the list a_1, a_2, ..., a_{n - 1} from it. If there are multiple such schemes, output any of them.
Example
Input
6
3 6 3 1 5
Output
3
6 3
6 5
1 3
1 4
5 2
Note
The scheme for the first example (R denotes the lamp connected to the grid, the numbers on wires are their importance values):
<image>
|
#include <bits/stdc++.h>
using namespace std;
vector<bool> vis;
vector<vector<long long>> adj;
void dfs(long long node) {
vis[node] = true;
for (long long child : adj[node]) {
if (vis[child]) continue;
dfs(child);
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> arr(n - 1);
vector<long long> deg(n + 1, 1);
for (long long i = 0; i < n - 1; ++i) {
cin >> arr[i];
++deg[arr[i]];
}
set<pair<long long, long long>> st;
for (long long i = 1; i <= n; ++i) {
if (deg[i] == 1) {
st.insert({i, i});
}
}
cout << arr[0] << '\n';
for (long long i = n - 2; i >= 0; --i) {
const long long node = arr[i];
auto it = st.begin();
long long currMx = it->first;
long long currRoot = it->second;
st.erase(it);
cout << currRoot << " " << node << '\n';
--deg[node];
if (deg[node] == 1) {
st.insert({max(currMx, node), node});
}
}
}
|
Your company was appointed to lay new asphalt on the highway of length n. You know that every day you can either repair one unit of the highway (lay new asphalt over one unit of the highway) or skip repairing.
Skipping the repair is necessary because of the climate. The climate in your region is periodical: there are g days when the weather is good and if you lay new asphalt these days it becomes high-quality pavement; after that, the weather during the next b days is bad, and if you lay new asphalt these days it becomes low-quality pavement; again g good days, b bad days and so on.
You can be sure that you start repairing at the start of a good season, in other words, days 1, 2, ..., g are good.
You don't really care about the quality of the highway, you just want to make sure that at least half of the highway will have high-quality pavement. For example, if the n = 5 then at least 3 units of the highway should have high quality; if n = 4 then at least 2 units should have high quality.
What is the minimum number of days is needed to finish the repair of the whole highway?
Input
The first line contains a single integer T (1 β€ T β€ 10^4) β the number of test cases.
Next T lines contain test cases β one per line. Each line contains three integers n, g and b (1 β€ n, g, b β€ 10^9) β the length of the highway and the number of good and bad days respectively.
Output
Print T integers β one per test case. For each test case, print the minimum number of days required to repair the whole highway if at least half of it should have high quality.
Example
Input
3
5 1 1
8 10 10
1000000 1 1000000
Output
5
8
499999500000
Note
In the first test case, you can just lay new asphalt each day, since days 1, 3, 5 are good.
In the second test case, you can also lay new asphalt each day, since days 1-8 are good.
|
from __future__ import division,print_function
#from sortedcontainers import SortedList
import sys
#sys.__stdout__.flush()
le=sys.__stdin__.read().split("\n")
le.pop()
le=le[::-1]
for k in range(int(le.pop())):
n,b,g=list(map(int,le.pop().split()))
h=(n+1)//2
q=(h-1)//b
r=(h-1)%b+1
#print(r,q)
print(max(r+q*(b+g),n))
|
Petya has a rectangular Board of size n Γ m. Initially, k chips are placed on the board, i-th chip is located in the cell at the intersection of sx_i-th row and sy_i-th column.
In one action, Petya can move all the chips to the left, right, down or up by 1 cell.
If the chip was in the (x, y) cell, then after the operation:
* left, its coordinates will be (x, y - 1);
* right, its coordinates will be (x, y + 1);
* down, its coordinates will be (x + 1, y);
* up, its coordinates will be (x - 1, y).
If the chip is located by the wall of the board, and the action chosen by Petya moves it towards the wall, then the chip remains in its current position.
Note that several chips can be located in the same cell.
For each chip, Petya chose the position which it should visit. Note that it's not necessary for a chip to end up in this position.
Since Petya does not have a lot of free time, he is ready to do no more than 2nm actions.
You have to find out what actions Petya should do so that each chip visits the position that Petya selected for it at least once. Or determine that it is not possible to do this in 2nm actions.
Input
The first line contains three integers n, m, k (1 β€ n, m, k β€ 200) β the number of rows and columns of the board and the number of chips, respectively.
The next k lines contains two integers each sx_i, sy_i ( 1 β€ sx_i β€ n, 1 β€ sy_i β€ m) β the starting position of the i-th chip.
The next k lines contains two integers each fx_i, fy_i ( 1 β€ fx_i β€ n, 1 β€ fy_i β€ m) β the position that the i-chip should visit at least once.
Output
In the first line print the number of operations so that each chip visits the position that Petya selected for it at least once.
In the second line output the sequence of operations. To indicate operations left, right, down, and up, use the characters L, R, D, U respectively.
If the required sequence does not exist, print -1 in the single line.
Examples
Input
3 3 2
1 2
2 1
3 3
3 2
Output
3
DRD
Input
5 4 3
3 4
3 1
3 3
5 3
1 3
1 4
Output
9
DDLUUUURR
|
n,m,k=map(int, input().split())
for i in range(2*k):
map(int, input().split())
ans = (m-1)*'L' + (n-1)*'U'
for i in range(n):
if i%2==0:
ans += 'R'*(m-1)
else:
ans += 'L'*(m-1)
if i < n-1:
ans+='D'
print(len(ans))
print(ans)
|
Leo Jr. draws pictures in his notebook with checkered sheets (that is, each sheet has a regular square grid printed on it). We can assume that the sheets are infinitely large in any direction.
To draw a picture, Leo Jr. colors some of the cells on a sheet gray. He considers the resulting picture beautiful if the following conditions are satisfied:
* The picture is connected, that is, it is possible to get from any gray cell to any other by following a chain of gray cells, with each pair of adjacent cells in the path being neighbours (that is, sharing a side).
* Each gray cell has an even number of gray neighbours.
* There are exactly n gray cells with all gray neighbours. The number of other gray cells can be arbitrary (but reasonable, so that they can all be listed).
Leo Jr. is now struggling to draw a beautiful picture with a particular choice of n. Help him, and provide any example of a beautiful picture.
To output cell coordinates in your answer, assume that the sheet is provided with a Cartesian coordinate system such that one of the cells is chosen to be the origin (0, 0), axes 0x and 0y are orthogonal and parallel to grid lines, and a unit step along any axis in any direction takes you to a neighbouring cell.
Input
The only line contains a single integer n (1 β€ n β€ 500) β the number of gray cells with all gray neighbours in a beautiful picture.
Output
In the first line, print a single integer k β the number of gray cells in your picture. For technical reasons, k should not exceed 5 β
10^5.
Each of the following k lines should contain two integers β coordinates of a gray cell in your picture. All listed cells should be distinct, and the picture should satisdfy all the properties listed above. All coordinates should not exceed 10^9 by absolute value.
One can show that there exists an answer satisfying all requirements with a small enough k.
Example
Input
4
Output
12
1 0
2 0
0 1
1 1
2 1
3 1
0 2
1 2
2 2
3 2
1 3
2 3
Note
The answer for the sample is pictured below:
<image>
|
import sys
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int, minp().split())
def solve():
n = mint()
print((n+1)*3+1)
for i in range(n+1):
print(i,i)
print(1+i,i)
print(i,1+i)
print(n+1,n+1)
#for i in range(mint()):
solve()
|
Berland year consists of m months with d days each. Months are numbered from 1 to m. Berland week consists of w days. The first day of the year is also the first day of the week. Note that the last week of the year might be shorter than w days.
A pair (x, y) such that x < y is ambiguous if day x of month y is the same day of the week as day y of month x.
Count the number of ambiguous pairs.
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of testcases.
Each of the next t lines contains three integers m, d and w (1 β€ m, d, w β€ 10^9) β the number of months in a year, the number of days in a month and the number of days in a week.
Output
Print t integers β for each testcase output the number of pairs (x, y) such that x < y and day x of month y is the same day of the week as day y of month x.
Example
Input
5
6 7 4
10 7 12
12 30 7
1 1 1
3247834 10298779 625324
Output
6
9
5
0
116461800
Note
Here are the pairs for the first test case:
<image>
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
int m, d, w;
cin >> m >> d >> w;
long long mod = w / gcd(d - 1, w);
long long cur = min(m, d) / mod;
long long ans = min(m, d) * cur - mod * (cur + 1) * cur / 2;
cout << ans << '\n';
}
return 0;
}
|
As meticulous Gerald sets the table, Alexander finished another post on Codeforces and begins to respond to New Year greetings from friends. Alexander has n friends, and each of them sends to Alexander exactly one e-card. Let us number his friends by numbers from 1 to n in the order in which they send the cards. Let's introduce the same numbering for the cards, that is, according to the numbering the i-th friend sent to Alexander a card number i.
Alexander also sends cards to friends, but he doesn't look for the new cards on the Net. He simply uses the cards previously sent to him (sometimes, however, he does need to add some crucial details). Initially Alexander doesn't have any cards. Alexander always follows the two rules:
1. He will never send to a firend a card that this friend has sent to him.
2. Among the other cards available to him at the moment, Alexander always chooses one that Alexander himself likes most.
Alexander plans to send to each friend exactly one card. Of course, Alexander can send the same card multiple times.
Alexander and each his friend has the list of preferences, which is a permutation of integers from 1 to n. The first number in the list is the number of the favorite card, the second number shows the second favorite, and so on, the last number shows the least favorite card.
Your task is to find a schedule of sending cards for Alexander. Determine at which moments of time Alexander must send cards to his friends, to please each of them as much as possible. In other words, so that as a result of applying two Alexander's rules, each friend receives the card that is preferred for him as much as possible.
Note that Alexander doesn't choose freely what card to send, but he always strictly follows the two rules.
Input
The first line contains an integer n (2 β€ n β€ 300) β the number of Alexander's friends, equal to the number of cards. Next n lines contain his friends' preference lists. Each list consists of n different integers from 1 to n. The last line contains Alexander's preference list in the same format.
Output
Print n space-separated numbers: the i-th number should be the number of the friend, whose card Alexander receives right before he should send a card to the i-th friend. If there are several solutions, print any of them.
Examples
Input
4
1 2 3 4
4 1 3 2
4 3 1 2
3 4 2 1
3 1 2 4
Output
2 1 1 4
Note
In the sample, the algorithm of actions Alexander and his friends perform is as follows:
1. Alexander receives card 1 from the first friend.
2. Alexander sends the card he has received (at the moment he only has one card, and therefore it is the most preferable for him) to friends with the numbers 2 and 3.
3. Alexander receives card 2 from the second friend, now he has two cards β 1 and 2.
4. Alexander sends a card to the first friend. Despite the fact that Alexander likes card 1 more, he sends card 2 as he cannot send a friend the card sent by that very friend.
5. Alexander receives card 3 from the third friend.
6. Alexander receives card 4 from the fourth friend.
7. Among the cards Alexander has number 3 is his favorite and he sends it to the fourth friend.
Note that Alexander can send cards to multiple friends at a time (in this case the second and the third one). Alexander can send card 3 to the fourth friend after he receives the third card or after he receives the fourth card (both variants are correct).
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int maxn = 100005;
int r[305][305];
int ans[305];
int main() {
int n;
scanf("%d", &n);
int d;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
scanf("%d", &d);
r[i][d] = j;
}
}
for (int i = 1; i <= n; i++) {
scanf("%d", &d);
r[0][d] = i;
}
int tmp1 = 0, tmp2 = 0;
for (int i = 0; i <= n; i++) r[i][0] = n + 1;
for (int i = 1; i <= n; i++) {
if (r[0][tmp1] > r[0][i])
tmp2 = tmp1, tmp1 = i;
else if (r[0][tmp2] > r[0][i])
tmp2 = i;
for (int j = 1; j <= n; j++) {
if (tmp1 != j) {
if (r[j][ans[j]] > r[j][tmp1]) ans[j] = tmp1;
} else if (tmp2) {
if (r[j][ans[j]] > r[j][tmp2]) ans[j] = tmp2;
}
}
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
puts("");
return 0;
}
|
Recently you've discovered a new shooter. They say it has realistic game mechanics.
Your character has a gun with magazine size equal to k and should exterminate n waves of monsters. The i-th wave consists of a_i monsters and happens from the l_i-th moment of time up to the r_i-th moments of time. All a_i monsters spawn at moment l_i and you have to exterminate all of them before the moment r_i ends (you can kill monsters right at moment r_i). For every two consecutive waves, the second wave starts not earlier than the first wave ends (though the second wave can start at the same moment when the first wave ends) β formally, the condition r_i β€ l_{i + 1} holds. Take a look at the notes for the examples to understand the process better.
You are confident in yours and your character's skills so you can assume that aiming and shooting are instant and you need exactly one bullet to kill one monster. But reloading takes exactly 1 unit of time.
One of the realistic mechanics is a mechanic of reloading: when you reload you throw away the old magazine with all remaining bullets in it. That's why constant reloads may cost you excessive amounts of spent bullets.
You've taken a liking to this mechanic so now you are wondering: what is the minimum possible number of bullets you need to spend (both used and thrown) to exterminate all waves.
Note that you don't throw the remaining bullets away after eradicating all monsters, and you start with a full magazine.
Input
The first line contains two integers n and k (1 β€ n β€ 2000; 1 β€ k β€ 10^9) β the number of waves and magazine size.
The next n lines contain descriptions of waves. The i-th line contains three integers l_i, r_i and a_i (1 β€ l_i β€ r_i β€ 10^9; 1 β€ a_i β€ 10^9) β the period of time when the i-th wave happens and the number of monsters in it.
It's guaranteed that waves don't overlap (but may touch) and are given in the order they occur, i. e. r_i β€ l_{i + 1}.
Output
If there is no way to clear all waves, print -1. Otherwise, print the minimum possible number of bullets you need to spend (both used and thrown) to clear all waves.
Examples
Input
2 3
2 3 6
3 4 3
Output
9
Input
2 5
3 7 11
10 12 15
Output
30
Input
5 42
42 42 42
42 43 42
43 44 42
44 45 42
45 45 1
Output
-1
Input
1 10
100 111 1
Output
1
Note
In the first example:
* At the moment 2, the first wave occurs and 6 monsters spawn. You kill 3 monsters and start reloading.
* At the moment 3, the second wave occurs and 3 more monsters spawn. You kill remaining 3 monsters from the first wave and start reloading.
* At the moment 4, you kill remaining 3 monsters from the second wave.
In total, you'll spend 9 bullets.
In the second example:
* At moment 3, the first wave occurs and 11 monsters spawn. You kill 5 monsters and start reloading.
* At moment 4, you kill 5 more monsters and start reloading.
* At moment 5, you kill the last monster and start reloading throwing away old magazine with 4 bullets.
* At moment 10, the second wave occurs and 15 monsters spawn. You kill 5 monsters and start reloading.
* At moment 11, you kill 5 more monsters and start reloading.
* At moment 12, you kill last 5 monsters.
In total, you'll spend 30 bullets.
|
#include <bits/stdc++.h>
using namespace std;
long long const MAXN = 2005;
long long l[MAXN], r[MAXN], a[MAXN];
long long C[MAXN][MAXN];
long long R[MAXN][MAXN];
long long f[MAXN];
signed main() {
long long n, k;
cin >> n >> k;
for (register long long i = 1; i <= n; ++i) cin >> l[i] >> r[i] >> a[i];
l[n + 1] = r[n + 1] = 1e18;
for (register long long i = 1; i <= n; ++i) {
long long nowtim = l[i], res = k, cost = 1;
for (register long long j = i; j <= n; ++j) {
if (nowtim < l[j] && res == 0) res = k, ++cost;
nowtim = max(nowtim, l[j]);
long long tim = (a[j] - res + k - 1) / k;
cost += tim;
nowtim += tim;
res = tim * k + res - a[j];
if (nowtim > r[j]) break;
if (nowtim < l[j + 1]) C[i][j] = cost, R[i][j] = res;
}
}
memset(f, 0x3f, sizeof(f));
f[0] = 0;
for (register long long i = 1; i < n; ++i)
for (register long long j = 1; j <= i; ++j)
if (C[j][i] != 0) f[i] = min(f[i], f[j - 1] + C[j][i] * k);
for (register long long j = 1; j <= n; ++j)
if (C[j][n] != 0) f[n] = min(f[n], f[j - 1] + C[j][n] * k - R[j][n]);
if (f[n] == 0x3f3f3f3f3f3f3f3f)
cout << -1 << endl;
else
cout << f[n] << endl;
return 0;
}
|
There is a game called "Unique Bid Auction". You can read more about it here: https://en.wikipedia.org/wiki/Unique_bid_auction (though you don't have to do it to solve this problem).
Let's simplify this game a bit. Formally, there are n participants, the i-th participant chose the number a_i. The winner of the game is such a participant that the number he chose is unique (i. e. nobody else chose this number except him) and is minimal (i. e. among all unique values of a the minimum one is the winning one).
Your task is to find the index of the participant who won the game (or -1 if there is no winner). Indexing is 1-based, i. e. the participants are numbered from 1 to n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 2 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 β€ n β€ 2 β
10^5) β the number of participants. The second line of the test case contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ n), where a_i is the i-th participant chosen number.
It is guaranteed that the sum of n does not exceed 2 β
10^5 (β n β€ 2 β
10^5).
Output
For each test case, print the answer β the index of the participant who won the game (or -1 if there is no winner). Note that the answer is always unique.
Example
Input
6
2
1 1
3
2 1 3
4
2 2 2 3
1
1
5
2 3 2 4 2
6
1 1 5 5 4 4
Output
-1
2
4
1
2
-1
|
#include <bits/stdc++.h>
#include<string.h>
#include<utility>
#define ll long long int
#include<fstream>
#define pb push_back
#include<vector>
#include<stack>
#define INF INT_MAX
#include <deque>
#define modulo 1000000007
using namespace std;
//Fuck ratings
//Get charasi...Have some ganja
ll checkpalindrome(ll c)
{
string p=to_string(c);
int j = p.size() - 1;
for (int i = 0; i < j; i++, j--)
{
if (p[i] != p[j])
{
return 0;
}
}
return 1;
}
ll isSubsetSum(ll a[], ll n, ll sum)
{
bool t[n + 1][sum + 1];
for (int i = 0; i <= n; i++)
t[i][0] = true;
for (int i = 1; i <= sum; i++)
t[0][i] = false;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= sum; j++) {
if (j < a[i - 1])
t[i][j] = t[i - 1][j];
if (j >= a[i - 1])
t[i][j] = t[i-1 ][j]
||t[i - 1][j - a[i - 1]];
}
}
ll j;
ll diff = INT_MAX,p;
for ( j=sum/2; j>=0; j--)
{
if (t[n][j] == true)
{
diff=sum-j;
break;
}
}
return diff;
}
int max(int a, int b)
{
return (a > b) ? a : b;
}
ll KnapSack(ll W, ll wt[], ll val[], ll n)
{
int i, j;
int t[n + 1][W + 1];
// Build table K[][] in bottom up manner
for (i = 0; i <= n; i++)
{
for (j= 0; j<= W; j++)
{
if (i == 0 || j == 0)
t[i][j] = 0;
else if (wt[i - 1] <= j)
t[i][j] = max(val[i - 1]
+ t[i - 1][j - wt[i - 1]],
t[i - 1][j]);
else
t[i][j] = t[i - 1][j];
}
}
return t[n][W];
}
ll tle(ll a[],ll n, ll m)
{
ll i,j,t[n+1][m+1];
for(i=0;i<=n;i++)
{
for(j=0;j<=m;j++)
{
if(i==0 || j==0) t[i][j]=0;
else if(a[i-1]<=j)
{
t[i][j]=max(1+t[i-1][j-a[i-1]],t[i-1][j]);
}
else
t[i][j]= t[i-1][j];
}
}
return t[n][m];
}
bool isSubSequence(string s, string p, ll n, ll m)
{
int j = 0; // For index of str1 (or subsequence
// Traverse str2 and str1, and compare current character
// of str2 with first unmatched char of str1, if matched
// then move ahead in str1
for (int i=0; i<n&&j<m; i++)
if (p[j] == s[i])
{ cout<<i<<" ";
j++;
}
// If all characters of str1 were found in str2
return (j==m);
}
void track(vector<ll>&a,vector<vector<ll>> &res ,vector<ll>& v,ll idx)
{
res.pb(v);
for(int i=idx;i<a.size();i++)
{
v.pb(a[i]);
track(a,res,v,i+1);
v.pop_back();
}
return ;
}
vector<vector<ll>> call(vector<ll>&a ,ll n)
{
vector<vector<ll>>res;
vector<ll >v;
ll idx=0;
track(a,res,v,idx);
return res;
}
int main()
{ ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t,n;
cin>>t;
while(t--)
{ cin>>n;
int a[n],b[n];
for(int i=0;i<n;i++){
cin>>a[i];
b[i]=a[i];
}
sort(b,b+n);
int ans=0;
for(int i=0;i<n;i++){
if(i==0&&b[i]!=b[i+1]){
ans=b[i];
break;
}
else if(i==n-1&&b[i]!=b[i-1]){
ans=b[i];
break;
}
else if(b[i]!=b[i-1]&&b[i]!=b[i+1]){
ans=b[i];
break;
}
}
if(ans>0){
for(int i=0;i<n;i++){
if(ans==a[i]){
cout<<i+1<<endl;
break;
}
}
}
else
cout<<-1<<endl;
}
}
|
Nezzar buys his favorite snack β n chocolate bars with lengths l_1,l_2,β¦,l_n. However, chocolate bars might be too long to store them properly!
In order to solve this problem, Nezzar designs an interesting process to divide them into small pieces. Firstly, Nezzar puts all his chocolate bars into a black box. Then, he will perform the following operation repeatedly until the maximum length over all chocolate bars does not exceed k.
* Nezzar picks a chocolate bar from the box with probability proportional to its length x.
* After step 1, Nezzar uniformly picks a real number r β (0,x) and divides the chosen chocolate bar into two chocolate bars with lengths r and x-r.
* Lastly, he puts those two new chocolate bars into the black box.
Nezzar now wonders, what is the expected number of operations he will perform to divide his chocolate bars into small pieces.
It can be shown that the answer can be represented as P/Q, where P and Q are coprime integers and Q not β‘ 0 (mod 998 244 353). Print the value of Pβ
Q^{-1} mod 998 244 353.
Input
The first line contains two integers n and k (1 β€ n β€ 50, 1 β€ k β€ 2000).
The second line contains n integers l_1, l_2, β¦, l_n (1 β€ l_i, β_{i=1}^{n} l_i β€ 2000).
Output
Print a single integer β the expected number of operations Nezzar will perform to divide his chocolate bars into small pieces modulo 998 244 353.
Examples
Input
1 1
2
Output
4
Input
1 1
1
Output
0
Input
1 5
1234
Output
15630811
Input
2 1
2 3
Output
476014684
Input
10 33
10 20 30 40 50 60 70 80 90 100
Output
675105648
|
#include<bits/stdc++.h>
#define fo(i,a,b)for(int i=a,_e=b;i<=_e;++i)
#define fd(i,a,b)for(int i=b,_e=a;i>=_e;--i)
using namespace std;
#define fastio ios_base::sync_with_stdio(0);cin.tie(0)
#define FOR(i,m,n) for(int i = (m); i < (n); i++)
#define pb push_back
#define mp make_pair
#define fst first
#define snd second
#define all(v) sort(v.begin(),v.end())
#define sz(v) int(v.size())
const int MOD=1e9+7;
const int mod= 998244353;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll,ll> ii;
#define yes cout<<"YES"<<endl;
#define no cout<<"N0"<<endl;
using namespace std;
const int N=2005,mo=998244353;
int n,k,tot,sum,ans,l;
int len[N],fac[N],ifac[N],f[55][N],g[2][N],h[55][N];
int pw(int x,int y=mo-2){
int t=1;
for(;y;y>>=1,x=(ll)x*x%mo)if(y&1)t=(ll)t*x%mo;
return t;
}
int main(){
n=2000;
fac[0]=1;
fo(i,1,n)fac[i]=(ll)fac[i-1]*i%mo;
ifac[n]=pw(fac[n]);
fd(i,0,n-1)ifac[i]=(ll)ifac[i+1]*(i+1)%mo;
scanf("%d%d",&n,&k);
f[0][0]=1;
fo(i,1,n)scanf("%d",&len[i]),tot+=len[i];
int itot=pw(tot);
fo(i,1,n){
l=len[i];
int lk=(l-1)/k;
fo(p,0,i)fo(j,0,sum+lk)h[p][j]=0;
fo(j,0,lk)g[0][j]=(ll)ifac[j]*pw((ll)(l-j*k)*itot%mo,j)%mo*(j&1?-1:1);
fo(j,1,lk)g[1][j]=(ll)ifac[j-1]*pw((ll)(l-j*k)*itot%mo,j-1)%mo*(j&1?-1:1);
fo(p,0,i-1)fo(j,0,sum){
int v=f[p][j];
if(!v)continue;
fo(q,0,1)fo(k,0,lk)
h[p+q][j+k]=((ll)v*g[q][k]+h[p+q][j+k])%mo;
}
fo(p,0,i)fo(j,0,sum+lk)f[p][j]=h[p][j];
sum+=lk;
}
f[0][0]=0;
fo(p,0,n)fo(i,0,sum)
if(f[p][i])
ans=((ll)f[p][i]*pw((ll)itot*i*k%mo,mo-1-(i-p+1))%mo*fac[i-p]+ans)%mo;
cout<<((ll)-ans+mo)%mo;
}
|
Many people are aware of DMCA β Digital Millennium Copyright Act. But another recently proposed DMCA β Digital Millennium Calculation Act β is much less known.
In this problem you need to find a root of a number according to this new DMCA law.
Input
The input contains a single integer a (1 β€ a β€ 1000000).
Output
Output the result β an integer number.
Examples
Input
1
Output
1
Input
81
Output
9
|
n = int(input())
sumo = n
while n>=10:
sumo = 0
while n!=0:
sumo+=n%10
n//=10
n = sumo
print(sumo)
|
Soroush and Keshi each have a labeled and rooted tree on n vertices. Both of their trees are rooted from vertex 1.
Soroush and Keshi used to be at war. After endless decades of fighting, they finally became allies to prepare a Codeforces round. To celebrate this fortunate event, they decided to make a memorial graph on n vertices.
They add an edge between vertices u and v in the memorial graph if both of the following conditions hold:
* One of u or v is the ancestor of the other in Soroush's tree.
* Neither of u or v is the ancestor of the other in Keshi's tree.
Here vertex u is considered ancestor of vertex v, if u lies on the path from 1 (the root) to the v.
Popping out of nowhere, Mashtali tried to find the maximum clique in the memorial graph for no reason. He failed because the graph was too big.
Help Mashtali by finding the size of the maximum clique in the memorial graph.
As a reminder, clique is a subset of vertices of the graph, each two of which are connected by an edge.
Input
The first line contains an integer t (1β€ tβ€ 3 β
10^5) β the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (2β€ nβ€ 3 β
10^5).
The second line of each test case contains n-1 integers a_2, β¦, a_n (1 β€ a_i < i), a_i being the parent of the vertex i in Soroush's tree.
The third line of each test case contains n-1 integers b_2, β¦, b_n (1 β€ b_i < i), b_i being the parent of the vertex i in Keshi's tree.
It is guaranteed that the given graphs are trees.
It is guaranteed that the sum of n over all test cases doesn't exceed 3 β
10^5.
Output
For each test case print a single integer β the size of the maximum clique in the memorial graph.
Example
Input
4
4
1 2 3
1 2 3
5
1 2 3 4
1 1 1 1
6
1 1 1 1 2
1 2 1 2 2
7
1 1 3 4 4 5
1 2 1 4 2 5
Output
1
4
1
3
Note
In the first and third test cases, you can pick any vertex.
In the second test case, one of the maximum cliques is \{2, 3, 4, 5\}.
In the fourth test case, one of the maximum cliques is \{3, 4, 6\}.
|
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
#define FOR(i,a,b) for(int i=a;i<=b;++i)
#define PII pair<int,int>
#define ll long long
#define pb push_back
#define sz(x) (int)(x.size())
#define rd (rand()<<16^rand())
#define db double
#define gc (_p1==_p2&&(_p2=(_p1=_buf)+fread(_buf,1,100000,stdin),_p1==_p2)?EOF:*_p1++)
using namespace std;
char _buf[100000],*_p1=_buf,*_p2=_buf;
inline int gi()
{
int x=0,f=1;
char ch=gc;
while(ch<'0'||ch>'9')
{
if(ch=='-')f=-1;
ch=gc;
}
while(ch>='0'&&ch<='9')
{
x=(x<<3)+(x<<1)+(ch^48);
ch=gc;
}
return (f==1)?x:-x;
}
inline int max(int a,int b){return a>b?a:b;}
inline int min(int a,int b){return a<b?a:b;}
const int maxn=3e5+5;
int sum,ans,n;
struct BIT
{
int c[maxn];
inline void update(int x,int v)
{
while(x<=n)c[x]+=v,x+=x&-x;
}
inline void clear()
{
FOR(i,1,n)c[i]=0;
}
inline int query(int x)
{
int ret=0;
while(x)ret+=c[x],x-=x&-x;
return ret;
}
}tree,tree2;
vector<int>e[maxn],e2[maxn];
int dep[maxn],dfn[maxn],low[maxn],tot,fa[maxn][20],siz[maxn],tp[maxn],son[maxn],Log[maxn];
inline void dfs(int u)
{
siz[u]=1;dep[u]=dep[fa[u][0]]+1;
FOR(i,1,Log[dep[u]])fa[u][i]=fa[fa[u][i-1]][i-1];
for(int v:e[u])
{
if(v==fa[u][0])continue;
fa[v][0]=u,dfs(v),siz[u]+=siz[v];
if(siz[v]>siz[son[u]])son[u]=v;
}
}
inline void dfs2(int u,int topf)
{
tp[u]=topf,dfn[u]=++tot;
if(son[u])dfs2(son[u],topf);
for(int v:e[u])
{
if(v==fa[u][0]||v==son[u])continue;
dfs2(v,v);
}
low[u]=tot;
}
inline void init()
{
sum=ans=0;
FOR(i,1,n)e[i].clear(),e2[i].clear();
FOR(i,1,n)dep[i]=dfn[i]=low[i]=fa[i][0]=siz[i]=tp[i]=son[i]=0;
FOR(i,1,n)FOR(j,0,19)fa[i][j]=0;
//FOR(i,1,n)cout<<tree.c[i]<<' ';cout<<endl;
//FOR(i,1,n)cout<<tree2.c[i]<<' ';cout<<endl;
tree.clear(),tree2.clear();
tot=0;
}
inline void input()
{
n=gi();
FOR(i,2,n)
{
int u=gi();
e2[i].pb(u),e2[u].pb(i);
}
FOR(i,2,n)
{
int u=gi();
e[i].pb(u),e[u].pb(i);
}
dfs(1);
dfs2(1,1);
}
inline int get(int u)
{
for(int i=Log[dep[u]];i>=0;--i)
{
if(fa[u][i]!=0&&tree.query(dfn[fa[u][i]]))u=fa[u][i];
}
return u;
}
inline void dfs3(int u,int fa)
{
vector<pair<int,int>>now;
bool ok=0;
int t=sum;
if(tree2.query(low[u])-tree2.query(dfn[u]-1)==0)
{
tree2.update(dfn[u],1);ok=1;
if(tree.query(dfn[u]))
{
int x=get(u);
now.pb({x,1});
tree.update(dfn[x],-1);
tree.update(low[x]+1,1);
}
else sum++;
tree.update(dfn[u],1);
tree.update(low[u]+1,-1);
now.pb({u,-1});
}
ans=max(ans,sum);
for(int v:e2[u])
{
if(v==fa)continue;
dfs3(v,u);
}
if(ok)tree2.update(dfn[u],-1);
for(auto x:now)
{
int y=x.first,v=x.second;
tree.update(dfn[y],v);
tree.update(low[y]+1,-v);
}
sum=t;
}
inline void solve()
{
dfs3(1,0);
printf("%d\n",ans);
}
int main()
{
int T=1;
T=gi();
FOR(i,2,maxn-1)Log[i]=Log[i>>1]+1;
while(T--)
{
init();
input();
solve();
}
return 0;
}
|
Petya is the most responsible worker in the Research Institute. So he was asked to make a very important experiment: to melt the chocolate bar with a new laser device. The device consists of a rectangular field of n Γ m cells and a robotic arm. Each cell of the field is a 1 Γ 1 square. The robotic arm has two lasers pointed at the field perpendicularly to its surface. At any one time lasers are pointed at the centres of some two cells. Since the lasers are on the robotic hand, their movements are synchronized β if you move one of the lasers by a vector, another one moves by the same vector.
The following facts about the experiment are known:
* initially the whole field is covered with a chocolate bar of the size n Γ m, both lasers are located above the field and are active;
* the chocolate melts within one cell of the field at which the laser is pointed;
* all moves of the robotic arm should be parallel to the sides of the field, after each move the lasers should be pointed at the centres of some two cells;
* at any one time both lasers should be pointed at the field. Petya doesn't want to become a second Gordon Freeman.
You are given n, m and the cells (x1, y1) and (x2, y2), where the lasers are initially pointed at (xi is a column number, yi is a row number). Rows are numbered from 1 to m from top to bottom and columns are numbered from 1 to n from left to right. You are to find the amount of cells of the field on which the chocolate can't be melted in the given conditions.
Input
The first line contains one integer number t (1 β€ t β€ 10000) β the number of test sets. Each of the following t lines describes one test set. Each line contains integer numbers n, m, x1, y1, x2, y2, separated by a space (2 β€ n, m β€ 109, 1 β€ x1, x2 β€ n, 1 β€ y1, y2 β€ m). Cells (x1, y1) and (x2, y2) are distinct.
Output
Each of the t lines of the output should contain the answer to the corresponding input test set.
Examples
Input
2
4 4 1 1 3 3
4 3 1 1 2 2
Output
8
2
|
#include <bits/stdc++.h>
using namespace std;
long long t, n, m;
int main() {
long long x1, x2, y1, y2, dx, dy;
long long top1, bot1, lef1, rig1, top2, bot2, lef2, rig2, top3, bot3, lef3,
rig3, s1, s2, s3;
cin >> t;
while (t--) {
cin >> n >> m >> x1 >> y1 >> x2 >> y2;
dx = x2 - x1;
dy = y2 - y1;
top1 = max(0LL, -dx);
bot1 = min(n - 1, n - 1 - dx);
lef1 = max(0LL, -dy);
rig1 = min(m - 1, m - 1 - dy);
top2 = max(0LL, dx);
bot2 = min(n - 1, n - 1 + dx);
lef2 = max(0LL, dy);
rig2 = min(m - 1, m - 1 + dy);
top3 = max(top1, top2);
bot3 = min(bot1, bot2);
lef3 = max(lef1, lef2);
rig3 = min(rig1, rig2);
s1 = (bot1 - top1 + 1LL) * (rig1 - lef1 + 1LL);
s2 = (bot2 - top2 + 1LL) * (rig2 - lef2 + 1LL);
s3 = (bot3 - top3 + 1LL) * (rig3 - lef3 + 1LL);
if (top3 <= bot3 && lef3 <= rig3)
cout << m * n - (s1 + s2 - s3) << endl;
else
cout << m * n - s1 - s2 << endl;
}
return 0;
}
|
The Smart Beaver from ABBYY has a long history of cooperating with the "Institute of Cytology and Genetics". Recently, the Institute staff challenged the Beaver with a new problem. The problem is as follows.
There is a collection of n proteins (not necessarily distinct). Each protein is a string consisting of lowercase Latin letters. The problem that the scientists offered to the Beaver is to select a subcollection of size k from the initial collection of proteins so that the representativity of the selected subset of proteins is maximum possible.
The Smart Beaver from ABBYY did some research and came to the conclusion that the representativity of a collection of proteins can be evaluated by a single number, which is simply calculated. Let's suppose we have a collection {a1, ..., ak} consisting of k strings describing proteins. The representativity of this collection is the following value:
<image>
where f(x, y) is the length of the longest common prefix of strings x and y; for example, f("abc", "abd") = 2, and f("ab", "bcd") = 0.
Thus, the representativity of collection of proteins {"abc", "abd", "abe"} equals 6, and the representativity of collection {"aaa", "ba", "ba"} equals 2.
Having discovered that, the Smart Beaver from ABBYY asked the Cup contestants to write a program that selects, from the given collection of proteins, a subcollection of size k which has the largest possible value of representativity. Help him to solve this problem!
Input
The first input line contains two integers n and k (1 β€ k β€ n), separated by a single space. The following n lines contain the descriptions of proteins, one per line. Each protein is a non-empty string of no more than 500 characters consisting of only lowercase Latin letters (a...z). Some of the strings may be equal.
The input limitations for getting 20 points are:
* 1 β€ n β€ 20
The input limitations for getting 50 points are:
* 1 β€ n β€ 100
The input limitations for getting 100 points are:
* 1 β€ n β€ 2000
Output
Print a single number denoting the largest possible value of representativity that a subcollection of size k of the given collection of proteins can have.
Examples
Input
3 2
aba
bzd
abq
Output
2
Input
4 3
eee
rrr
ttt
qqq
Output
0
Input
4 3
aaa
abba
abbc
abbd
Output
9
|
#include <bits/stdc++.h>
const double eps = 1e-9;
const int oo = 1000000000;
const double E = 2.7182818284590452353602874713527;
const double pi = 3.1415926535897932384626433832795;
using namespace std;
struct case1 {
int son[26];
int v, f;
} p[50002];
int f[50002][101];
string a[101];
int n, k;
void dfs(int now, int dis) {
for (int i = 0; i < 26; i++)
if (p[now].son[i]) {
int t = p[now].son[i];
dfs(t, dis + 1);
for (int j = min(p[now].v, k); j; j--)
for (int a = 0; a <= min(j, p[t].v); a++)
f[now][j] =
max(f[now][j], f[now][j - a] + f[t][a] + (j - a) * dis * a);
}
for (int i = min(p[now].v, k); i; i--)
for (int j = 1; j <= min(p[now].f, i); j++)
f[now][i] =
max(f[now][i], f[now][i - j] + dis * ((i - j) * j + j * (j - 1) / 2));
}
int main() {
int tot = 1;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int now = 1;
cin >> a[i];
for (int j = 0; j < a[i].size(); j++) {
p[now].v++;
if (!p[now].son[a[i][j] - 'a']) p[now].son[a[i][j] - 'a'] = ++tot;
now = p[now].son[a[i][j] - 'a'];
}
p[now].v++;
p[now].f++;
}
dfs(1, 0);
cout << f[1][k] << endl;
return 0;
}
|
Once n people simultaneously signed in to the reception at the recently opened, but already thoroughly bureaucratic organization (abbreviated TBO). As the organization is thoroughly bureaucratic, it can accept and cater for exactly one person per day. As a consequence, each of n people made an appointment on one of the next n days, and no two persons have an appointment on the same day.
However, the organization workers are very irresponsible about their job, so none of the signed in people was told the exact date of the appointment. The only way to know when people should come is to write some requests to TBO.
The request form consists of m empty lines. Into each of these lines the name of a signed in person can be written (it can be left blank as well). Writing a person's name in the same form twice is forbidden, such requests are ignored. TBO responds very quickly to written requests, but the reply format is of very poor quality β that is, the response contains the correct appointment dates for all people from the request form, but the dates are in completely random order. Responds to all requests arrive simultaneously at the end of the day (each response specifies the request that it answers).
Fortunately, you aren't among these n lucky guys. As an observer, you have the following task β given n and m, determine the minimum number of requests to submit to TBO to clearly determine the appointment date for each person.
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases. Each of the following t lines contains two integers n and m (1 β€ n, m β€ 109) β the number of people who have got an appointment at TBO and the number of empty lines in the request form, correspondingly.
Output
Print t lines, each containing an answer for the corresponding test case (in the order they are given in the input) β the minimum number of requests to submit to TBO.
Examples
Input
5
4 1
4 2
7 3
1 1
42 7
Output
3
2
3
0
11
Note
In the first sample, you need to submit three requests to TBO with three different names. When you learn the appointment dates of three people out of four, you can find out the fourth person's date by elimination, so you do not need a fourth request.
In the second sample you need only two requests. Let's number the persons from 1 to 4 and mention persons 1 and 2 in the first request and persons 1 and 3 in the second request. It is easy to see that after that we can clearly determine each person's appointment date regardless of the answers obtained from TBO.
In the fourth sample only one person signed up for an appointment. He doesn't need to submit any requests β his appointment date is tomorrow.
|
#include <bits/stdc++.h>
using namespace std;
int jud(long long N, long long M, long long K) {
int i;
if (K < 40 && (1ll << K) < N) return 0;
long long cnt = 0, sum = 0, x = 1;
for (i = 0;; i++) {
long long tmp = min(N - cnt, x);
cnt += tmp;
sum += tmp * i;
if (cnt == N) break;
x = x * (K - i) / (i + 1);
}
M = min(M, N - M);
return (sum <= K * M);
}
int main() {
int t, n, m;
cin >> t;
while (t--) {
cin >> n >> m;
m = min(n / 2, m);
int l = 0, r = n - 1;
while (l < r) {
int d = l + r >> 1;
if (jud(n, m, d))
r = d;
else
l = d + 1;
}
printf("%d\n", l);
}
return 0;
}
|
Harry Potter has a difficult homework. Given a rectangular table, consisting of n Γ m cells. Each cell of the table contains the integer. Harry knows how to use two spells: the first spell change the sign of the integers in the selected row, the second β in the selected column. Harry's task is to make non-negative the sum of the numbers in each row and each column using these spells.
Alone, the boy can not cope. Help the young magician!
Input
The first line contains two integers n and m (1 β€ n, m β€ 100) β the number of rows and the number of columns.
Next n lines follow, each contains m integers: j-th integer in the i-th line is ai, j (|ai, j| β€ 100), the number in the i-th row and j-th column of the table.
The rows of the table numbered from 1 to n. The columns of the table numbered from 1 to m.
Output
In the first line print the number a β the number of required applications of the first spell. Next print a space-separated integers β the row numbers, you want to apply a spell. These row numbers must be distinct!
In the second line print the number b β the number of required applications of the second spell. Next print b space-separated integers β the column numbers, you want to apply a spell. These column numbers must be distinct!
If there are several solutions are allowed to print any of them.
Examples
Input
4 1
-1
-1
-1
-1
Output
4 1 2 3 4
0
Input
2 4
-1 -1 -1 2
1 1 1 1
Output
1 1
1 4
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<vector<int> > a(n, vector<int>(m));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> a[i][j];
vector<int> czyR(n, 0), czyK(m, 0);
vector<int> sR(n, 0), sK(m, 0);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
sR[i] += a[i][j];
sK[j] += a[i][j];
}
}
while (true) {
int nr = -1;
for (int i = 0; i < n; ++i)
if (sR[i] < 0) nr = i;
if (nr != -1) {
czyR[nr] ^= 1;
sR[nr] *= -1;
for (int i = 0; i < m; ++i) {
sK[i] -= a[nr][i];
a[nr][i] *= -1;
sK[i] += a[nr][i];
}
continue;
}
for (int i = 0; i < m; ++i)
if (sK[i] < 0) nr = i;
if (nr != -1) {
czyK[nr] ^= 1;
sK[nr] *= -1;
for (int i = 0; i < n; ++i) {
sR[i] -= a[i][nr];
a[i][nr] *= -1;
sR[i] += a[i][nr];
}
continue;
}
break;
}
int x = 0;
for (int i = 0; i < n; ++i) x += czyR[i];
cout << x << " ";
for (int i = 0; i < n; ++i)
if (czyR[i] == 1) cout << i + 1 << " ";
cout << endl;
int y = 0;
for (int i = 0; i < m; ++i) y += czyK[i];
cout << y << " ";
for (int i = 0; i < m; ++i)
if (czyK[i] == 1) cout << i + 1 << " ";
return 0;
}
|
An IPv6-address is a 128-bit number. For convenience, this number is recorded in blocks of 16 bits in hexadecimal record, the blocks are separated by colons β 8 blocks in total, each block has four hexadecimal digits. Here is an example of the correct record of a IPv6 address: "0124:5678:90ab:cdef:0124:5678:90ab:cdef". We'll call such format of recording an IPv6-address full.
Besides the full record of an IPv6 address there is a short record format. The record of an IPv6 address can be shortened by removing one or more leading zeroes at the beginning of each block. However, each block should contain at least one digit in the short format. For example, the leading zeroes can be removed like that: "a56f:00d3:0000:0124:0001:f19a:1000:0000" β "a56f:d3:0:0124:01:f19a:1000:00". There are more ways to shorten zeroes in this IPv6 address.
Some IPv6 addresses contain long sequences of zeroes. Continuous sequences of 16-bit zero blocks can be shortened to "::". A sequence can consist of one or several consecutive blocks, with all 16 bits equal to 0.
You can see examples of zero block shortenings below:
* "a56f:00d3:0000:0124:0001:0000:0000:0000" β "a56f:00d3:0000:0124:0001::";
* "a56f:0000:0000:0124:0001:0000:1234:0ff0" β "a56f::0124:0001:0000:1234:0ff0";
* "a56f:0000:0000:0000:0001:0000:1234:0ff0" β "a56f:0000::0000:0001:0000:1234:0ff0";
* "a56f:00d3:0000:0124:0001:0000:0000:0000" β "a56f:00d3:0000:0124:0001::0000";
* "0000:0000:0000:0000:0000:0000:0000:0000" β "::".
It is not allowed to shorten zero blocks in the address more than once. This means that the short record can't contain the sequence of characters "::" more than once. Otherwise, it will sometimes be impossible to determine the number of zero blocks, each represented by a double colon.
The format of the record of the IPv6 address after removing the leading zeroes and shortening the zero blocks is called short.
You've got several short records of IPv6 addresses. Restore their full record.
Input
The first line contains a single integer n β the number of records to restore (1 β€ n β€ 100).
Each of the following n lines contains a string β the short IPv6 addresses. Each string only consists of string characters "0123456789abcdef:".
It is guaranteed that each short address is obtained by the way that is described in the statement from some full IPv6 address.
Output
For each short IPv6 address from the input print its full record on a separate line. Print the full records for the short IPv6 addresses in the order, in which the short records follow in the input.
Examples
Input
6
a56f:d3:0:0124:01:f19a:1000:00
a56f:00d3:0000:0124:0001::
a56f::0124:0001:0000:1234:0ff0
a56f:0000::0000:0001:0000:1234:0ff0
::
0ea::4d:f4:6:0
Output
a56f:00d3:0000:0124:0001:f19a:1000:0000
a56f:00d3:0000:0124:0001:0000:0000:0000
a56f:0000:0000:0124:0001:0000:1234:0ff0
a56f:0000:0000:0000:0001:0000:1234:0ff0
0000:0000:0000:0000:0000:0000:0000:0000
00ea:0000:0000:0000:004d:00f4:0006:0000
|
#include <bits/stdc++.h>
using namespace std;
int N;
char s[1000];
int chartoint(char c) {
if (c >= 'a' && c <= 'f') return c - 'a' + 10;
return c - '0';
}
int stringtoint(char *s) {
int len = strlen(s);
int sum = 0;
for (int i = 0; i < len; i++) sum = sum * 16 + chartoint(s[i]);
return sum;
}
vector<int> split(char *s) {
vector<int> ans;
int len = strlen(s);
for (int i = 0; i < len; ++i)
if (s[i] == ':') s[i] = 0;
for (int i = 0; i < len; ++i)
if (s[i]) {
ans.push_back(stringtoint(s + i));
i += strlen(s + i);
}
return ans;
}
void solve(char *s) {
std::vector<int> ip(8, 0), left, right;
int len = strlen(s), i;
for (i = 0; i < len - 1; ++i)
if (s[i] == ':' && s[i + 1] == ':') {
s[i] = 0;
break;
}
if (i != len - 1) {
left = split(s);
right = split(s + i + 2);
} else {
left = split(s);
}
for (i = 0; i < left.size(); ++i) ip[i] = left[i];
for (i = 0; i < right.size(); ++i) ip[8 - right.size() + i] = right[i];
for (i = 0; i < 8; ++i) {
if (i) putchar(':');
printf("%04x", ip[i]);
}
puts("");
}
int main(int argc, char const *argv[]) {
scanf("%d", &N);
getchar();
for (int i = 0; i < N; ++i) {
gets(s);
solve(s);
}
return 0;
}
|
A k-multiple free set is a set of integers where there is no pair of integers where one is equal to another integer multiplied by k. That is, there are no two integers x and y (x < y) from the set, such that y = xΒ·k.
You're given a set of n distinct positive integers. Your task is to find the size of it's largest k-multiple free subset.
Input
The first line of the input contains two integers n and k (1 β€ n β€ 105, 1 β€ k β€ 109). The next line contains a list of n distinct positive integers a1, a2, ..., an (1 β€ ai β€ 109).
All the numbers in the lines are separated by single spaces.
Output
On the only line of the output print the size of the largest k-multiple free subset of {a1, a2, ..., an}.
Examples
Input
6 2
2 3 6 5 4 10
Output
3
Note
In the sample input one of the possible maximum 2-multiple free subsets is {4, 5, 6}.
|
def solve():
n,k=map(int,input().split())
a=sorted([int(i) for i in input().split()])
b=set(a)
if k!=1:
for i in a:
if i in b:
b.discard(i*k)
print(len(b))
solve()
|
Polar bears like unique arrays β that is, arrays without repeated elements.
You have got a unique array s with length n containing non-negative integers. Since you are good friends with Alice and Bob, you decide to split the array in two. Precisely, you need to construct two arrays a and b that are also of length n, with the following conditions for all i (1 β€ i β€ n):
* ai, bi are non-negative integers;
* si = ai + bi .
Ideally, a and b should also be unique arrays. However, life in the Arctic is hard and this is not always possible. Fortunately, Alice and Bob are still happy if their arrays are almost unique. We define an array of length n to be almost unique, if and only if it can be turned into a unique array by removing no more than <image> entries.
For example, the array [1, 2, 1, 3, 2] is almost unique because after removing the first two entries, it becomes [1, 3, 2]. The array [1, 2, 1, 3, 1, 2] is not almost unique because we need to remove at least 3 entries to turn it into a unique array.
So, your task is to split the given unique array s into two almost unique arrays a and b.
Input
The first line of the input contains integer n (1 β€ n β€ 105).
The second line contains n distinct integers s1, s2, ... sn (0 β€ si β€ 109).
Output
If it is possible to make Alice and Bob happy (if you can split the given array), print "YES" (without quotes) in the first line. In the second line, print the array a. In the third line, print the array b. There may be more than one solution. Any of them will be accepted.
If it is impossible to split s into almost unique arrays a and b, print "NO" (without quotes) in the first line.
Examples
Input
6
12 5 8 3 11 9
Output
YES
6 2 6 0 2 4
6 3 2 3 9 5
Note
In the sample, we can remove the first two entries from a and the second entry from b to make them both unique.
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void debug(T a, T b) {
for (; a != b; a++) cerr << *a << ' ';
cerr << endl;
}
template <class T>
bool isprime(T x) {
int till = (T)sqrt(x + .0);
if (x <= 1) return 0;
if (x == 2) return 1;
if (x % 2 == 0) return 0;
for (int i = 3; i <= till; i += 2)
if (x % i == 0) return 0;
return 1;
}
int n;
pair<int, int> s[100000];
int a[100000];
int b[100000];
int main() {
cin >> n;
for (int i = 0; i < int(n); i++) {
cin >> s[i].first;
s[i].second = i;
}
sort(s, s + n);
for (int i = 0; i <= n / 3; i++) {
a[s[i].second] = 0;
b[s[i].second] = s[i].first;
}
for (int i = n / 3 + 1; i <= n / 3 * 2; i++) {
a[s[i].second] = s[i].first;
b[s[i].second] = 0;
}
for (int i = n / 3 * 2 + 1; i < n; i++) {
a[s[i].second] = n - i;
b[s[i].second] = s[i].first - (n - i);
}
cout << "YES\n";
for (int i = 0; i < int(n); i++) cout << a[i] << " ";
cout << "\n";
for (int i = 0; i < int(n); i++) cout << b[i] << " ";
cout << "\n";
return EXIT_SUCCESS;
}
|
Now Fox Ciel becomes a commander of Tree Land. Tree Land, like its name said, has n cities connected by n - 1 undirected roads, and for any two cities there always exists a path between them.
Fox Ciel needs to assign an officer to each city. Each officer has a rank β a letter from 'A' to 'Z'. So there will be 26 different ranks, and 'A' is the topmost, so 'Z' is the bottommost.
There are enough officers of each rank. But there is a special rule must obey: if x and y are two distinct cities and their officers have the same rank, then on the simple path between x and y there must be a city z that has an officer with higher rank. The rule guarantee that a communications between same rank officers will be monitored by higher rank officer.
Help Ciel to make a valid plan, and if it's impossible, output "Impossible!".
Input
The first line contains an integer n (2 β€ n β€ 105) β the number of cities in Tree Land.
Each of the following n - 1 lines contains two integers a and b (1 β€ a, b β€ n, a β b) β they mean that there will be an undirected road between a and b. Consider all the cities are numbered from 1 to n.
It guaranteed that the given graph will be a tree.
Output
If there is a valid plane, output n space-separated characters in a line β i-th character is the rank of officer in the city with number i.
Otherwise output "Impossible!".
Examples
Input
4
1 2
1 3
1 4
Output
A B B B
Input
10
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
Output
D C B A D C B D C D
Note
In the first example, for any two officers of rank 'B', an officer with rank 'A' will be on the path between them. So it is a valid solution.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
vector<int> e[N];
char a[N];
int n, ans, id, order;
int dfs(int r, int last, int n) {
int tmp = 0, sum = 1, res = 0;
for (int i = e[r].size() - 1; i >= 0; i--) {
if (e[r][i] == last || a[e[r][i]] != -1) continue;
tmp = dfs(e[r][i], r, n);
sum += tmp;
res = max(res, tmp);
}
res = max(res, n - sum);
if (res < ans) {
ans = res;
id = r;
} else if (res == ans) {
id = min(id, r);
}
return sum;
}
int getn(int r, int last = -1) {
int tmp = 0, sum = 1;
for (int i = e[r].size() - 1; i >= 0; i--) {
if (e[r][i] == last || a[e[r][i]] != -1) continue;
tmp = getn(e[r][i], r);
sum += tmp;
}
return sum;
}
void solve(int r, char c) {
int i, j, id;
if (a[r] != -1) return;
::ans = getn(r);
::id = r;
dfs(r, -1, ::ans);
id = ::id;
a[id] = c;
for (i = e[id].size() - 1; i >= 0; i--) {
solve(e[id][i], c + 1);
}
}
int main() {
int T, u, v, i;
T = 1;
while (T--) {
scanf("%d", &n);
for (i = 0; i <= n; i++) {
e[i].clear();
a[i] = -1;
}
for (i = 0; i < n - 1; i++) {
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
solve(1, 'A');
for (i = 1; i <= n; i++) {
if (i < n)
printf("%c ", a[i]);
else
printf("%c\n", a[i]);
}
}
return 0;
}
|
It is so boring in the summer holiday, isn't it? So Alice and Bob have invented a new game to play. The rules are as follows. First, they get a set of n distinct integers. And then they take turns to make the following moves. During each move, either Alice or Bob (the player whose turn is the current) can choose two distinct integers x and y from the set, such that the set doesn't contain their absolute difference |x - y|. Then this player adds integer |x - y| to the set (so, the size of the set increases by one).
If the current player has no valid move, he (or she) loses the game. The question is who will finally win the game if both players play optimally. Remember that Alice always moves first.
Input
The first line contains an integer n (2 β€ n β€ 100) β the initial number of elements in the set. The second line contains n distinct space-separated integers a1, a2, ..., an (1 β€ ai β€ 109) β the elements of the set.
Output
Print a single line with the winner's name. If Alice wins print "Alice", otherwise print "Bob" (without quotes).
Examples
Input
2
2 3
Output
Alice
Input
2
5 3
Output
Alice
Input
3
5 6 7
Output
Bob
Note
Consider the first test sample. Alice moves first, and the only move she can do is to choose 2 and 3, then to add 1 to the set. Next Bob moves, there is no valid move anymore, so the winner is Alice.
|
import java.io.BufferedReader;
import java.io.*;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.*;
import java.math.*;
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;
}
}
public static void main (String[] args) throws java.lang.Exception {
int test=1;
FastReader sc=new FastReader();
PrintWriter pw=new PrintWriter(System.out);
//test=sc.nextInt();
while(test-->0){
int n=sc.nextInt();
BigInteger g=BigInteger.ZERO;
long a[]=new long[n];
for(int i=0;i<n;i++)
{
a[i]=sc.nextLong();
g=g.gcd(BigInteger.valueOf(a[i]));
}
Arrays.parallelSort(a);
long gcd=g.longValue();
if((a[n-1]/gcd-a.length)%2==0) pw.println("Bob");
else pw.println("Alice");
}
pw.close();
}
}
|
Valera loves segments. He has recently come up with one interesting problem.
The Ox axis of coordinates has n segments, the i-th segment starts in position li and ends in position ri (we will mark it as [li, ri]). Your task is to process m queries, each consists of number cnti and a set of cnti coordinates of points located on the Ox axis. The answer to the query is the number of segments, such that each of them contains at least one point from the query. Segment [l, r] contains point q, if l β€ q β€ r.
Valera found the solution of this problem too difficult. So he asked you to help him. Help Valera.
Input
The first line contains two integers n, m (1 β€ n, m β€ 3Β·105) β the number of segments on the axis of coordinates and the number of queries.
Next n lines contain the descriptions of the segments. The i-th line contains two positive integers li, ri (1 β€ li β€ ri β€ 106) β the borders of the i-th segment.
Next m lines contain the description of the queries, one per line. Each line starts from integer cnti (1 β€ cnti β€ 3Β·105) β the number of points in the i-th query. Then the line contains cnti distinct positive integers p1, p2, ..., pcnti (1 β€ p1 < p2 < ... < pcnti β€ 106) β the coordinates of points in the i-th query.
It is guaranteed that the total number of points in all queries doesn't exceed 3Β·105.
Output
Print m non-negative integers, where the i-th number is the response to the i-th query.
Examples
Input
3 3
1 3
4 5
6 7
3 1 4 7
2 4 5
1 8
Output
3
1
0
|
#include <bits/stdc++.h>
using namespace std;
long long pw(long long base, long long e) {
return e ? pw(base * base, e / 2) * (e % 2 ? base : 1) : 1;
}
const int maxn = 3e5 + 10, mod = 1e9 + 7, maxlg = 21;
const long long INF = 1e9;
long long seg[maxlg][maxn];
int n;
pair<int, int> a[maxn];
int get(int lx, int rx, int l, int r, int x, int val) {
if (lx >= l && rx <= r) {
int i = (int)log2(x);
return rx - (lower_bound(seg[i] + lx, seg[i] + rx, val) - seg[i]);
}
if (lx >= r || rx <= l) {
return 0;
}
int mid = (lx + rx) / 2;
return get(lx, mid, l, r, 2 * x, val) + get(mid, rx, l, r, 2 * x + 1, val);
}
void build(int ind, int l, int r) {
if (l == r - 1) {
int i = (int)log2(ind);
seg[i][l] = a[l].second;
return;
}
int mid = (l + r) / 2;
build(ind * 2, l, mid);
build(ind * 2 + 1, mid, r);
int i0, i1, i2;
i1 = (int)log2(ind * 2);
i2 = (int)log2(ind * 2 + 1);
i0 = (int)log2(ind);
merge(seg[i1] + l, seg[i1] + mid, seg[i2] + mid, seg[i2] + r, seg[i0] + l);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q, cnt, m;
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a, a + n);
int b[n];
int c[n];
for (int i = 0; i < n; i++) {
b[i] = a[i].second;
c[i] = a[i].first;
}
build(1, 0, n);
while (q--) {
cin >> m;
int ans = 0;
int prev, cur;
prev = cur = 0;
int l, r;
for (int i = 0; i < m; i++) {
cin >> cur;
l = upper_bound(c, c + n, prev) - c;
r = upper_bound(c, c + n, cur) - c - 1;
r++;
ans += get(0, n, l, r, 1, cur);
prev = cur;
}
cout << ans << '\n';
}
}
|
This problem consists of two subproblems: for solving subproblem D1 you will receive 3 points, and for solving subproblem D2 you will receive 16 points.
Manao is the chief architect involved in planning a new supercollider. He has to identify a plot of land where the largest possible supercollider can be built. The supercollider he is building requires four-way orthogonal collisions of particles traveling at the same speed, so it will consist of four accelerating chambers and be shaped like a plus sign (i.e., +). Each of the four accelerating chambers must be the same length and must be aligned with the Earth's magnetic field (parallel or orthogonal) to minimize interference.
The accelerating chambers need to be laid down across long flat stretches of land to keep costs under control. Thus, Manao has already commissioned a topographical study that has identified all possible maximal length tracts of land available for building accelerating chambers that are either parallel or orthogonal to the Earth's magnetic field. To build the largest possible supercollider, Manao must identify the largest symmetric plus shape from among these candidate tracts. That is, he must find the two tracts of land that form an axis-aligned plus shape with the largest distance from the center of the plus to the tip of the shortest of the four arms of the plus. Note that the collider need not use the entire length of the tracts identified (see the example in the notes).
Input
The first line of the input will contain two single-space-separated integers n, the number of north-south tracts and m, the number of west-east tracts.
Each of the n lines following the first describes a north-south tract. Each such tract is described by three single-space-separated integers xi, yi, li representing the vertical line segment from (xi, yi) to (xi, yi + li).
Similarly, after the n lines describing north-south tracts follow m similar lines describing the west-east tracts. Each such tract is described by three single-space-separated integers xi, yi, li representing the horizontal line segment from (xi, yi) to (xi + li, yi).
All xi and yi are between -100000000 and 100000000, inclusive. All li are between 1 and 100000000, inclusive. No pair of horizontal segments will touch or intersect, and no pair of vertical segments will touch or intersect.
The problem consists of two subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem D1 (3 points), n and m will be between 1 and 1000, inclusive.
* In subproblem D2 (16 points), n and m will be between 1 and 50000, inclusive.
Output
Print one line containing a single integer, the size of the largest supercollider that can be built on one north-south tract and one west-east tract. The size of the supercollider is defined to be the length of one of the four accelerating chambers. In other words, the size of the resulting supercollider is defined to be the distance from the intersection of the two line segments to the closest endpoint of either of the two segments. If no pair of north-south and west-east tracts intersects, it is not possible to build a supercollider and the program should report a maximum size of zero.
Examples
Input
1 2
4 0 9
1 1 8
1 2 7
Output
2
Note
Consider the example. There is one vertical line segment from (4, 0) to (4, 9) and two horizontal line segments: from (1, 1) to (9, 1) and from (1, 2) to (8, 2). The largest plus shape that can be found among these segments is formed from the only vertical segment and the second of horizontal segments, and is centered at (4, 2).
The program should output 2 because the closest end point of those segments to the center is (4, 0), which is distance 2 from the center point of (4, 2). The collider will be formed by the line segments from (2, 2) to (6, 2) and from (4, 0) to (4, 4).
|
#include <bits/stdc++.h>
int vx[50007], vy[50007], vl[50007];
int hx[50007], hy[50007], hl[50007];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d %d %d", vx + i, vy + i, vl + i);
}
int ans = 0;
for (int i = 0; i < m; i++) {
scanf("%d %d %d", hx + i, hy + i, hl + i);
for (int j = 0; j < n; j++) {
if (vx[j] >= hx[i] && vx[j] <= hx[i] + hl[i] && hy[i] >= vy[j] &&
hy[i] <= vy[j] + vl[j]) {
const int r =
std::min(std::min(std::min(hy[i] - vy[j], vy[j] + vl[j] - hy[i]),
vx[j] - hx[i]),
hx[i] + hl[i] - vx[j]);
if (r > ans) {
ans = r;
}
}
}
}
printf("%d", ans);
return 0;
}
|
The last product of the R2 company in the 2D games' field is a new revolutionary algorithm of searching for the shortest path in a 2 Γ n maze.
Imagine a maze that looks like a 2 Γ n rectangle, divided into unit squares. Each unit square is either an empty cell or an obstacle. In one unit of time, a person can move from an empty cell of the maze to any side-adjacent empty cell. The shortest path problem is formulated as follows. Given two free maze cells, you need to determine the minimum time required to go from one cell to the other.
Unfortunately, the developed algorithm works well for only one request for finding the shortest path, in practice such requests occur quite often. You, as the chief R2 programmer, are commissioned to optimize the algorithm to find the shortest path. Write a program that will effectively respond to multiple requests to find the shortest path in a 2 Γ n maze.
Input
The first line contains two integers, n and m (1 β€ n β€ 2Β·105; 1 β€ m β€ 2Β·105) β the width of the maze and the number of queries, correspondingly. Next two lines contain the maze. Each line contains n characters, each character equals either '.' (empty cell), or 'X' (obstacle).
Each of the next m lines contains two integers vi and ui (1 β€ vi, ui β€ 2n) β the description of the i-th request. Numbers vi, ui mean that you need to print the value of the shortest path from the cell of the maze number vi to the cell number ui. We assume that the cells of the first line of the maze are numbered from 1 to n, from left to right, and the cells of the second line are numbered from n + 1 to 2n from left to right. It is guaranteed that both given cells are empty.
Output
Print m lines. In the i-th line print the answer to the i-th request β either the size of the shortest path or -1, if we can't reach the second cell from the first one.
Examples
Input
4 7
.X..
...X
5 1
1 3
7 7
1 4
6 1
4 7
5 7
Output
1
4
0
5
2
2
2
Input
10 3
X...X..X..
..X...X..X
11 7
7 18
18 10
Output
9
-1
3
|
#include <bits/stdc++.h>
using namespace std;
string s[2];
int comp[2][1000000];
int vis[2][1000000];
int n;
void dfs(int i, int j, int col) {
if (i >= 2 || j >= n || i < 0 || j < 0) return;
if (s[i][j] == 'X') return;
if (vis[i][j]) return;
vis[i][j] = 1;
comp[i][j] = col;
dfs(i + 1, j, col);
dfs(i, j + 1, col);
dfs(i, j - 1, col);
dfs(i - 1, j, col);
}
int L[1000000];
int R[1000000];
int sum[1000000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> n >> q;
int V = 0;
cin >> s[0] >> s[1];
for (int i = 0; i < 2; i++) {
for (int j = 0; j < n; j++) {
if (!vis[i][j]) dfs(i, j, ++V);
}
}
if ((s[0][0] == 'X') + (s[1][0] == 'X') == 1)
L[0] = 0;
else
L[0] = -1;
if ((s[0].back() == 'X') + (s[1].back() == 'X') == 1)
R[n - 1] = n - 1;
else
R[n - 1] = n + 1;
for (int i = 1; i < n; i++) {
L[i] = L[i - 1];
if ((s[0][i] == 'X') + (s[1][i] == 'X') == 1) L[i] = i;
}
for (int i = n - 2; i >= 0; i--) {
R[i] = R[i + 1];
if ((s[0][i] == 'X') + (s[1][i] == 'X') == 1) R[i] = i;
}
for (int i = 0; i < n; i++) {
if (i) sum[i] = sum[i - 1];
if (i && L[i] == i && L[i - 1] != -1 && s[0][L[i - 1]] != s[0][i]) sum[i]++;
}
while (q--) {
int x, y;
cin >> x >> y;
int x1 = (x - 1) / n;
int y1 = (x - 1) % n;
int x2 = (y - 1) / n;
int y2 = (y - 1) % n;
x = y1;
y = y2;
if (y1 > y2) {
swap(y1, y2);
swap(x1, x2);
swap(x, y);
}
if (comp[x1][y1] != comp[x2][y2]) {
cout << "-1\n";
} else {
if (R[x] > L[y])
cout << y - x + abs(x1 - x2) << endl;
else {
int add = 0;
if (x1 == 0 && s[0][R[x]] == 'X') add++;
if (x1 == 1 && s[1][R[x]] == 'X') add++;
if (x2 == 0 && s[0][L[y]] == 'X') add++;
if (x2 == 1 && s[1][L[y]] == 'X') add++;
cout << y - x + sum[L[y]] - sum[R[x]] + add << endl;
}
}
}
}
|
Petya has k matches, placed in n matchboxes lying in a line from left to right. We know that k is divisible by n. Petya wants all boxes to have the same number of matches inside. For that, he can move a match from its box to the adjacent one in one move. How many such moves does he need to achieve the desired configuration?
Input
The first line contains integer n (1 β€ n β€ 50000). The second line contains n non-negative numbers that do not exceed 109, the i-th written number is the number of matches in the i-th matchbox. It is guaranteed that the total number of matches is divisible by n.
Output
Print the total minimum number of moves.
Examples
Input
6
1 6 2 5 3 7
Output
12
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 50005;
int n, in[MAXN];
long long k, ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> in[i];
k += in[i];
}
k /= n;
long long c = in[0] - k;
for (int i = 1; i < n; ++i) {
ans += abs(c);
c += in[i];
c -= k;
}
cout << ans << endl;
return 0;
}
|
Appleman has a tree with n vertices. Some of the vertices (at least one) are colored black and other vertices are colored white.
Consider a set consisting of k (0 β€ k < n) edges of Appleman's tree. If Appleman deletes these edges from the tree, then it will split into (k + 1) parts. Note, that each part will be a tree with colored vertices.
Now Appleman wonders, what is the number of sets splitting the tree in such a way that each resulting part will have exactly one black vertex? Find this number modulo 1000000007 (109 + 7).
Input
The first line contains an integer n (2 β€ n β€ 105) β the number of tree vertices.
The second line contains the description of the tree: n - 1 integers p0, p1, ..., pn - 2 (0 β€ pi β€ i). Where pi means that there is an edge connecting vertex (i + 1) of the tree and vertex pi. Consider tree vertices are numbered from 0 to n - 1.
The third line contains the description of the colors of the vertices: n integers x0, x1, ..., xn - 1 (xi is either 0 or 1). If xi is equal to 1, vertex i is colored black. Otherwise, vertex i is colored white.
Output
Output a single integer β the number of ways to split the tree modulo 1000000007 (109 + 7).
Examples
Input
3
0 0
0 1 1
Output
2
Input
6
0 1 1 0 4
1 1 0 0 1 0
Output
1
Input
10
0 1 2 1 4 4 4 0 8
0 0 0 1 0 1 1 0 0 1
Output
27
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int MAXN = 100010;
int N, c[MAXN], f[MAXN][2];
vector<int> graph[MAXN];
void dfs(int u, int p) {
f[u][0] = 1;
f[u][1] = 0;
for (int i = 0; i < graph[u].size(); ++i) {
int v = graph[u][i];
if (v != p) {
dfs(v, u);
f[u][1] = (long long)f[u][1] * f[v][0] % MOD;
f[u][1] = (f[u][1] + (long long)f[u][0] * f[v][1]) % MOD;
f[u][0] = (long long)f[u][0] * f[v][0] % MOD;
}
}
if (c[u] == 1)
f[u][1] = f[u][0];
else
f[u][0] = (f[u][0] + f[u][1]) % MOD;
}
int main() {
int v;
cin >> N;
for (int u = 0; u < N - 1; ++u) {
cin >> v;
graph[u + 1].push_back(v);
graph[v].push_back(u + 1);
}
for (int i = 0; i < N; ++i) cin >> c[i];
dfs(0, -1);
cout << f[0][1] << endl;
return 0;
}
|
Nam is playing with a string on his computer. The string consists of n lowercase English letters. It is meaningless, so Nam decided to make the string more beautiful, that is to make it be a palindrome by using 4 arrow keys: left, right, up, down.
There is a cursor pointing at some symbol of the string. Suppose that cursor is at position i (1 β€ i β€ n, the string uses 1-based indexing) now. Left and right arrow keys are used to move cursor around the string. The string is cyclic, that means that when Nam presses left arrow key, the cursor will move to position i - 1 if i > 1 or to the end of the string (i. e. position n) otherwise. The same holds when he presses the right arrow key (if i = n, the cursor appears at the beginning of the string).
When Nam presses up arrow key, the letter which the text cursor is pointing to will change to the next letter in English alphabet (assuming that alphabet is also cyclic, i. e. after 'z' follows 'a'). The same holds when he presses the down arrow key.
Initially, the text cursor is at position p.
Because Nam has a lot homework to do, he wants to complete this as fast as possible. Can you help him by calculating the minimum number of arrow keys presses to make the string to be a palindrome?
Input
The first line contains two space-separated integers n (1 β€ n β€ 105) and p (1 β€ p β€ n), the length of Nam's string and the initial position of the text cursor.
The next line contains n lowercase characters of Nam's string.
Output
Print the minimum number of presses needed to change string into a palindrome.
Examples
Input
8 3
aeabcaez
Output
6
Note
A string is a palindrome if it reads the same forward or reversed.
In the sample test, initial Nam's string is: <image> (cursor position is shown bold).
In optimal solution, Nam may do 6 following steps:
<image>
The result, <image>, is now a palindrome.
|
import sys
input=sys.stdin.readline
n,p=map(int,input().split())
s=input().rstrip()
if p>=n//2:
s=s[::-1]
p=n+1-p
p-=1
ans1=0;ans2=0
l=10**6;r=-1
for i in range(n//2):
if s[i]!=s[n-1-i]:
l=min(l,i)
r=max(r,i)
use=set()
if l<=p<=r:
if r!=-1:
for i in range(p,r+1):
if s[i]!=s[n-1-i] and i not in use:
ans1+=min( abs(ord(s[i])-ord(s[n-1-i])) , 26-abs(ord(s[i])-ord(s[n-1-i])) )
ans2+=min( abs(ord(s[i])-ord(s[n-1-i])) , 26-abs(ord(s[i])-ord(s[n-1-i])) )
use.add(i)
ans1+=2*abs(r-p)
ans2+=abs(r-p)
if l!=10**6:
for i in range(p,l-1,-1):
if s[i]!=s[n-1-i] and i not in use:
ans1+=min( abs(ord(s[i])-ord(s[n-1-i])) , 26-abs(ord(s[i])-ord(s[n-1-i])) )
ans2+=min( abs(ord(s[i])-ord(s[n-1-i])) , 26-abs(ord(s[i])-ord(s[n-1-i])) )
use.add(i)
ans1+=abs(p-l)
ans2+=2*abs(p-l)
ans=min(ans1,ans2)
print(ans)
elif p<=l:
if r!=-1:
for i in range(p,r+1):
if s[i]!=s[n-1-i]:
ans2+=min( abs(ord(s[i])-ord(s[n-1-i])) , 26-abs(ord(s[i])-ord(s[n-1-i])) )
ans2+=abs(r-p)
print(ans2)
else:
if l!=10**6:
for i in range(p,l-1,-1):
if s[i]!=s[n-1-i]:
ans1+=min( abs(ord(s[i])-ord(s[n-1-i])) , 26-abs(ord(s[i])-ord(s[n-1-i])) )
ans1+=abs(p-l)
print(ans1)
|
There is a given string S consisting of N symbols. Your task is to find the number of ordered pairs of integers i and j such that
1. 1 β€ i, j β€ N
2. S[i] = S[j], that is the i-th symbol of string S is equal to the j-th.
Input
The single input line contains S, consisting of lowercase Latin letters and digits. It is guaranteed that string S in not empty and its length does not exceed 105.
Output
Print a single number which represents the number of pairs i and j with the needed property. Pairs (x, y) and (y, x) should be considered different, i.e. the ordered pairs count.
Examples
Input
great10
Output
7
Input
aaaaaaaaaa
Output
100
|
#include <bits/stdc++.h>
using namespace std;
int main() {
map<char, long long> m;
string s;
cin >> s;
long long sum = 0;
for (long long i = 0; i < s.length(); i++) {
char c = s[i];
m[c]++;
}
map<char, long long>::iterator i;
for (i = m.begin(); i != m.end(); i++) {
long long temp = i->second;
temp = temp * temp;
sum += temp;
}
cout << sum << endl;
return 0;
}
|
On February, 30th n students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.
At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.
Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.
Please note that some students could work independently until the end of the day, without participating in a team contest.
Input
The first line contains integer n (1 β€ n β€ 2Β·105) β the number of students who came to CTOP. The next line contains n integers a1, a2, ..., an (0 β€ ai < n), where ai is the number of students with who the i-th student shook hands.
Output
If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number i that stands to the left of number j in this permutation means that the i-th student came earlier than the j-th student. If there are multiple answers, print any of them.
If the sought order of students doesn't exist, in a single line print "Impossible".
Examples
Input
5
2 1 3 0 1
Output
Possible
4 5 1 3 2
Input
9
0 2 3 4 1 1 0 2 2
Output
Possible
7 5 2 1 6 8 3 4 9
Input
4
0 2 1 1
Output
Impossible
Note
In the first sample from the statement the order of events could be as follows:
* student 4 comes in (a4 = 0), he has no one to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 4;
* student 1 comes in (a1 = 2), he shakes hands with two students (students 4, 5);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 4, 5, 1);
* students 4, 5, 3 form a team and start writing a contest;
* student 2 comes in (a2 = 1), he shakes hands with one student (number 1).
In the second sample from the statement the order of events could be as follows:
* student 7 comes in (a7 = 0), he has nobody to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 7;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 7, 5);
* students 7, 5, 2 form a team and start writing a contest;
* student 1 comes in(a1 = 0), he has no one to greet (everyone is busy with the contest);
* student 6 comes in (a6 = 1), he shakes hands with student 1;
* student 8 comes in (a8 = 2), he shakes hands with two students (students 1, 6);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 1, 6, 8);
* student 4 comes in (a4 = 4), he shakes hands with four students (students 1, 6, 8, 3);
* students 8, 3, 4 form a team and start writing a contest;
* student 9 comes in (a9 = 2), he shakes hands with two students (students 1, 6).
In the third sample from the statement the order of events is restored unambiguously:
* student 1 comes in (a1 = 0), he has no one to greet;
* student 3 comes in (or student 4) (a3 = a4 = 1), he shakes hands with student 1;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 1, 3 (or 4));
* the remaining student 4 (or student 3), must shake one student's hand (a3 = a4 = 1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually.
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T pwr(T b, T p) {
T r = 1, x = b;
while (p) {
if (p & 1) r *= x;
x *= x;
p = (p >> 1);
}
return r;
}
template <class T>
T lcm(T a, T b) {
return (a / __gcd(a, b)) * b;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T>
void xswap(T &x, T &y) {
if (x != y) {
x ^= y;
y ^= x;
x ^= y;
}
}
template <typename T>
inline bool isOn(T &mask, int pos) {
return ((mask) & (1LL << pos));
}
template <typename T>
inline T setf(T mask, int pos) {
return mask = ((mask) & (~(1LL << pos)));
}
template <typename T>
inline T sett(T mask, int pos) {
return mask = ((mask)(1LL << pos));
}
template <typename T>
inline T flip(T mask, int pos) {
return mask = ((mask) ^ (1LL << pos));
}
template <class T1>
void put(T1 e) {
cout << e << endl;
}
template <class T1, class T2>
void put(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void put(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void put(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void put(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1>
void putv(vector<T1> e1) {
for (int i = 0; i < e1.size(); i++)
(!i ? cout << e1[i] : cout << " " << e1[i]);
cout << endl;
}
template <class T1>
void puta(T1 arr[], int l) {
for (int i = 0; i < l; i++) (!i ? cout << arr[i] : cout << " " << arr[i]);
cout << endl;
}
template <class T1>
bool tk(T1 &e1) {
return (cin >> e1 ? true : false);
}
template <class T1, class T2>
bool tk(T1 &e1, T2 &e2) {
return (cin >> e1 >> e2 ? true : false);
}
template <class T1, class T2, class T3>
bool tk(T1 &e1, T2 &e2, T3 &e3) {
return (cin >> e1 >> e2 >> e3 ? true : false);
}
template <class T1, class T2, class T3, class T4>
bool tk(T1 &e1, T2 &e2, T3 &e3, T4 &e4) {
return (cin >> e1 >> e2 >> e3 >> e4 ? true : false);
}
priority_queue<int> que[200007];
vector<int> ans;
int main() {
int n, shakes;
tk(n);
for (int i = 1; i <= n; ++i) {
tk(shakes);
que[shakes].push(i);
}
int now_shakes = 0, i = 0;
while (i < n) {
if (now_shakes < 0) {
put("Impossible");
return 0;
} else if (que[now_shakes].empty()) {
now_shakes -= 3;
} else {
ans.push_back(que[now_shakes].top());
que[now_shakes].pop();
now_shakes++;
i++;
}
}
put("Possible");
putv(ans);
return 0;
}
|
Gerald got tired of playing board games with the usual six-sided die, and he bought a toy called Randomizer. It functions as follows.
A Randomizer has its own coordinate plane on which a strictly convex polygon is painted, the polygon is called a basic polygon. If you shake a Randomizer, it draws some nondegenerate (i.e. having a non-zero area) convex polygon with vertices at some vertices of the basic polygon. The result of the roll (more precisely, the result of the shaking) is considered to be the number of points with integer coordinates, which were strictly inside (the points on the border are not considered) the selected polygon. Now Gerald is wondering: what is the expected result of shaking the Randomizer?
During the shaking the Randomizer considers all the possible non-degenerate convex polygons with vertices at the vertices of the basic polygon. Let's assume that there are k versions of the polygons. Then the Randomizer chooses each of them with probability <image>.
Input
The first line of the input contains a single integer n (3 β€ n β€ 100 000) β the number of vertices of the basic polygon.
Next n lines contain the coordinates of the vertices of the basic polygon. The i-th of these lines contain two integers xi and yi ( - 109 β€ xi, yi β€ 109) β the coordinates of the i-th vertex of the polygon. The vertices are given in the counter-clockwise order.
Output
Print the sought expected value with absolute or relative error at most 10 - 9.
Examples
Input
4
0 0
2 0
2 2
0 2
Output
0.2
Input
5
0 0
2 0
2 2
1 3
0 2
Output
0.8125
Note
A polygon is called strictly convex if it is convex and no its vertices lie on the same line.
Let's assume that a random variable takes values x1, ..., xn with probabilities p1, ..., pn, correspondingly. Then the expected value of this variable equals to <image>.
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.Arrays;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.math.BigDecimal;
import java.io.Closeable;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) throws Exception {
Thread thread = new Thread(null, new TaskAdapter(), "", 1 << 29);
thread.start();
thread.join();
}
static class TaskAdapter implements Runnable {
@Override
public void run() {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
FastInput in = new FastInput(inputStream);
FastOutput out = new FastOutput(outputStream);
DRandomizer solver = new DRandomizer();
solver.solve(1, in, out);
out.close();
}
}
static class DRandomizer {
double[] floor;
int n;
Debug debug = new Debug(true);
public long cross(int[] a, int[] b) {
return (long) a[0] * b[1] - (long) a[1] * b[0];
}
public int intPointCount(int x, int y) {
x = Math.abs(x);
y = Math.abs(y);
int g = GCDs.gcd(x, y);
return g;
}
double prob(int j) {
return (floor[j + 1] - floor[n]) / (1 - (1 + n + (double) n * (n - 1) / 2) * floor[n]);
}
public void solve(int testNumber, FastInput in, FastOutput out) {
n = in.ri();
int[][] pts = new int[n][2];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
pts[i][j] = in.ri();
}
}
KahanSummation ea = new KahanSummation();
KahanSummation eb = new KahanSummation();
floor = new double[n + 1];
floor[0] = 1;
for (int i = 1; i <= n; i++) {
floor[i] = floor[i - 1] * 0.5;
}
for (int i = 0; i < n; i++) {
for (int j = 1; j < n && j < 100; j++) {
int to = j + i;
if (to >= n) {
to -= n;
}
ea.add(prob(j) * cross(pts[i], pts[to]));
eb.add(prob(j) * intPointCount(pts[to][0] - pts[i][0], pts[to][1] - pts[i][1]));
}
}
debug.debug("ea", ea);
debug.debug("eb", eb);
double ans = ea.sum() / 2 - eb.sum() / 2 + 1;
out.println(ans);
}
}
static class Debug {
private boolean offline;
private PrintStream out = System.err;
static int[] empty = new int[0];
public Debug(boolean enable) {
offline = enable && System.getSecurityManager() == null;
}
public Debug debug(String name, Object x) {
return debug(name, x, empty);
}
public Debug debug(String name, Object x, int... indexes) {
if (offline) {
if (x == null || !x.getClass().isArray()) {
out.append(name);
for (int i : indexes) {
out.printf("[%d]", i);
}
out.append("=").append("" + x);
out.println();
} else {
indexes = Arrays.copyOf(indexes, indexes.length + 1);
if (x instanceof byte[]) {
byte[] arr = (byte[]) x;
for (int i = 0; i < arr.length; i++) {
indexes[indexes.length - 1] = i;
debug(name, arr[i], indexes);
}
} else if (x instanceof short[]) {
short[] arr = (short[]) x;
for (int i = 0; i < arr.length; i++) {
indexes[indexes.length - 1] = i;
debug(name, arr[i], indexes);
}
} else if (x instanceof boolean[]) {
boolean[] arr = (boolean[]) x;
for (int i = 0; i < arr.length; i++) {
indexes[indexes.length - 1] = i;
debug(name, arr[i], indexes);
}
} else if (x instanceof char[]) {
char[] arr = (char[]) x;
for (int i = 0; i < arr.length; i++) {
indexes[indexes.length - 1] = i;
debug(name, arr[i], indexes);
}
} else if (x instanceof int[]) {
int[] arr = (int[]) x;
for (int i = 0; i < arr.length; i++) {
indexes[indexes.length - 1] = i;
debug(name, arr[i], indexes);
}
} else if (x instanceof float[]) {
float[] arr = (float[]) x;
for (int i = 0; i < arr.length; i++) {
indexes[indexes.length - 1] = i;
debug(name, arr[i], indexes);
}
} else if (x instanceof double[]) {
double[] arr = (double[]) x;
for (int i = 0; i < arr.length; i++) {
indexes[indexes.length - 1] = i;
debug(name, arr[i], indexes);
}
} else if (x instanceof long[]) {
long[] arr = (long[]) x;
for (int i = 0; i < arr.length; i++) {
indexes[indexes.length - 1] = i;
debug(name, arr[i], indexes);
}
} else {
Object[] arr = (Object[]) x;
for (int i = 0; i < arr.length; i++) {
indexes[indexes.length - 1] = i;
debug(name, arr[i], indexes);
}
}
}
}
return this;
}
}
static class GCDs {
private GCDs() {
}
public static int gcd(int a, int b) {
return a >= b ? gcd0(a, b) : gcd0(b, a);
}
private static int gcd0(int a, int b) {
return b == 0 ? a : gcd0(b, a % b);
}
}
static class KahanSummation {
private double error;
private double sum;
public double sum() {
return sum;
}
public void add(double x) {
x = x - error;
double t = sum + x;
error = (t - sum) - x;
sum = t;
}
public String toString() {
return new BigDecimal(sum).toString();
}
}
static class FastInput {
private final InputStream is;
private byte[] buf = new byte[1 << 13];
private int bufLen;
private int bufOffset;
private int next;
public FastInput(InputStream is) {
this.is = is;
}
private int read() {
while (bufLen == bufOffset) {
bufOffset = 0;
try {
bufLen = is.read(buf);
} catch (IOException e) {
bufLen = -1;
}
if (bufLen == -1) {
return -1;
}
}
return buf[bufOffset++];
}
public void skipBlank() {
while (next >= 0 && next <= 32) {
next = read();
}
}
public int ri() {
return readInt();
}
public int readInt() {
int sign = 1;
skipBlank();
if (next == '+' || next == '-') {
sign = next == '+' ? 1 : -1;
next = read();
}
int val = 0;
if (sign == 1) {
while (next >= '0' && next <= '9') {
val = val * 10 + next - '0';
next = read();
}
} else {
while (next >= '0' && next <= '9') {
val = val * 10 - next + '0';
next = read();
}
}
return val;
}
}
static class FastOutput implements AutoCloseable, Closeable, Appendable {
private static final int THRESHOLD = 1 << 13;
private final Writer os;
private StringBuilder cache = new StringBuilder(THRESHOLD * 2);
public FastOutput append(CharSequence csq) {
cache.append(csq);
return this;
}
public FastOutput append(CharSequence csq, int start, int end) {
cache.append(csq, start, end);
return this;
}
private void afterWrite() {
if (cache.length() < THRESHOLD) {
return;
}
flush();
}
public FastOutput(Writer os) {
this.os = os;
}
public FastOutput(OutputStream os) {
this(new OutputStreamWriter(os));
}
public FastOutput append(char c) {
cache.append(c);
afterWrite();
return this;
}
public FastOutput append(double c) {
cache.append(new BigDecimal(c).toPlainString());
afterWrite();
return this;
}
public FastOutput append(String c) {
cache.append(c);
afterWrite();
return this;
}
public FastOutput println(double c) {
return append(c).println();
}
public FastOutput println() {
return append(System.lineSeparator());
}
public FastOutput flush() {
try {
os.append(cache);
os.flush();
cache.setLength(0);
} catch (IOException e) {
throw new UncheckedIOException(e);
}
return this;
}
public void close() {
flush();
try {
os.close();
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
public String toString() {
return cache.toString();
}
}
}
|
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.
All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.
Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.
<image>
Input
Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 β€ t β€ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of t sets of the input data.
The first line of the description of each set contains two integers n, k (2 β€ n β€ 100, 1 β€ k β€ 26) β the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.
Output
For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.
Examples
Input
2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
Output
YES
NO
Input
2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...
Output
YES
NO
Note
In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.
Note that in this problem the challenges are restricted to tests that contain only one testset.
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskD solver = new TaskD();
int testCount = Integer.parseInt(in.next());
for (int i = 1; i <= testCount; i++)
solver.solve(i, in, out);
out.close();
}
static class TaskD {
public void solve(int testNumber, InputReader in, PrintWriter out) {
int n = in.nextInt();
int k = in.nextInt();
Train[] trains = new Train[k];
for (int i = 0; i < k; i++) {
trains[i] = new Train();
}
char[][] a = new char[3][n];
int[] cTrain = new int[26];
int countTrain = 0;
Arrays.fill(cTrain, -1);
boolean[] can = new boolean[3];
for (int i = 0; i < 3; i++) {
a[i] = in.next().toCharArray();
for (int j = 0; j < n; j++) {
if (a[i][j] == '.') continue;
if (a[i][j] == 's') {
can[i] = true;
continue;
}
int curTrainIndex = a[i][j] - 'A';
if (cTrain[curTrainIndex] == -1) {
cTrain[curTrainIndex] = countTrain++;
}
if (trains[cTrain[curTrainIndex]].row == -1) {
trains[cTrain[curTrainIndex]].row = i;
trains[cTrain[curTrainIndex]].begin = j;
}
trains[cTrain[curTrainIndex]].end = j;
}
}
int col = 0;
for (int i = 0; i < n; i++) {
boolean[] next = new boolean[3];
col++;
for (int j = 0; j < 3; j++) {
if (!can[j]) continue;
next[j] = true;
for (int l = 0; l < k; l++) {
if (trains[l].isInside(j, col)) {
next[j] = false;
}
}
if (!next[j]) continue;
if (j + 1 < 3) {
next[j + 1] = true;
}
if (j > 0) {
next[j - 1] = true;
}
}
for (int j = 0; j < k; j++) {
for (int l = 0; l < 3; l++) {
if (trains[j].isInside(l, col)) {
next[l] = false;
}
}
}
for (int j = 0; j < k; j++) {
trains[j].move();
}
for (int j = 0; j < k; j++) {
for (int l = 0; l < 3; l++) {
if (trains[j].isInside(l, col)) {
next[l] = false;
}
}
}
boolean any = false;
for (int j = 0; j < 3; j++) {
if (next[j]) {
any = true;
}
}
if (!any) {
out.println("NO");
return;
}
can = next;
}
out.println("YES");
}
}
static class Train {
int row;
int begin;
int end;
public Train() {
row = -1;
begin = end = -1;
}
public void move() {
begin -= 2;
end -= 2;
}
boolean isInside(int i, int j) {
if (i != row) return false;
return begin <= j && j <= end;
}
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
}
}
|
Genos recently installed the game Zuma on his phone. In Zuma there exists a line of n gemstones, the i-th of which has color ci. The goal of the game is to destroy all the gemstones in the line as quickly as possible.
In one second, Genos is able to choose exactly one continuous substring of colored gemstones that is a palindrome and remove it from the line. After the substring is removed, the remaining gemstones shift to form a solid line again. What is the minimum number of seconds needed to destroy the entire line?
Let us remind, that the string (or substring) is called palindrome, if it reads same backwards or forward. In our case this means the color of the first gemstone is equal to the color of the last one, the color of the second gemstone is equal to the color of the next to last and so on.
Input
The first line of input contains a single integer n (1 β€ n β€ 500) β the number of gemstones.
The second line contains n space-separated integers, the i-th of which is ci (1 β€ ci β€ n) β the color of the i-th gemstone in a line.
Output
Print a single integer β the minimum number of seconds needed to destroy the entire line.
Examples
Input
3
1 2 1
Output
1
Input
3
1 2 3
Output
3
Input
7
1 4 4 2 3 2 1
Output
2
Note
In the first sample, Genos can destroy the entire line in one second.
In the second sample, Genos can only destroy one gemstone at a time, so destroying three gemstones takes three seconds.
In the third sample, to achieve the optimal time of two seconds, destroy palindrome 4 4 first and then destroy palindrome 1 2 3 2 1.
|
#include <bits/stdc++.h>
using namespace std;
int n, a[510];
int dp[510][510];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) dp[i][j] = 1e9;
}
for (int i = 1; i <= n; i++) dp[i][i] = 1;
for (int len = 2; len <= n; len++) {
for (int i = 1; i <= n; i++) {
if (i + len - 1 > n) break;
int j = i + len - 1;
if (a[i] == a[j]) {
if (len == 2) {
dp[i][j] = 1;
} else {
dp[i][j] = dp[i + 1][j - 1];
}
}
for (int k = i; k < j; k++) {
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j]);
}
}
}
printf("%d\n", dp[1][n]);
}
|
Door's family is going celebrate Famil Doors's birthday party. They love Famil Door so they are planning to make his birthday cake weird!
The cake is a n Γ n square consisting of equal squares with side length 1. Each square is either empty or consists of a single chocolate. They bought the cake and randomly started to put the chocolates on the cake. The value of Famil Door's happiness will be equal to the number of pairs of cells with chocolates that are in the same row or in the same column of the cake. Famil Doors's family is wondering what is the amount of happiness of Famil going to be?
Please, note that any pair can be counted no more than once, as two different cells can't share both the same row and the same column.
Input
In the first line of the input, you are given a single integer n (1 β€ n β€ 100) β the length of the side of the cake.
Then follow n lines, each containing n characters. Empty cells are denoted with '.', while cells that contain chocolates are denoted by 'C'.
Output
Print the value of Famil Door's happiness, i.e. the number of pairs of chocolate pieces that share the same row or the same column.
Examples
Input
3
.CC
C..
C.C
Output
4
Input
4
CC..
C..C
.CC.
.CC.
Output
9
Note
If we number rows from top to bottom and columns from left to right, then, pieces that share the same row in the first sample are:
1. (1, 2) and (1, 3)
2. (3, 1) and (3, 3)
Pieces that share the same column are:
1. (2, 1) and (3, 1)
2. (1, 3) and (3, 3)
|
//package HackerEarthA;
import java.io.*;
import java.util.*;
import java.util.Map.Entry;
import java.text.*;
import java.math.*;
import java.util.regex.*;
/**
*
* @author prabhat
*/
public class easy18{
public static long[] BIT;
public static long[] tree;
public static long[] sum;
public static int mod=1000000007;
public static int[][] dp;
public static boolean[][] isPalin;
public static int max1=1000005;
public static int[][] g;
public static LinkedList<Pair> l[];
public static int n,m,q,k,t,arr[],b[],cnt[],chosen[],pos[],ans;
public static ArrayList<Integer> adj[],al;
public static TreeSet<Integer> ts;
public static char[][] s;
public static int depth,mini,maxi;
public static long V[],low,high,min=Long.MAX_VALUE;
public static boolean visit[][],isPrime[],used[];
public static int[][] dist;
public static ArrayList<Integer>prime;
public static int[] x={0,1};
public static int[] y={-1,0};
public static ArrayList<Integer> divisor[]=new ArrayList[1500005];
public static int[][] subtree,parent,mat;
public static TreeMap<Integer,Integer> tm;
public static LongPoint[] p;
public static int[][] grid;
public static ArrayList<Pair> list;
public static TrieNode root;
static LinkedHashMap<String,Integer> map;
public static BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
public static void main(String[] args) throws Exception
{
InputReader in = new InputReader(System.in);
PrintWriter pw=new PrintWriter(System.out);
n=in.ii();
s=new char[n][n];
for(int i=0;i<n;i++)
{
s[i]=in.is().trim().toCharArray();
}
long ans=0;
for(int i=0;i<n;i++)
{
int r=0;
for(char c:s[i])
if(c=='C')r++;
ans+=nCr(r,2);
}
for(int j=0;j<n;j++)
{
int c=0;
for(int i=0;i<n;i++)
{
if(s[i][j]=='C')c++;
}
ans+=nCr(c,2);
}
pw.println(ans);
pw.close();
}
public static void dfs1(int cur)
{
used[cur]=true;
cnt[cur]=1;
for(int ver:adj[cur])
{
if(used[ver])continue;
dfs1(ver);
cnt[cur]+=cnt[ver];
}
}
static ArrayList<String> dfs(String s,String[] sarr,HashMap<String, ArrayList<String>> map)
{
if(map.containsKey(s))return map.get(s);
ArrayList<String> res=new ArrayList<>();
if(s.length()==0)
{
res.add("");
return res;
}
for(String word:sarr)
{
if(s.startsWith(word))
{
ArrayList<String > sub=dfs(s.substring(word.length()),sarr,map);
for(String s2:sub)
{
res.add(word+ (s2.isEmpty() ? "" : " ")+s2);
}
}
}
map.put(s,res);
return res;
}
static class SegmentTree{
int n;
int max_bound;
public SegmentTree(int n)
{
this.n=n;
tree=new long[4*n+1];
build(1,0,n-1);
}
void build(int c,int s,int e)
{
if(s==e)
{
tree[c]=arr[s];
return ;
}
int mid=(s+e)>>1;
build(2*c,s,mid);
build(2*c+1,mid+1,e);
tree[c]=(tree[2*c]+tree[2*c+1]);
}
void put(int c,int s, int e,int l,int r,int v) {
if(l>e||r<s||s>e)return ;
if (s == e)
{
tree[c] = arr[s]^v;
return;
}
int mid = (s + e) >> 1;
if (l>mid) put(2*c+1,m+1, e , l,r, v);
else if(r<=mid)put(2*c,s,m,l,r , v);
else{
}
}
long query(int c,int s,int e,int l,int r)
{
if(e<l||s>r)return 0L;
if(s>=l&&e<=r)
{
return tree[c];
}
int mid=(s+e)>>1;
return (query(2*c,s,mid,l,r)+query(2*c+1,mid+1,e,l,r));
}
}
static void update(int indx,long val)
{
while(indx<max1)
{
BIT[indx]+=val;
indx+=(indx&(-indx));
}
}
static long query1(int indx)
{
long sum=0;
while(indx>0)
{
sum+=BIT[indx];
// System.out.println(indx);
indx-=(indx&(-indx));
}
return sum;
}
public static ListNode removeNthFromEnd(ListNode a, int b) {
int cnt=0;
ListNode ra1=a;
ListNode ra2=a;
while(ra1!=null){ra1=ra1.next; cnt++;}
if(b>cnt)return a.next;
else if(b==1&&cnt==1)return null;
else{
int y=cnt-b+1;
int u=0;
ListNode prev=null;
while(a!=null)
{
u++;
if(u==y)
{
if(a.next==null)prev.next=null;
else
{
if(prev==null)return ra2.next;
prev.next=a.next;
a.next=null;
}
break;
}
prev=a;
a=a.next;
}
}
return ra2;
}
static ListNode rev(ListNode a)
{
ListNode prev=null;
ListNode cur=a;
ListNode next=null;
while(cur!=null)
{
next=cur.next;
cur.next=prev;
prev=cur;
cur=next;
}
return prev;
}
static class ListNode {
public int val;
public ListNode next;
ListNode(int x) { val = x; next = null; }
}
static class TrieNode
{
int value; // Only used in leaf nodes
TrieNode[] arr = new TrieNode[2];
public TrieNode() {
value = 0;
arr[0] = null;
arr[1] = null;
}
}
static void insert(int pre_xor)
{
TrieNode temp = root;
// Start from the msb, insert all bits of
// pre_xor into Trie
for (int i=31; i>=0; i--)
{
// Find current bit in given prefix
int val = (pre_xor & (1<<i)) >=1 ? 1 : 0;
// Create a new node if needed
if (temp.arr[val] == null)
temp.arr[val] = new TrieNode();
temp = temp.arr[val];
}
// Store value at leaf node
temp.value = pre_xor;
}
static int query(int pre_xor)
{
TrieNode temp = root;
for (int i=31; i>=0; i--)
{
// Find current bit in given prefix
int val = (pre_xor & (1<<i)) >= 1 ? 1 : 0;
// Traverse Trie, first look for a
// prefix that has opposite bit
if (temp.arr[val] != null)
temp = temp.arr[val];
// If there is no prefix with opposite
// bit, then look for same bit.
else if (temp.arr[1-val] != null)
temp = temp.arr[1-val];
}
return pre_xor^(temp.value);
}
public static String add(String s1,String s2)
{
int n=s1.length()-1;
int m=s2.length()-1;
int rem=0;
int carry=0;
int i=n;
int j=m;
String ans="";
while(i>=0&&j>=0)
{
int c1=(int)(s1.charAt(i)-'0');
int c2=(int)(s2.charAt(j)-'0');
int sum=c1+c2;
sum+=carry;
rem=sum%10;
carry=sum/10;
ans=rem+ans;
i--; j--;
}
while(i>=0)
{
int c1=(int)(s1.charAt(i)-'0');
int sum=c1;
sum+=carry;
rem=sum%10;
carry=sum/10;
ans=rem+ans;
i--;
}
while(j>=0)
{
int c2=(int)(s2.charAt(j)-'0');
int sum=c2;
sum+=carry;
rem=sum%10;
carry=sum/10;
ans=rem+ans;
j--;
}
if(carry>0)ans=carry+ans;
return ans;
}
public static String[] multiply(String A, String B) {
int lb=B.length();
char[] a=A.toCharArray();
char[] b=B.toCharArray();
String[] s=new String[lb];
int cnt=0;
int y=0;
String s1="";
q=0;
for(int i=b.length-1;i>=0;i--)
{
int rem=0;
int carry=0;
for(int j=a.length-1;j>=0;j--)
{
int mul=(int)(b[i]-'0')*(int)(a[j]-'0');
mul+=carry;
rem=mul%10;
carry=mul/10;
s1=rem+s1;
}
s1=carry+s1;
s[y++]=s1;
q=Math.max(q,s1.length());
s1="";
for(int i1=0;i1<y;i1++)s1+='0';
}
return s;
}
public static long nCr(long total, long choose)
{
if(total < choose)
return 0;
if(choose == 0 || choose == total)
return 1;
return nCr(total-1,choose-1)+nCr(total-1,choose);
}
static int get(long s)
{
int ans=0;
for(int i=0;i<n;i++)
{
if(p[i].x<=s&&s<=p[i].y)ans++;
}
return ans;
}
static class LongPoint {
public long x;
public long y;
public LongPoint(long x, long y) {
this.x = x;
this.y = y;
}
public LongPoint subtract(LongPoint o) {
return new LongPoint(x - o.x, y - o.y);
}
public long cross(LongPoint o) {
return x * o.y - y * o.x;
}
}
static int CountPs(String s,int n)
{
boolean b=false;
char[] S=s.toCharArray();
int[][] dp=new int[n][n];
boolean[][] p=new boolean[n][n];
for(int i=0;i<n;i++)p[i][i]=true;
for(int i=0;i<n-1;i++)
{
if(S[i]==S[i+1])
{
p[i][i+1]=true;
dp[i][i+1]=0;
b=true;
}
}
for(int gap=2;gap<n;gap++)
{
for(int i=0;i<n-gap;i++)
{
int j=gap+i;
if(S[i]==S[j]&&p[i+1][j-1]){p[i][j]=true;}
if(p[i][j])
dp[i][j]=dp[i][j-1]+dp[i+1][j]+1-dp[i+1][j-1];
else if(!p[i][j]) dp[i][j]=dp[i][j-1]+dp[i+1][j]-dp[i+1][j-1];
//if(dp[i][j]>=1)
// return true;
}
}
// return b;
return dp[0][n-1];
}
static void Seive()
{
isPrime=new boolean[1500005];
Arrays.fill(isPrime,true);
for(int i=0;i<1500005;i++){divisor[i]=new ArrayList<>();}
int u=0;
prime=new ArrayList<>();
for(int i=2;i<=(1500000);i++)
{
if(isPrime[i])
{
prime.add(i);
for(int j=i;j<1500000;j+=i)
{
divisor[j].add(i);
isPrime[j]=false;
}
/* for(long x=(divCeil(low,i))*i;x<=high;x+=i)
{
divisor[(int)(x-low)].add(i*1L);
}*/
}
}
}
static long divCeil(long a,long b)
{
return (a+b-1)/b;
}
static long root(int pow, long x) {
long candidate = (long)Math.exp(Math.log(x)/pow);
candidate = Math.max(1, candidate);
while (pow(candidate, pow) <= x) {
candidate++;
}
return candidate-1;
}
static long pow(long x, int pow)
{
long result = 1;
long p = x;
while (pow > 0) {
if ((pow&1) == 1) {
if (result > Long.MAX_VALUE/p) return Long.MAX_VALUE;
result *= p;
}
pow >>>= 1;
if (pow > 0 && p >= 4294967296L) return Long.MAX_VALUE;
p *= p;
}
return result;
}
static boolean valid(int i,int j)
{
if(i>=0&&i<n&&j>=0&&j<m)return true;
return false;
}
private static class DSU{
int[] parent;
int[] rank;
int cnt;
public DSU(int n){
parent=new int[n];
rank=new int[n];
for(int i=0;i<n;i++){
parent[i]=i;
rank[i]=1;
}
cnt=n;
}
int find(int i){
while(parent[i] !=i){
parent[i]=parent[parent[i]];
i=parent[i];
}
return i;
}
int Union(int x, int y){
int xset = find(x);
int yset = find(y);
if(xset!=yset)
cnt--;
if(rank[xset]<rank[yset]){
parent[xset] = yset;
rank[yset]+=rank[xset];
rank[xset]=0;
return yset;
}else{
parent[yset]=xset;
rank[xset]+=rank[yset];
rank[yset]=0;
return xset;
}
}
}
public static int[][] packU(int n, int[] from, int[] to, int max) {
int[][] g = new int[n][];
int[] p = new int[n];
for (int i = 0; i < max; i++) p[from[i]]++;
for (int i = 0; i < max; i++) p[to[i]]++;
for (int i = 0; i < n; i++) g[i] = new int[p[i]];
for (int i = 0; i < max; i++) {
g[from[i]][--p[from[i]]] = to[i];
g[to[i]][--p[to[i]]] = from[i];
}
return g;
}
public static int[][] parents3(int[][] g, int root) {
int n = g.length;
int[] par = new int[n];
Arrays.fill(par, -1);
int[] depth = new int[n];
depth[0] = 0;
int[] q = new int[n];
q[0] = root;
for (int p = 0, r = 1; p < r; p++) {
int cur = q[p];
for (int nex : g[cur]) {
if (par[cur] != nex) {
q[r++] = nex;
par[nex] = cur;
depth[nex] = depth[cur] + 1;
}
}
}
return new int[][]{par, q, depth};
}
public static int lower_bound(int[] nums, int target) {
int low = 0, high = nums.length - 1;
while (low < high) {
int mid = low + (high - low) / 2;
if (nums[mid] < target)
low = mid + 1;
else
high = mid;
}
return nums[low] == target ? low : -1;
}
public static int upper_bound(int[] nums, int target) {
int low = 0, high = nums.length - 1;
while (low < high) {
int mid = low + (high + 1 - low) / 2;
if (nums[mid] > target)
high = mid - 1;
else
low = mid;
}
return nums[low] == target ? low : -1;
}
public static boolean palin(String s)
{
int i=0;
int j=s.length()-1;
while(i<j)
{
if(s.charAt(i)==s.charAt(j))
{
i++;
j--;
}
else return false;
}
return true;
}
public static int gcd(int a,int b)
{
int res=1;
while(a>0)
{
res=a;
a=b%a;
b=res;
}
return res;
}
static int lcm(int a,int b)
{
return (a*b)/(gcd(a,b));
}
public static long pow(long n,long p,long m)
{
long result = 1;
if(p==0)
return 1;
while(p!=0)
{
if(p%2==1)
result *= n;
if(result>=m)
result%=m;
p >>=1;
n*=n;
if(n>=m)
n%=m;
}
return result;
}
/**
*
* @param n
* @param p
* @return
*/
public static long pow(long n,long p)
{
long result = 1;
if(p==0)
return 1;
if (p==1)
return n;
while(p!=0)
{
if(p%2==1)
result *= n;
p >>=1;
n*=n;
}
return result;
}
static class Edge implements Comparator<Edge> {
private int u;
private int v;
private long w;
public Edge() {
}
public Edge(int u, int v, long w) {
this.u=u;
this.v=v;
this.w=w;
}
public int getU() {
return u;
}
public void setU(int u) {
this.u = u;
}
public int getV() {
return v;
}
public void setV(int v) {
this.v = v;
}
public long getW() {
return w;
}
public void setW(int w) {
this.w = w;
}
public long compareTo(Edge e)
{
return (this.getW() - e.getW());
}
@Override
public int compare(Edge o1, Edge o2) {
throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
}
}
static class Pair implements Comparable<Pair>
{
int x,y;
Pair (int a,int b)
{
this.x=a;
this.y=b;
}
public int compareTo(Pair o) {
// TODO Auto-generated method stub
if(this.x!=o.x)
return -Integer.compare(this.x,o.x);
else
return -Integer.compare(this.y, o.y);
//return 0;
}
public boolean equals(Object o) {
if (o instanceof Pair) {
Pair p = (Pair)o;
return p.x == x && p.y == y;
}
return false;
}
public int hashCode() {
return new Integer(x).hashCode() * 31 + new Integer(y).hashCode();
}
}
static class InputReader
{
private InputStream stream;
private byte[] buf = new byte[1024];
private SpaceCharFilter filter;
byte inbuffer[] = new byte[1024];
int lenbuffer = 0, ptrbuffer = 0;
final int M = (int) 1e9 + 7;
int md=(int)(1e7+1);
int[] SMP=new int[md];
final double eps = 1e-6;
final double pi = Math.PI;
PrintWriter out;
String check = "";
InputStream obj = check.isEmpty() ? System.in : new ByteArrayInputStream(check.getBytes());
public InputReader(InputStream stream)
{
this.stream = stream;
}
int readByte() {
if (lenbuffer == -1) throw new InputMismatchException();
if (ptrbuffer >= lenbuffer) {
ptrbuffer = 0;
try {
lenbuffer = obj.read(inbuffer);
} catch (IOException e) {
throw new InputMismatchException();
}
}
if (lenbuffer <= 0) return -1;
return inbuffer[ptrbuffer++];
}
public int read()
{
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = read();
}
int res = 0;
do
{
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
String is() {
int b = skip();
StringBuilder sb = new StringBuilder();
while (!(isSpaceChar(b))) // when nextLine, (isSpaceChar(b) && b!=' ')
{
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int ii() {
int num = 0, b;
boolean minus = false;
while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
if (b == '-') {
minus = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') {
num = num * 10 + (b - '0');
} else {
return minus ? -num : num;
}
b = readByte();
}
}
public long il() {
long num = 0;
int b;
boolean minus = false;
while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
if (b == '-') {
minus = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') {
num = num * 10 + (b - '0');
} else {
return minus ? -num : num;
}
b = readByte();
}
}
boolean isSpaceChar(int c) {
return (!(c >= 33 && c <= 126));
}
int skip()
{
int b;
while ((b = readByte()) != -1 && isSpaceChar(b)) ;
return b;
}
float nf() {
return Float.parseFloat(is());
}
double id() {
return Double.parseDouble(is());
}
char ic() {
return (char) skip();
}
int[] iia(int n) {
int a[] = new int[n];
for (int i = 0; i<n; i++) a[i] = ii();
return a;
}
long[] ila(int n) {
long a[] = new long[n];
for (int i = 0; i <n; i++) a[i] = il();
return a;
}
String[] isa(int n) {
String a[] = new String[n];
for (int i = 0; i < n; i++) a[i] = is();
return a;
}
long mul(long a, long b) { return a * b % M; }
long div(long a, long b)
{
return mul(a, pow(b, M - 2));
}
double[][] idm(int n, int m) {
double a[][] = new double[n][m];
for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) a[i][j] = id();
return a;
}
int[][] iim(int n, int m) {
int a[][] = new int[n][m];
for (int i = 0; i < n; i++) for (int j = 0; j <m; j++) a[i][j] = ii();
return a;
}
public String readLine() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isEndOfLine(c));
return res.toString();
}
public interface SpaceCharFilter
{
public boolean isSpaceChar(int ch);
}
public boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
}
}
|
Limak is a little polar bear. Polar bears hate long strings and thus they like to compress them. You should also know that Limak is so young that he knows only first six letters of the English alphabet: 'a', 'b', 'c', 'd', 'e' and 'f'.
You are given a set of q possible operations. Limak can perform them in any order, any operation may be applied any number of times. The i-th operation is described by a string ai of length two and a string bi of length one. No two of q possible operations have the same string ai.
When Limak has a string s he can perform the i-th operation on s if the first two letters of s match a two-letter string ai. Performing the i-th operation removes first two letters of s and inserts there a string bi. See the notes section for further clarification.
You may note that performing an operation decreases the length of a string s exactly by 1. Also, for some sets of operations there may be a string that cannot be compressed any further, because the first two letters don't match any ai.
Limak wants to start with a string of length n and perform n - 1 operations to finally get a one-letter string "a". In how many ways can he choose the starting string to be able to get "a"? Remember that Limak can use only letters he knows.
Input
The first line contains two integers n and q (2 β€ n β€ 6, 1 β€ q β€ 36) β the length of the initial string and the number of available operations.
The next q lines describe the possible operations. The i-th of them contains two strings ai and bi (|ai| = 2, |bi| = 1). It's guaranteed that ai β aj for i β j and that all ai and bi consist of only first six lowercase English letters.
Output
Print the number of strings of length n that Limak will be able to transform to string "a" by applying only operations given in the input.
Examples
Input
3 5
ab a
cc c
ca a
ee c
ff d
Output
4
Input
2 8
af e
dc d
cc f
bc b
da b
eb a
bb b
ff c
Output
1
Input
6 2
bb a
ba a
Output
0
Note
In the first sample, we count initial strings of length 3 from which Limak can get a required string "a". There are 4 such strings: "abb", "cab", "cca", "eea". The first one Limak can compress using operation 1 two times (changing "ab" to a single "a"). The first operation would change "abb" to "ab" and the second operation would change "ab" to "a".
Other three strings may be compressed as follows:
* "cab" <image> "ab" <image> "a"
* "cca" <image> "ca" <image> "a"
* "eea" <image> "ca" <image> "a"
In the second sample, the only correct initial string is "eb" because it can be immediately compressed to "a".
|
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Bearcompress {
static int count=0;
static String ar[];
static char a[];
static int q;
static int n;
public static void main(String[] args)
{
// TODO Auto-generated method stub
MyScannerbrc sc=new MyScannerbrc();
n=sc.nextInt();
q=sc.nextInt();
ar=new String[q];
a=new char[q];
int i;
for(i=0;i<q;i++)
{
ar[i]=sc.next();
a[i]=sc.next().charAt(0);
}
find(1,'a');
System.out.println(count);
}
static void find(int h,char fc)
{
int i;
if(h!=n)
for(i=0;i<q;i++)
{
if(fc==a[i])
{
find(h+1,ar[i].charAt(0));
}
}
else
count+=1;
}
}
class MyScannerbrc
{
BufferedReader br;
StringTokenizer st;
MyScannerbrc()
{
br=new BufferedReader(new InputStreamReader(System.in));
}
String next()
{
while(st==null || !st.hasMoreTokens())
{
try
{
st=new StringTokenizer(br.readLine());
}
catch(Exception 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(Exception e)
{
e.printStackTrace();
}
return str;
}
}
|
Lena is a programmer. She got a task to solve at work.
There is an empty set of pairs of integers and n queries to process. Each query is one of three types:
1. Add a pair (a, b) to the set.
2. Remove a pair added in the query number i. All queries are numbered with integers from 1 to n.
3. For a given integer q find the maximal value xΒ·q + y over all pairs (x, y) from the set.
Help Lena to process the queries.
Input
The first line of input contains integer n (1 β€ n β€ 3Β·105) β the number of queries.
Each of the next n lines starts with integer t (1 β€ t β€ 3) β the type of the query.
A pair of integers a and b ( - 109 β€ a, b β€ 109) follows in the query of the first type.
An integer i (1 β€ i β€ n) follows in the query of the second type. It is guaranteed that i is less than the number of the query, the query number i has the first type and the pair from the i-th query is not already removed.
An integer q ( - 109 β€ q β€ 109) follows in the query of the third type.
Output
For the queries of the third type print on a separate line the desired maximal value of xΒ·q + y.
If there are no pairs in the set print "EMPTY SET".
Example
Input
7
3 1
1 2 3
3 1
1 -1 100
3 1
2 4
3 1
Output
EMPTY SET
5
99
5
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1);
const int MOD = (int)1e9 + 7;
const int MAXN = (int)3e6 + 7;
struct line {
long long slope, delta;
line() {}
line(long long k, long long c) {
slope = k;
delta = c;
}
friend bool operator<(line a, line b) {
if (a.slope != b.slope) return a.slope < b.slope;
return a.delta < b.delta;
}
};
double intersection(line x, line y) {
return (double)(x.delta - y.delta) / (double)(y.slope - x.slope);
}
const long long SOSMALL = -(1LL << 62);
long long optima(vector<line> &st, int x) {
if (st.empty()) return SOSMALL;
int l = 0, r = (int)st.size();
while (r - l > 1) {
int mid = (l + r) / 2;
if (intersection(st[mid], st[mid + 1]) <= x) {
l = mid;
} else {
r = mid;
}
}
long long optimus = SOSMALL;
for (int i = max(0, l - 5); i < min(l + 5, (int)st.size()); i++)
optimus = max(optimus, st[i].delta + st[i].slope * 1ll * x);
return optimus;
}
vector<line> lazy[MAXN];
vector<int> query[MAXN];
int n;
int t[MAXN];
int a[MAXN];
int b[MAXN];
int en[MAXN];
void add(int l, int r, line x, int v = 1, int tl = 1, int tr = n) {
if (tl > r || tr < l) return;
if (l <= tl && tr <= r) {
lazy[v].push_back(x);
return;
}
int mid = (tl + tr) / 2;
add(l, r, x, v + v, tl, mid);
add(l, r, x, v + v + 1, mid + 1, tr);
}
void add_line(vector<line> &st, line w) {
while (st.size() > 1 && intersection(st[st.size() - 2], st[st.size() - 1]) >
intersection(st[st.size() - 2], w))
st.pop_back();
st.push_back(w);
}
vector<line> calc(vector<line> st) {
sort(st.begin(), st.end());
vector<line> res;
for (auto it : st) {
while (!res.empty() && res.back().slope == it.slope) {
assert(it.delta >= res.back().delta);
res.pop_back();
}
res.push_back(it);
}
return res;
}
void traverse(int v = 1, int tl = 1, int tr = n) {
auto tmp = calc(lazy[v]);
lazy[v].clear();
for (auto it : tmp) {
add_line(lazy[v], it);
}
if (tl != tr) {
int mid = (tl + tr) / 2;
traverse(v + v, tl, mid);
traverse(v + v + 1, mid + 1, tr);
}
}
void dfs(int v = 1, int tl = 1, int tr = n) {
if (tl == tr) {
if (query[tl].empty()) return;
long long ans = SOSMALL;
for (int i = v; i > 0; i /= 2)
ans = max(ans, optima(lazy[i], query[tl][0]));
if (ans == SOSMALL) {
puts("EMPTY SET");
} else {
printf("%lld\n", ans);
}
} else {
int mid = (tl + tr) / 2;
dfs(v + v, tl, mid);
dfs(v + v + 1, mid + 1, tr);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &t[i], &a[i]);
if (t[i] == 1) {
scanf("%d", &b[i]);
} else if (t[i] == 2) {
en[a[i]] = i;
} else {
query[i].push_back(a[i]);
}
}
for (int i = 1; i <= n; i++) {
if (t[i] == 1) {
if (!en[i]) en[i] = n;
add(i, en[i], line(a[i], b[i]));
}
}
traverse();
dfs();
return 0;
}
|
There are n cards (n is even) in the deck. Each card has a positive integer written on it. n / 2 people will play new card game. At the beginning of the game each player gets two cards, each card is given to exactly one player.
Find the way to distribute cards such that the sum of values written of the cards will be equal for each player. It is guaranteed that it is always possible.
Input
The first line of the input contains integer n (2 β€ n β€ 100) β the number of cards in the deck. It is guaranteed that n is even.
The second line contains the sequence of n positive integers a1, a2, ..., an (1 β€ ai β€ 100), where ai is equal to the number written on the i-th card.
Output
Print n / 2 pairs of integers, the i-th pair denote the cards that should be given to the i-th player. Each card should be given to exactly one player. Cards are numbered in the order they appear in the input.
It is guaranteed that solution exists. If there are several correct answers, you are allowed to print any of them.
Examples
Input
6
1 5 7 4 4 3
Output
1 3
6 2
4 5
Input
4
10 10 10 10
Output
1 2
3 4
Note
In the first sample, cards are distributed in such a way that each player has the sum of numbers written on his cards equal to 8.
In the second sample, all values ai are equal. Thus, any distribution is acceptable.
|
n = int(input())
s = list(map(int, input().split()))
dif = 2 * sum(s) // n
t = []
for i in range(n):
for j in range(n):
if s[i] + s[j] == dif and i not in t and j not in t and i != j:
print(i + 1, j + 1)
t.append(i)
t.append(j)
|
Modern text editors usually show some information regarding the document being edited. For example, the number of words, the number of pages, or the number of characters.
In this problem you should implement the similar functionality.
You are given a string which only consists of:
* uppercase and lowercase English letters,
* underscore symbols (they are used as separators),
* parentheses (both opening and closing).
It is guaranteed that each opening parenthesis has a succeeding closing parenthesis. Similarly, each closing parentheses has a preceding opening parentheses matching it. For each pair of matching parentheses there are no other parenthesis between them. In other words, each parenthesis in the string belongs to a matching "opening-closing" pair, and such pairs can't be nested.
For example, the following string is valid: "_Hello_Vasya(and_Petya)__bye_(and_OK)".
Word is a maximal sequence of consecutive letters, i.e. such sequence that the first character to the left and the first character to the right of it is an underscore, a parenthesis, or it just does not exist. For example, the string above consists of seven words: "Hello", "Vasya", "and", "Petya", "bye", "and" and "OK". Write a program that finds:
* the length of the longest word outside the parentheses (print 0, if there is no word outside the parentheses),
* the number of words inside the parentheses (print 0, if there is no word inside the parentheses).
Input
The first line of the input contains a single integer n (1 β€ n β€ 255) β the length of the given string. The second line contains the string consisting of only lowercase and uppercase English letters, parentheses and underscore symbols.
Output
Print two space-separated integers:
* the length of the longest word outside the parentheses (print 0, if there is no word outside the parentheses),
* the number of words inside the parentheses (print 0, if there is no word inside the parentheses).
Examples
Input
37
_Hello_Vasya(and_Petya)__bye_(and_OK)
Output
5 4
Input
37
_a_(_b___c)__de_f(g_)__h__i(j_k_l)m__
Output
2 6
Input
27
(LoooonG)__shOrt__(LoooonG)
Output
5 2
Input
5
(___)
Output
0 0
Note
In the first sample, the words "Hello", "Vasya" and "bye" are outside any of the parentheses, and the words "and", "Petya", "and" and "OK" are inside. Note, that the word "and" is given twice and you should count it twice in the answer.
|
def solution():
m = raw_input()
line = raw_input().split(')')
if len(line) == 1:
print max(len(o) for o in line[0].split('_')), 0
return
max_len = 0
number_in = 0
for l in line:
splitted = l.split('(')
if len(splitted) == 1:
# we are in the end
before = splitted[0]
after = ''
else:
before, after = splitted
max_len = max(max_len, max(len(o) for o in before.split('_')))
number_in += len(filter(lambda o: len(o) > 0, after.split('_')))
print max_len, number_in
if __name__ == '__main__':
solution()
|
Hongcow is learning to spell! One day, his teacher gives him a word that he needs to learn to spell. Being a dutiful student, he immediately learns how to spell the word.
Hongcow has decided to try to make new words from this one. He starts by taking the word he just learned how to spell, and moves the last character of the word to the beginning of the word. He calls this a cyclic shift. He can apply cyclic shift many times. For example, consecutively applying cyclic shift operation to the word "abracadabra" Hongcow will get words "aabracadabr", "raabracadab" and so on.
Hongcow is now wondering how many distinct words he can generate by doing the cyclic shift arbitrarily many times. The initial string is also counted.
Input
The first line of input will be a single string s (1 β€ |s| β€ 50), the word Hongcow initially learns how to spell. The string s consists only of lowercase English letters ('a'β'z').
Output
Output a single integer equal to the number of distinct strings that Hongcow can obtain by applying the cyclic shift arbitrarily many times to the given string.
Examples
Input
abcd
Output
4
Input
bbb
Output
1
Input
yzyz
Output
2
Note
For the first sample, the strings Hongcow can generate are "abcd", "dabc", "cdab", and "bcda".
For the second sample, no matter how many times Hongcow does the cyclic shift, Hongcow can only generate "bbb".
For the third sample, the two strings Hongcow can generate are "yzyz" and "zyzy".
|
from collections import Counter
s = input()
counter = Counter()
for i in range(len(s)):
counter[s[i:len(s)] + s[0:i]] = 1
print(sum(counter.values()))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.