input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
Vasya owns three strings s , a and b, each of them consists only of first k Latin letters.
Let a template be such a string of length k that each of the first k Latin letters appears in it exactly once (thus there are k! distinct templates). Application of template p to the string s is the replacement of each character in string s with p_i, i is the index of this letter in the alphabet. For example, applying template "bdca" to a string "aabccd" yields string "bbdcca".
Vasya wants to know if there exists such a template which yields a string lexicographically greater than or equal to string a and lexicographically less than or equal to string b after applying it to s.
If there exist multiple suitable templates, print any of them.
String a is lexicographically less than string b if there is some i (1 ≤ i ≤ n) that a_i < b_i and for any j (1 ≤ j < i) a_j = b_j.
You are required to answer t testcases independently.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^6) — the number of testcases.
In hacks you can only use t = 1.
Each of the next t lines contains the description of the testcase in the following form:
The first line of the testcase contains a single integer k (1 ≤ k ≤ 26) — the length of the template.
The second line of the testcase contains the string s (1 ≤ |s| ≤ 10^6).
The third line of the testcase contains the string a.
The fourth line of the testcase contains the string b.
Strings s, a and b have the same length (|s| = |a| = |b|) and consist only of the first k Latin letters, all letters are lowercase.
It is guaranteed that string a is lexicographically less than or equal to string b.
It is also guaranteed that the total length of strings over all testcase won't exceed 3 ⋅ 10^6.
Output
Print the answers to all testcases in the following form:
If there exists no suitable template then print "NO" in the first line.
Otherwise print "YES" in the first line and the template itself in the second line (k lowercase letters, each of the first k Latin letters should appear exactly once).
If there exist multiple suitable templates, print any of them.
Example
Input
2
4
bbcb
aada
aada
3
abc
bbb
bbb
Output
YES
badc
NO
|
#include <bits/stdc++.h>
using namespace std;
string a, b, ds, s, temp;
bool used[26];
bool fore, back, filled;
void fill_temp(char c, int b, int e) {
if (temp[c - 'a'] != '$') return;
for (int i = b; i <= e; ++i) {
if (!used[i]) {
temp[c - 'a'] = i + 'a';
used[i] = true;
return;
}
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int k, t;
cin >> t;
for (int q = 0; q < t; ++q) {
cin >> k >> ds >> a >> b;
s = ds;
temp = string(k, '$');
fill(used, used + k, false);
fore = false, back = false;
for (int i = 0; i < a.size(); ++i) {
if (temp[s[i] - 'a'] == '$') {
if (fore) {
fill_temp(s[i], 0, b[i] - 'a');
} else if (back) {
fill_temp(s[i], a[i] - 'a' + 1, k - 1);
fill_temp(s[i], a[i] - 'a', a[i] - 'a');
} else {
fill_temp(s[i], a[i] - 'a' + 1, b[i] - 'a' - 1);
fill_temp(s[i], a[i] - 'a', a[i] - 'a');
fill_temp(s[i], b[i] - 'a', b[i] - 'a');
}
}
if (temp[s[i] - 'a'] == '$') {
s[0] = 'A';
break;
}
s[i] = temp[s[i] - 'a'];
if ((!fore && s[i] < a[i]) || (!back && b[i] < s[i])) break;
if (a[i] < s[i]) fore = true;
if (s[i] < b[i]) back = true;
if (fore && back) break;
}
if (a <= s && s <= b) {
cout << "YES\n";
for (char c = 'a'; c < 'a' + k; ++c) {
fill_temp(c, 0, k - 1);
}
cout << temp << "\n";
continue;
}
s = ds;
temp = string(k, '$');
fill(used, used + k, false);
fore = false, back = false;
for (int i = 0; i < a.size(); ++i) {
if (temp[s[i] - 'a'] == '$') {
if (fore) {
fill_temp(s[i], 0, b[i] - 'a');
} else if (back) {
fill_temp(s[i], a[i] - 'a' + 1, k - 1);
fill_temp(s[i], a[i] - 'a', a[i] - 'a');
} else {
fill_temp(s[i], a[i] - 'a' + 1, b[i] - 'a' - 1);
fill_temp(s[i], b[i] - 'a', b[i] - 'a');
fill_temp(s[i], a[i] - 'a', a[i] - 'a');
}
}
if (temp[s[i] - 'a'] == '$') {
s[0] = 'A';
break;
}
s[i] = temp[s[i] - 'a'];
if ((!fore && s[i] < a[i]) || (!back && b[i] < s[i])) break;
if (a[i] < s[i]) fore = true;
if (s[i] < b[i]) back = true;
if (fore && back) break;
}
if (a <= s && s <= b) {
cout << "YES\n";
for (char c = 'a'; c < 'a' + k; ++c) {
fill_temp(c, 0, k - 1);
}
cout << temp << "\n";
continue;
}
cout << "NO\n";
}
return 0;
}
|
Lunar New Year is approaching, and Bob is struggling with his homework – a number division problem.
There are n positive integers a_1, a_2, …, a_n on Bob's homework paper, where n is always an even number. Bob is asked to divide those numbers into groups, where each group must contain at least 2 numbers. Suppose the numbers are divided into m groups, and the sum of the numbers in the j-th group is s_j. Bob's aim is to minimize the sum of the square of s_j, that is $$$∑_{j = 1}^{m} s_j^2.$$$
Bob is puzzled by this hard problem. Could you please help him solve it?
Input
The first line contains an even integer n (2 ≤ n ≤ 3 ⋅ 10^5), denoting that there are n integers on Bob's homework paper.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^4), describing the numbers you need to deal with.
Output
A single line containing one integer, denoting the minimum of the sum of the square of s_j, which is $$$∑_{i = j}^{m} s_j^2, where m$$$ is the number of groups.
Examples
Input
4
8 5 2 3
Output
164
Input
6
1 1 1 2 2 2
Output
27
Note
In the first sample, one of the optimal solutions is to divide those 4 numbers into 2 groups \{2, 8\}, \{5, 3\}. Thus the answer is (2 + 8)^2 + (5 + 3)^2 = 164.
In the second sample, one of the optimal solutions is to divide those 6 numbers into 3 groups \{1, 2\}, \{1, 2\}, \{1, 2\}. Thus the answer is (1 + 2)^2 + (1 + 2)^2 + (1 + 2)^2 = 27.
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
long long a[n];
long long sum = 0;
for (int i = 0; i < (n); i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < (n / 2); i++) {
sum += (a[i] + a[n - i - 1]) * (a[i] + a[n - i - 1]);
}
cout << sum;
return 0;
}
|
You are given two arrays a and b, each contains n integers.
You want to create a new array c as follows: choose some real (i.e. not necessarily integer) number d, and then for every i ∈ [1, n] let c_i := d ⋅ a_i + b_i.
Your goal is to maximize the number of zeroes in array c. What is the largest possible answer, if you choose d optimally?
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in both arrays.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9).
The third line contains n integers b_1, b_2, ..., b_n (-10^9 ≤ b_i ≤ 10^9).
Output
Print one integer — the maximum number of zeroes in array c, if you choose d optimally.
Examples
Input
5
1 2 3 4 5
2 4 7 11 3
Output
2
Input
3
13 37 39
1 2 3
Output
2
Input
4
0 0 0 0
1 2 3 4
Output
0
Input
3
1 2 -1
-6 -12 6
Output
3
Note
In the first example, we may choose d = -2.
In the second example, we may choose d = -1/13.
In the third example, we cannot obtain any zero in array c, no matter which d we choose.
In the fourth example, we may choose d = 6.
|
import sys, math
from sys import stdin, stdout
rem = 10 ** 9 + 7
inf = 10 ** 18
sys.setrecursionlimit(10 ** 6 + 7)
#from resource import *; setrlimit(RLIMIT_STACK, (RLIM_INFINITY, RLIM_INFINITY))
take = lambda: map(int, stdin.readline().split())
from heapq import heappush, heappop, heapify
from collections import deque
from bisect import *
def gcd(x, y):
while (y):
x, y = y, x % y
return x
n=input()
a=take()
b=take()
cnt={}
cnt[inf]=0
cnt[-inf]=0
cnt[0]=0
free=0
for i in range(n):
x=a[i]
y=b[i]
if x==0 and y==0:
free+=1
continue
if y==0:
cnt[0]+=1
continue
if x==0:
continue
k=gcd(x,y)
x/=k
y/=k
if x*y>0:
p=(-y,x)
if p not in cnt:
cnt[p]=0
cnt[p]+=1
else:
p = (y, x)
if p not in cnt:
cnt[p] = 0
cnt[p] += 1
#print cnt
print max(cnt.values())+free
|
Polycarp has guessed three positive integers a, b and c. He keeps these numbers in secret, but he writes down four numbers on a board in arbitrary order — their pairwise sums (three numbers) and sum of all three numbers (one number). So, there are four numbers on a board in random order: a+b, a+c, b+c and a+b+c.
You have to guess three numbers a, b and c using given numbers. Print three guessed integers in any order.
Pay attention that some given numbers a, b and c can be equal (it is also possible that a=b=c).
Input
The only line of the input contains four positive integers x_1, x_2, x_3, x_4 (2 ≤ x_i ≤ 10^9) — numbers written on a board in random order. It is guaranteed that the answer exists for the given number x_1, x_2, x_3, x_4.
Output
Print such positive integers a, b and c that four numbers written on a board are values a+b, a+c, b+c and a+b+c written in some order. Print a, b and c in any order. If there are several answers, you can print any. It is guaranteed that the answer exists.
Examples
Input
3 6 5 4
Output
2 1 3
Input
40 40 40 60
Output
20 20 20
Input
201 101 101 200
Output
1 100 100
|
x,y,z,w = (int(i) for i in input().split())
s = (x+y+z+w)//3
for i in x,y,z,w:
temp = s - i
if s - i > 0:
print(s-i, end=' ')
|
You have an array a_1, a_2, ..., a_n.
Let's call some subarray a_l, a_{l + 1}, ... , a_r of this array a subpermutation if it contains all integers from 1 to r-l+1 exactly once. For example, array a = [2, 2, 1, 3, 2, 3, 1] contains 6 subarrays which are subpermutations: [a_2 ... a_3], [a_2 ... a_4], [a_3 ... a_3], [a_3 ... a_5], [a_5 ... a_7], [a_7 ... a_7].
You are asked to calculate the number of subpermutations.
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5).
The second line contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ n).
This array can contain the same integers.
Output
Print the number of subpermutations of the array a.
Examples
Input
8
2 4 1 3 4 2 1 2
Output
7
Input
5
1 1 2 1 2
Output
6
Note
There are 7 subpermutations in the first test case. Their segments of indices are [1, 4], [3, 3], [3, 6], [4, 7], [6, 7], [7, 7] and [7, 8].
In the second test case 6 subpermutations exist: [1, 1], [2, 2], [2, 3], [3, 4], [4, 4] and [4, 5].
|
#include <bits/stdc++.h>
using namespace std;
int a[300010], pre[300010], pos[300010];
int n;
int max_[1200010];
int f(int x, int y) {
if (a[x] > a[y]) return x;
return y;
}
void pushup(int rt) { max_[rt] = f(max_[rt << 1], max_[rt << 1 | 1]); }
void build(int l, int r, int rt) {
if (l == r) {
max_[rt] = l;
return;
}
int m = l + r >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
pushup(rt);
}
int query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return max_[rt];
int m = l + r >> 1;
int ans = 0;
if (m >= L) ans = f(ans, query(L, R, l, m, rt << 1));
if (m < R) ans = f(ans, query(L, R, m + 1, r, rt << 1 | 1));
return ans;
}
long long solve(int l, int r) {
if (l == r) {
if (a[l] == 1) return 1;
return 0;
}
if (l > r) return 0;
int mid = query(l, r, 1, n, 1);
int i;
long long ans = 0;
if (mid - l < r - mid) {
for (i = l; i <= mid; i++) {
if (i + a[mid] - 1 < mid) continue;
if (i + a[mid] - 1 > r) break;
if (pre[i + a[mid] - 1] < i) ans++;
}
} else {
for (i = r; i >= mid; i--) {
if (i - a[mid] + 1 > mid) continue;
if (i - a[mid] + 1 < l) break;
if (pre[i] < i - a[mid] + 1) ans++;
}
}
ans += solve(l, mid - 1);
ans += solve(mid + 1, r);
return ans;
}
int main() {
scanf("%d", &n);
int i;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pre[i] = pos[a[i]];
pre[i] = max(pre[i], pre[i - 1]);
pos[a[i]] = i;
}
long long ans = 0;
build(1, n, 1);
ans = solve(1, n);
printf("%lld\n", ans);
return 0;
}
|
There are n segments drawn on a plane; the i-th segment connects two points (x_{i, 1}, y_{i, 1}) and (x_{i, 2}, y_{i, 2}). Each segment is non-degenerate, and is either horizontal or vertical — formally, for every i ∈ [1, n] either x_{i, 1} = x_{i, 2} or y_{i, 1} = y_{i, 2} (but only one of these conditions holds). Only segments of different types may intersect: no pair of horizontal segments shares any common points, and no pair of vertical segments shares any common points.
We say that four segments having indices h_1, h_2, v_1 and v_2 such that h_1 < h_2 and v_1 < v_2 form a rectangle if the following conditions hold:
* segments h_1 and h_2 are horizontal;
* segments v_1 and v_2 are vertical;
* segment h_1 intersects with segment v_1;
* segment h_2 intersects with segment v_1;
* segment h_1 intersects with segment v_2;
* segment h_2 intersects with segment v_2.
Please calculate the number of ways to choose four segments so they form a rectangle. Note that the conditions h_1 < h_2 and v_1 < v_2 should hold.
Input
The first line contains one integer n (1 ≤ n ≤ 5000) — the number of segments.
Then n lines follow. The i-th line contains four integers x_{i, 1}, y_{i, 1}, x_{i, 2} and y_{i, 2} denoting the endpoints of the i-th segment. All coordinates of the endpoints are in the range [-5000, 5000].
It is guaranteed that each segment is non-degenerate and is either horizontal or vertical. Furthermore, if two segments share a common point, one of these segments is horizontal, and another one is vertical.
Output
Print one integer — the number of ways to choose four segments so they form a rectangle.
Examples
Input
7
-1 4 -1 -2
6 -1 -2 -1
-2 3 6 3
2 -2 2 4
4 -1 4 3
5 3 5 1
5 2 1 2
Output
7
Input
5
1 5 1 0
0 1 5 1
5 4 0 4
4 2 4 0
4 3 4 5
Output
0
Note
The following pictures represent sample cases:
<image> <image>
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long n, m, a, b, c, k, x, y;
const int MAXN = 1e5 + 11, mod = 1e9 + 7;
long long max(long long a, long long b) { return ((a > b) ? a : b); }
long long min(long long a, long long b) { return ((a > b) ? b : a); }
vector<long long> read(int n) {
vector<long long> v(n);
for (int i = 0; i < v.size(); i++) cin >> v[i];
return v;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
pair<long long, long long> intersection(pair<long long, long long> p1,
pair<long long, long long> p2) {
if (p1.first > p2.first) swap(p1, p2);
if (p2.first > p1.second) return {0, -1};
return {p2.first, min(p1.second, p2.second)};
}
long long tree[20025];
long long qfst(int l, int r) {
long long res = 0;
for (l += 10001, r += 10001; l < r; l >>= 1, r >>= 1) {
if (l & 1) res += tree[l++];
if (r & 1) res += tree[--r];
}
return res;
}
void modify(int p, int value) {
for (tree[p += 10001] = value; p > 1; p >>= 1)
tree[p >> 1] = tree[p] + tree[p ^ 1];
}
void sol(void) {
cin >> n;
vector<pair<long long, pair<long long, long long>>> vph, vpv;
for (int i = 0; i < n; i++) {
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (y1 == y2 && x1 > x2) {
swap(x1, x2);
} else if (x1 == x2 && y1 > y2) {
swap(y1, y2);
}
x1 += 5000;
x2 += 5000;
y1 += 5000;
y2 += 5000;
if (x1 == x2)
vpv.push_back({y1, {x1, y2}});
else
vph.push_back({y1, {x1, x2}});
}
sort(vph.begin(), vph.end());
sort(vpv.begin(), vpv.end());
long long ans = 0;
set<pair<long long, long long>> s;
int r = 0;
for (int i = 0; i < vph.size(); i++) {
while (r < vpv.size() && vpv[r].first <= vph[i].first) {
s.insert({vpv[r].second.second, vpv[r].second.first});
modify(vpv[r].second.first,
qfst(vpv[r].second.first, vpv[r].second.first + 1) + 1);
r++;
}
set<pair<long long, long long>> temp;
for (int j = i + 1; j < vph.size(); j++) {
while (s.size() && (*s.begin()).first < vph[j].first) {
modify((*s.begin()).second,
qfst((*s.begin()).second, (*s.begin()).second + 1) - 1);
temp.insert(*s.begin());
s.erase(s.begin());
}
pair<long long, long long> p = intersection(vph[i].second, vph[j].second);
if (p.second - p.first + 1 > 0) {
long long calc = qfst(p.first, p.second + 1);
ans += (calc * (calc - 1));
}
}
while (temp.size()) {
if ((*temp.begin()).first < vph[i].first)
temp.erase(temp.begin());
else {
s.insert(*temp.begin());
modify((*temp.begin()).second,
qfst((*temp.begin()).second, (*temp.begin()).second + 1) + 1);
temp.erase(temp.begin());
}
}
}
cout << (ans >> 1);
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test = 1;
for (int i = 1; i <= test; i++) sol();
}
|
You are both a shop keeper and a shop assistant at a small nearby shop. You have n goods, the i-th good costs a_i coins.
You got tired of remembering the price of each product when customers ask for it, thus you decided to simplify your life. More precisely you decided to set the same price for all n goods you have.
However, you don't want to lose any money so you want to choose the price in such a way that the sum of new prices is not less than the sum of the initial prices. It means that if you sell all n goods for the new price, you will receive at least the same (or greater) amount of money as if you sell them for their initial prices.
On the other hand, you don't want to lose customers because of big prices so among all prices you can choose you need to choose the minimum one.
So you need to find the minimum possible equal price of all n goods so if you sell them for this price, you will receive at least the same (or greater) amount of money as if you sell them for their initial prices.
You have to answer q independent queries.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of queries. Then q queries follow.
The first line of the query contains one integer n (1 ≤ n ≤ 100) — the number of goods. The second line of the query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^7), where a_i is the price of the i-th good.
Output
For each query, print the answer for it — the minimum possible equal price of all n goods so if you sell them for this price, you will receive at least the same (or greater) amount of money as if you sell them for their initial prices.
Example
Input
3
5
1 2 3 4 5
3
1 2 2
4
1 1 1 1
Output
3
2
1
|
import math
for _ in range(int(input())):
k=int(input())
l=list(map(int,input().split()))
k=sum(l)/k
print(math.ceil(k))
|
Vasya has a tree with n vertices numbered from 1 to n, and n - 1 edges numbered from 1 to n - 1. Initially each vertex contains a token with the number of the vertex written on it.
Vasya plays a game. He considers all edges of the tree by increasing of their indices. For every edge he acts as follows:
* If both endpoints of the edge contain a token, remove a token from one of the endpoints and write down its number.
* Otherwise, do nothing.
The result of the game is the sequence of numbers Vasya has written down. Note that there may be many possible resulting sequences depending on the choice of endpoints when tokens are removed.
Vasya has played for such a long time that he thinks he exhausted all possible resulting sequences he can obtain. He wants you to verify him by computing the number of distinct sequences modulo 998 244 353.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of vertices of the tree.
The next n - 1 lines describe edges of the tree. The i-th of these lines contains two integers u_i, v_i (1 ≤ u_i, v_i ≤ n) — endpoints of the edge with index i. It is guaranteed that the given graph is indeed a tree.
Output
Print a single integer — the number of distinct sequences modulo 998 244 353.
Examples
Input
5
1 2
1 3
1 4
1 5
Output
5
Input
7
7 2
7 6
1 2
7 5
4 7
3 5
Output
10
Note
In the first sample case the distinct sequences are (1), (2, 1), (2, 3, 1), (2, 3, 4, 1), (2, 3, 4, 5).
Int the second sample case the distinct sequences are (2, 6, 5, 3), (2, 6, 5, 7), (2, 6, 7, 2), (2, 6, 7, 5), (2, 7, 3), (2, 7, 5), (7, 1, 3), (7, 1, 5), (7, 2, 3), (7, 2, 5).
|
#include <bits/stdc++.h>
using namespace std;
int n, i, j, k, x, y;
vector<int> e[200005];
long long f[200005][4], pre[200005], nex[200005];
void DFS(int x, int p) {
int fi = 0, y, k;
for (int i = 0; i < e[x].size(); i++)
if (e[x][i] == p) {
fi = i;
break;
}
for (int i = 0; i < e[x].size(); i++)
if (e[x][i] != p) DFS(e[x][i], x);
f[x][0] = f[x][2] = pre[0] = 1;
for (int i = 0; i < e[x].size(); i++)
if (e[x][i] != p) {
y = e[x][i];
(f[x][0] *= (f[y][1] + f[y][2]) % 998244353) %= 998244353;
if (i < fi) (f[x][2] *= (f[y][1] + f[y][2]) % 998244353) %= 998244353;
if (i > fi)
(f[x][2] *= (f[y][0] + f[y][1] + f[y][3]) % 998244353) %= 998244353;
pre[i + 1] = ((f[y][1] + f[y][2]) % 998244353 * pre[i]) % 998244353;
} else
pre[i + 1] = pre[i];
nex[e[x].size()] = 1;
for (int i = e[x].size() - 1; i >= 0; i--)
if (e[x][i] != p) {
y = e[x][i];
nex[i] =
((f[y][0] + f[y][1] + f[y][3]) % 998244353 * nex[i + 1]) % 998244353;
} else
nex[i] = nex[i + 1];
for (int i = 0; i < e[x].size(); i++)
if (e[x][i] != p) {
y = e[x][i], k = (i < fi) ? 1 : 3;
f[x][k] += (f[y][0] + f[y][3]) % 998244353 * pre[i] % 998244353 *
nex[i + 1] % 998244353;
}
f[x][1] %= 998244353, f[x][3] %= 998244353;
}
int main() {
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
}
DFS(1, 0);
printf("%lld", (f[1][0] + f[1][1] + f[1][3]) % 998244353);
}
|
This is an easy version of the problem. The actual problems are different, but the easy version is almost a subtask of the hard version. Note that the constraints and the output format are different.
You are given a string s consisting of n lowercase Latin letters.
You have to color all its characters one of the two colors (each character to exactly one color, the same letters can be colored the same or different colors, i.e. you can choose exactly one color for each index in s).
After coloring, you can swap any two neighboring characters of the string that are colored different colors. You can perform such an operation arbitrary (possibly, zero) number of times.
The goal is to make the string sorted, i.e. all characters should be in alphabetical order.
Your task is to say if it is possible to color the given string so that after coloring it can become sorted by some sequence of swaps. Note that you have to restore only coloring, not the sequence of swaps.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 200) — the length of s.
The second line of the input contains the string s consisting of exactly n lowercase Latin letters.
Output
If it is impossible to color the given string so that after coloring it can become sorted by some sequence of swaps, print "NO" (without quotes) in the first line.
Otherwise, print "YES" in the first line and any correct coloring in the second line (the coloring is the string consisting of n characters, the i-th character should be '0' if the i-th character is colored the first color and '1' otherwise).
Examples
Input
9
abacbecfd
Output
YES
001010101
Input
8
aaabbcbb
Output
YES
01011011
Input
7
abcdedc
Output
NO
Input
5
abcde
Output
YES
00000
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 205;
int n, ans[MAX];
char a[MAX];
int main() {
scanf("%d", &n);
scanf("%s", a + 1);
for (int i = 1; i <= n; i++) {
if (!ans[i]) ans[i] = 2;
for (int j = i + 1; j <= n; j++) {
if (a[i] > a[j]) {
if (ans[i] == ans[j]) {
printf("NO");
return 0;
}
ans[j] = ans[i] ^ 1;
}
}
}
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d", ans[i] - 2);
return 0;
}
|
A queen is the strongest chess piece. In modern chess the queen can move any number of squares in any horizontal, vertical or diagonal direction (considering that there're no other pieces on its way). The queen combines the options given to the rook and the bishop.
There are m queens on a square n × n chessboard. You know each queen's positions, the i-th queen is positioned in the square (ri, ci), where ri is the board row number (numbered from the top to the bottom from 1 to n), and ci is the board's column number (numbered from the left to the right from 1 to n). No two queens share the same position.
For each queen one can count w — the number of other queens that the given queen threatens (attacks). For a fixed attack direction only the first queen in this direction is under attack if there are many queens are on the ray of the attack. Obviously, for any queen w is between 0 and 8, inclusive.
Print the sequence t0, t1, ..., t8, where ti is the number of queens that threaten exactly i other queens, i.e. the number of queens that their w equals i.
Input
The first line of the input contains a pair of integers n, m (1 ≤ n, m ≤ 105), where n is the size of the board and m is the number of queens on the board. Then m following lines contain positions of the queens, one per line. Each line contains a pair of integers ri, ci (1 ≤ ri, ci ≤ n) — the queen's position. No two queens stand on the same square.
Output
Print the required sequence t0, t1, ..., t8, separating the numbers with spaces.
Examples
Input
8 4
4 3
4 8
6 5
1 6
Output
0 3 0 1 0 0 0 0 0
Input
10 3
1 1
1 2
1 3
Output
0 2 1 0 0 0 0 0 0
|
import java.io.*;
import java.util.*;
public class E {
BufferedReader in;
StringTokenizer st;
PrintWriter out;
String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(in.readLine());
return st.nextToken();
}
int nextInt() throws Exception {
return Integer.parseInt(next());
}
long nextLong() throws Exception {
return Long.parseLong(next());
}
double nextDouble() throws Exception {
return Double.parseDouble(next());
}
void solve() throws Exception {
int n = nextInt();
int m = nextInt();
int[] Q = new int[m];
int[] W = new int[m];
int[] d1q = new int[2 * n];
int[] d2q = new int[2 * n];
int[] hq = new int[n];
int[] vq = new int[n];
int[] d1w = new int[2 * n];
int[] d2w = new int[2 * n];
int[] hw = new int[n];
int[] vw = new int[n];
for (int i = 0; i < n; i++) {
hw[i] = Integer.MIN_VALUE;
vw[i] = Integer.MIN_VALUE;
hq[i] = Integer.MAX_VALUE;
vq[i] = Integer.MAX_VALUE;
}
for (int i = 0; i < 2 * n; i++) {
d1w[i] = Integer.MIN_VALUE;
d2w[i] = Integer.MIN_VALUE;
d1q[i] = Integer.MAX_VALUE;
d2q[i] = Integer.MAX_VALUE;
}
for (int i = 0; i < m; i++) {
int q = nextInt() - 1;
Q[i] = q;
int w = nextInt() - 1;
W[i] = w;
hq[q] = Math.min(hq[q], w);
vq[w] = Math.min(vq[w], q);
hw[q] = Math.max(hw[q], w);
vw[w] = Math.max(vw[w], q);
int d1n = q - w + n - 1;
int d2n = w + q;
d1q[d1n] = Math.min(d1q[d1n], w);
d2q[d2n] = Math.min(d2q[d2n], w);
d1w[d1n] = Math.max(d1w[d1n], w);
d2w[d2n] = Math.max(d2w[d2n], w);
}
int[] tot = new int[9];
for (int i = 0; i < 9; i++)
tot[i] = 0;
for (int i = 0; i < m; i++) {
int ans = 8;
int q = Q[i];
int w = W[i];
if (hq[q] == w)
ans--;
if (vq[w] == q)
ans--;
if (hw[q] == w)
ans--;
if (vw[w] == q)
ans--;
int d1n = q - w + n - 1;
int d2n = w + q;
if (d1q[d1n] == w)
ans--;
if (d2q[d2n] == w)
ans--;
if (d1w[d1n] == w)
ans--;
if (d2w[d2n] == w)
ans--;
tot[ans]++;
// out.print(ans);
}
for (int i = 0; i < 9; i++)
out.print(tot[i] + " ");
}
void run() {
try {
Locale.setDefault(Locale.US);
in = new BufferedReader(new InputStreamReader((System.in)));
out = new PrintWriter(System.out);
solve();
out.close();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
public static void main(String[] args) {
new E().run();
}
}
|
You have array of n numbers a_{1}, a_{2}, …, a_{n}.
Rearrange these numbers to satisfy |a_{1} - a_{2}| ≤ |a_{2} - a_{3}| ≤ … ≤ |a_{n-1} - a_{n}|, where |x| denotes absolute value of x. It's always possible to find such rearrangement.
Note that all numbers in a are not necessarily different. In other words, some numbers of a may be same.
You have to answer independent t test cases.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^{4}) — the number of test cases.
The first line of each test case contains single integer n (3 ≤ n ≤ 10^{5}) — the length of array a. It is guaranteed that the sum of values of n over all test cases in the input does not exceed 10^{5}.
The second line of each test case contains n integers a_{1}, a_{2}, …, a_{n} (-10^{9} ≤ a_{i} ≤ 10^{9}).
Output
For each test case, print the rearranged version of array a which satisfies given condition. If there are multiple valid rearrangements, print any of them.
Example
Input
2
6
5 -2 4 8 6 5
4
8 1 4 2
Output
5 5 4 6 8 -2
1 2 4 8
Note
In the first test case, after given rearrangement, |a_{1} - a_{2}| = 0 ≤ |a_{2} - a_{3}| = 1 ≤ |a_{3} - a_{4}| = 2 ≤ |a_{4} - a_{5}| = 2 ≤ |a_{5} - a_{6}| = 10. There are other possible answers like "5 4 5 6 -2 8".
In the second test case, after given rearrangement, |a_{1} - a_{2}| = 1 ≤ |a_{2} - a_{3}| = 2 ≤ |a_{3} - a_{4}| = 4. There are other possible answers like "2 4 8 1".
|
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
vector<long long int> primes;
void sieve(long long int n) {
vector<bool> prime(n + 1, true);
for (long long int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long int i = p * 2; i <= n; i += p) prime[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (prime[p]) primes.push_back(p);
}
long long int gcd(long long int x, long long int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
vector<long long int> vin(long long int n) {
vector<long long int> a(n);
for (long long int i = 0; i < n; i++) cin >> a[i];
return a;
}
void out(vector<long long int> a) {
for (int i = 0; i < (long long int)a.size(); i++) {
cout << a[i] << ' ';
}
cout << '\n';
}
void in(long long int *a, long long int n) {
for (long long int i = 0; i < n; i++) cin >> a[i];
}
void out(long long int *a, long long int n) {
for (long long int i = 0; i < n; i++) {
cout << a[i] << " ";
}
}
void out1(vector<long long int> v) {
for (long long int i = 0; i < (long long int)v.size(); i++) {
cout << v[i] << " ";
}
cout << '\n';
}
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
vector<long long int> v1, v2, v3;
for (long long int i = 0; i < n / 2; i++) {
v1.push_back(a[i]);
}
if (n % 2 == 0) {
for (long long int i = n / 2; i < n; i++) {
v2.push_back(a[i]);
}
} else {
for (long long int i = n / 2 + 1; i < n; i++) {
v2.push_back(a[i]);
}
}
reverse(v2.begin(), v2.end());
for (long long int i = 0; i < v1.size(); i++) {
v3.push_back(v2[i]);
v3.push_back(v1[i]);
}
if (n % 2 != 0) {
v3.push_back(a[n / 2]);
}
reverse(v3.begin(), v3.end());
for (long long int i = 0; i < v3.size(); i++) {
cout << v3[i] << " ";
}
cout << endl;
}
return 0;
}
|
You are given n strings a_1, a_2, …, a_n: all of them have the same length m. The strings consist of lowercase English letters.
Find any string s of length m such that each of the given n strings differs from s in at most one position. Formally, for each given string a_i, there is no more than one position j such that a_i[j] ≠ s[j].
Note that the desired string s may be equal to one of the given strings a_i, or it may differ from all the given strings.
For example, if you have the strings abac and zbab, then the answer to the problem might be the string abab, which differs from the first only by the last character, and from the second only by the first.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
Each test case starts with a line containing two positive integers n (1 ≤ n ≤ 10) and m (1 ≤ m ≤ 10) — the number of strings and their length.
Then follow n strings a_i, one per line. Each of them has length m and consists of lowercase English letters.
Output
Print t answers to the test cases. Each answer (if it exists) is a string of length m consisting of lowercase English letters. If there are several answers, print any of them. If the answer does not exist, print "-1" ("minus one", without quotes).
Example
Input
5
2 4
abac
zbab
2 4
aaaa
bbbb
3 3
baa
aaa
aab
2 2
ab
bb
3 1
a
b
c
Output
abab
-1
aaa
ab
z
Note
The first test case was explained in the statement.
In the second test case, the answer does not exist.
|
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.*;
public class Main {
InputStream is;
PrintWriter out;
String INPUT = "";
//class Declaration
static class pair implements Comparable<pair>{
int x;
int y;
pair (int i,int j)
{ x=i; y=j;
}
public int compareTo(pair p){
if(this.x!=p.x) { return this.x-p.x;}
else { return this.y-p.y;}
}
public int hashCode() { return (x+" "+y).hashCode();}
public String toString(){ return x+" "+y;}
public boolean equals(Object o){
pair x = (pair) o ;
return (x.x==this.x&&x.y==this.y);}
}
int inf = (int)1e9 + 5;
void solve() throws Exception{
int t=ni();
while(t-->0){
int n=ni(),m=ni();
char[][] str = new char[n][m];
for(int i=0;i<n;++i){
str[i] = ns().toCharArray();
}
boolean pos = false ;
String ans = "";
outer : for(int i=0;i<n;++i){
String x = new String(str[i]);
//print("trying "+x);
char[] chk = x.toCharArray();
for(int j=0;j<m;++j){
for(int k=0;k<26;++k){
chk[j] = (char)('a'+k );
boolean use = true ;
for(int l= 0;l<n;++l){
int cost =0;
for(int jj =0;jj<m;++jj){
if(chk[jj]!= str[l][jj]) cost++;
}
if(cost>1){
use = false;
break ;
}
}
if(use){
pos =true ;
ans = new String(chk);
break outer ;
}
}
chk[j] = str[i][j];
}
}
if(pos){
pn(ans);
}
else{
pn(-1);
}
}
}
void print(Object o){
System.out.println(o);
System.out.flush();
}
long gcd(long a, long b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
void run() throws Exception{
is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
out = new PrintWriter(System.out);
long s = System.currentTimeMillis();
solve();
out.flush();
if(!INPUT.isEmpty())tr(System.currentTimeMillis()-s+"ms");
}
public static void main(String[] args) throws Exception { new Main().run(); }
//output methods
private void pn(Object o)
{
out.println(o);
}
private void p(Object o)
{
out.print(o);
}
//input methods
private byte[] inbuf = new byte[1024];
public int lenbuf = 0, ptrbuf = 0;
private int readByte()
{
if(lenbuf == -1)throw new InputMismatchException();
if(ptrbuf >= lenbuf){
ptrbuf = 0;
try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
if(lenbuf <= 0)return -1;
}
return inbuf[ptrbuf++];
}
private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
private double nd() { return Double.parseDouble(ns()); }
private char nc() { return (char)skip(); }
private String ns()
{
int b = skip();
StringBuilder sb = new StringBuilder();
while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
private char[] ns(int n)
{
char[] buf = new char[n];
int b = skip(), p = 0;
while(p < n && !(isSpaceChar(b))){
buf[p++] = (char)b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
private char[][] nm(int n, int m)
{
char[][] map = new char[n][];
for(int i = 0;i < n;i++)map[i] = ns(m);
return map;
}
private int[] na(int n)
{
int[] a = new int[n];
for(int i = 0;i < n;i++)a[i] = ni();
return a;
}
private int ni()
{
int num = 0, b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private long nl()
{
long num = 0;
int b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private void tr(Object... o) { if(INPUT.length() > 0)System.out.println(Arrays.deepToString(o)); }
void watch(Object ... a) throws Exception{
int i=1;
print("watch starts :");
for(Object o : a ) {
//print(o);
boolean notfound = true;
if(o.getClass().isArray()){
String type = o.getClass().getName().toString();
//print("type is "+type);
switch (type) {
case "[I":{
int[] test = (int[])o ;
print(i+" "+Arrays.toString(test));
break;
}
case "[[I":{
int[][] obj = (int[][])o;
print(i+" "+Arrays.deepToString(obj));
break;
}
case "[J" : {
long[] obj = (long[])o ;
print(i+" "+Arrays.toString(obj));
break;
}
case "[[J": {
long[][] obj = (long[][])o;
print(i+" "+Arrays.deepToString(obj));
break;
}
case "[D" :{
double[] obj= (double[])o;
print(i+" "+Arrays.toString(obj));
break;
}
case "[[D" :{
double[][] obj = (double[][])o;
print(i+" "+Arrays.deepToString(obj));
break;
}
case "[Ljava.lang.String": {
String[] obj = (String[])o ;
print(i+" "+Arrays.toString(obj));
break;
}
case "[[Ljava.lang.String": {
String[][] obj = (String[][])o ;
print(i+" "+Arrays.deepToString(obj));
break ;
}
case "[C" :{
char[] obj = (char[])o ;
print(i+" "+Arrays.toString(obj));
break;
}
case "[[C" :{
char[][] obj = (char[][])o;
print(i+" "+Arrays.deepToString(obj));
break;
}
default:{
print(i+" type not identified");
break;
}
}
notfound = false;
}
if(o.getClass() == ArrayList.class){
print(i+" al: "+o);
notfound = false;
}
if(o.getClass() == HashSet.class){
print(i+" hs: "+o);
notfound = false;
}
if(o.getClass() == TreeSet.class){
print(i+" ts: "+o);
notfound = false;
}
if(o.getClass() == TreeMap.class){
print(i+" tm: "+o);
notfound = false;
}
if(o.getClass() == HashMap.class){
print(i+" hm: "+o);
notfound = false;
}
if(o.getClass() == LinkedList.class){
print(i+" ll: "+o);
notfound = false;
}
if(o.getClass() == PriorityQueue.class){
print(i+" pq : "+o);
notfound = false;
}
if(o.getClass() == pair.class){
print(i+" pq : "+o);
notfound = false;
}
if(notfound){
print(i+" unknown: "+o);
}
i++;
}
print("watch ends ");
}
}
|
You are creating a level for a video game. The level consists of n rooms placed in a circle. The rooms are numbered 1 through n. Each room contains exactly one exit: completing the j-th room allows you to go the (j+1)-th room (and completing the n-th room allows you to go the 1-st room).
You are given the description of the multiset of n chests: the i-th chest has treasure value c_i.
Each chest can be of one of two types:
* regular chest — when a player enters a room with this chest, he grabs the treasure and proceeds to the next room;
* mimic chest — when a player enters a room with this chest, the chest eats him alive, and he loses.
The player starts in a random room with each room having an equal probability of being chosen. The players earnings is equal to the total value of treasure chests he'd collected before he lost.
You are allowed to choose the order the chests go into the rooms. For each k from 1 to n place the chests into the rooms in such a way that:
* each room contains exactly one chest;
* exactly k chests are mimics;
* the expected value of players earnings is minimum possible.
Please note that for each k the placement is chosen independently.
It can be shown that it is in the form of P/Q where P and Q are non-negative integers and Q ≠ 0. Report the values of P ⋅ Q^{-1} \pmod {998244353}.
Input
The first contains a single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of rooms and the number of chests.
The second line contains n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^6) — the treasure values of each chest.
Output
Print n integers — the k -th value should be equal to the minimum possible expected value of players earnings if the chests are placed into the rooms in some order and exactly k of the chests are mimics.
It can be shown that it is in the form of P/Q where P and Q are non-negative integers and Q ≠ 0. Report the values of P ⋅ Q^{-1} \pmod {998244353}.
Examples
Input
2
1 2
Output
499122177 0
Input
8
10 4 3 6 5 10 7 5
Output
499122193 249561095 249561092 873463811 499122178 124780545 623902721 0
Note
In the first example the exact values of minimum expected values are: \frac 1 2, \frac 0 2.
In the second example the exact values of minimum expected values are: \frac{132} 8, \frac{54} 8, \frac{30} 8, \frac{17} 8, \frac{12} 8, \frac 7 8, \frac 3 8, \frac 0 8.
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 998244353, N = 300005;
long long n, a[N];
long long ksm(long long x, long long y) {
long long ans = 1;
for (; y; y /= 2, x = x * x % M)
if (y & 1) (ans *= x) %= M;
return ans;
}
signed main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
sort(a + 1, a + n + 1);
for (long long i = 1; i <= n; i++) a[i] = (a[i] + a[i - 1]) % M;
for (long long i = 1; i <= n; i++) {
long long l = n - 2 * i + 1, r = n - i, d = 1, s = 0;
for (; r > 0; l -= i, r -= i, d++)
l = max(l, 1ll), (s += d * (a[r] - a[l - 1] + M)) %= M;
printf("%lld ", s * ksm(n, M - 2) % M);
}
}
|
Polycarp plays a (yet another!) strategic computer game. In this game, he leads an army of mercenaries.
Polycarp wants to gather his army for a quest. There are n mercenaries for hire, and the army should consist of some subset of them.
The i-th mercenary can be chosen if the resulting number of chosen mercenaries is not less than l_i (otherwise he deems the quest to be doomed) and not greater than r_i (he doesn't want to share the trophies with too many other mercenaries). Furthermore, m pairs of mercenaries hate each other and cannot be chosen for the same quest.
How many non-empty subsets does Polycarp need to consider? In other words, calculate the number of non-empty subsets of mercenaries such that the size of this subset belongs to [l_i, r_i] for each chosen mercenary, and there are no two mercenaries in the subset that hate each other.
The answer may be large, so calculate it modulo 998244353.
Input
The first line contains two integers n and m (1 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ m ≤ min(20, (n(n-1))/(2))) — the number of mercenaries and the number of pairs of mercenaries that hate each other.
Then n lines follow, the i-th of them contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n).
Then m lines follow, the i-th of them contains two integers a_i and b_i (1 ≤ a_i < b_i ≤ n) denoting that the mercenaries a_i and b_i hate each other. There are no two equal pairs in this list.
Output
Print one integer — the number of non-empty subsets meeting the constraints, taken modulo 998244353.
Examples
Input
3 0
1 1
2 3
1 3
Output
3
Input
3 1
1 1
2 3
1 3
2 3
Output
2
|
#include <bits/stdc++.h>
using namespace std;
const int Inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const int jt = 998244353;
int n, m;
int jc[1 << 19], fjc[1 << 19];
int l[1 << 19], r[1 << 19];
int a[44], b[44];
int xf[1 << 19], cs[1 << 19][44];
int lgl[1 << 19];
int ksmii(int a, int b) {
if (!b) return 1;
int x = ksmii(a, b >> 1);
x = 1ll * x * x % jt;
if (b & 1) x = 1ll * x * a % jt;
return x;
}
int inline C(int a, int b) {
if (b < 0 || a < b) return 0;
return 1ll * jc[a] * fjc[b] % jt * fjc[a - b] % jt;
}
int main() {
jc[0] = 1;
for (int i = 1; i <= (500000); i++) jc[i] = 1ll * jc[i - 1] * i % jt;
fjc[500000] = ksmii(jc[500000], jt - 2);
for (int i = (500000); ((-1) > 0 ? i <= (1) : i >= (1)); i += (-1))
fjc[i - 1] = 1ll * fjc[i] * i % jt;
scanf("%d%d", &n, &m);
for (int i = 1; i <= (n); i++) {
scanf("%d%d", l + i, r + i);
xf[l[i]]++;
xf[r[i] + 1]--;
}
for (int i = 1; i <= (n); i++) {
xf[i] += xf[i - 1];
for (int j = 0; j < (m << 1 | 1); j++) {
cs[i][j] = (cs[i - 1][j] + C(xf[i] - j, i - j)) % jt;
}
}
for (int i = 0; i < (m); i++) scanf("%d%d", a + i, b + i);
int ans = 0;
for (int i = 0; i < (1 << m); i++) {
int ls = 1, rs = n, ts = 0;
for (int j = 0; j < (m); j++) {
if (!((i >> j) & 1)) continue;
if (lgl[a[j]] != i) {
lgl[a[j]] = i;
ts++;
}
if (lgl[b[j]] != i) {
lgl[b[j]] = i;
ts++;
}
ls = max(ls, max(l[a[j]], l[b[j]]));
rs = min(rs, min(r[a[j]], r[b[j]]));
}
if (ls > rs) continue;
int res = (cs[rs][ts] - cs[ls - 1][ts] + jt) % jt;
if (__builtin_popcount(i) % 2)
ans = (ans - res + jt) % jt;
else
ans = (ans + res) % jt;
}
printf("%d\n", ans);
return 0;
}
|
During one of the space missions, humans have found an evidence of previous life at one of the planets. They were lucky enough to find a book with birth and death years of each individual that had been living at this planet. What's interesting is that these years are in the range (1, 10^9)! Therefore, the planet was named Longlifer.
In order to learn more about Longlifer's previous population, scientists need to determine the year with maximum number of individuals that were alive, as well as the number of alive individuals in that year. Your task is to help scientists solve this problem!
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) — the number of people.
Each of the following n lines contain two integers b and d (1 ≤ b < d ≤ 10^9) representing birth and death year (respectively) of each individual.
Output
Print two integer numbers separated by blank character, y — the year with a maximum number of people alive and k — the number of people alive in year y.
In the case of multiple possible solutions, print the solution with minimum year.
Examples
Input
3
1 5
2 4
5 6
Output
2 2
Input
4
3 4
4 5
4 6
8 10
Output
4 2
Note
You can assume that an individual living from b to d has been born at the beginning of b and died at the beginning of d, and therefore living for d - b years.
|
#include <bits/stdc++.h>
using namespace std;
const int Mn = 1e5 + 5;
struct A {
long long a;
bool x;
} p[Mn << 1];
int cnt = 0;
bool cmp(A a, A b) {
if (a.a != b.a) return a.a < b.a;
return a.x < b.x;
}
int main() {
int n;
scanf("%d", &n);
long long x, y;
for (int i = 1; i <= n; i++) {
scanf("%lld%lld", &x, &y);
p[++cnt].a = x;
p[cnt].x = 1;
p[++cnt].a = y;
p[cnt].x = 0;
}
long long ans = 0;
long long mx = -1;
sort(p + 1, p + 1 + cnt, cmp);
long long t = 0;
for (int i = 1; i <= cnt; i++) {
if (p[i].x)
t++;
else
t--;
if (t > mx) {
ans = p[i].a;
mx = t;
}
}
printf("%lld %lld\n", ans, mx);
return 0;
}
|
Oleg's favorite subjects are History and Math, and his favorite branch of mathematics is division.
To improve his division skills, Oleg came up with t pairs of integers p_i and q_i and for each pair decided to find the greatest integer x_i, such that:
* p_i is divisible by x_i;
* x_i is not divisible by q_i.
Oleg is really good at division and managed to find all the answers quickly, how about you?
Input
The first line contains an integer t (1 ≤ t ≤ 50) — the number of pairs.
Each of the following t lines contains two integers p_i and q_i (1 ≤ p_i ≤ 10^{18}; 2 ≤ q_i ≤ 10^{9}) — the i-th pair of integers.
Output
Print t integers: the i-th integer is the largest x_i such that p_i is divisible by x_i, but x_i is not divisible by q_i.
One can show that there is always at least one value of x_i satisfying the divisibility conditions for the given constraints.
Example
Input
3
10 4
12 6
179 822
Output
10
4
179
Note
For the first pair, where p_1 = 10 and q_1 = 4, the answer is x_1 = 10, since it is the greatest divisor of 10 and 10 is not divisible by 4.
For the second pair, where p_2 = 12 and q_2 = 6, note that
* 12 is not a valid x_2, since 12 is divisible by q_2 = 6;
* 6 is not valid x_2 as well: 6 is also divisible by q_2 = 6.
The next available divisor of p_2 = 12 is 4, which is the answer, since 4 is not divisible by 6.
|
"""
#If FastIO not needed, used this and don't forget to strip
#import sys, math
#input = sys.stdin.readline
"""
import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
from collections import defaultdict as dd, deque as dq
import math, string
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
MOD = 10**9+7
"""
Start with P
P has factors pi**qi
X = P, is X % Q == 0, doesn't work
Need the largest factor of P s.t. factor % Q = 0
30
10
1 2 3 5 6 10 15 30 so 15 is the answer
If P//Q is the smallest factor of P, the answer is the next smallest factor
Otherwise, the answer is either the next factor, or a smaller factor which doesn't divide P//Q
We need to remove a combination of factors from P until it doesn't divide Q any more
50 = 2*2*5
100 = 2*2*5*5
10 = 2*5
30 = 2*3*5
Answer = 5*5
"""
from functools import reduce
def factors(n):
return set(reduce(list.__add__,
([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))
def solve():
P, Q = getInts()
if P < Q:
return P
if P % Q > 0:
return P
facs = sorted(list(factors(Q)))
best = 0
for fac in facs:
if fac == 1:
continue
power = 1
while P % fac**power == 0:
#print(P,fac,power,flush=True)
tmp = P//(fac**power)
if tmp % Q > 0:
best = max(best,tmp)
power += 1
return best
for _ in range(getInt()):
print(solve())
|
Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya has two strings a and b of the same length n. The strings consist only of lucky digits. Petya can perform operations of two types:
* replace any one digit from string a by its opposite (i.e., replace 4 by 7 and 7 by 4);
* swap any pair of digits in string a.
Petya is interested in the minimum number of operations that are needed to make string a equal to string b. Help him with the task.
Input
The first and the second line contains strings a and b, correspondingly. Strings a and b have equal lengths and contain only lucky digits. The strings are not empty, their length does not exceed 105.
Output
Print on the single line the single number — the minimum number of operations needed to convert string a into string b.
Examples
Input
47
74
Output
1
Input
774
744
Output
1
Input
777
444
Output
3
Note
In the first sample it is enough simply to swap the first and the second digit.
In the second sample we should replace the second digit with its opposite.
In the third number we should replace all three digits with their opposites.
|
import java.util.Scanner;
public class C_104C {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String a = sc.next();
String b = sc.next();
int count=0;
int sa4=0,sa7=0,sb7=0, sb4=0;
for (int i = 0; i < a.length(); i++) {
if(a.charAt(i)==b.charAt(i)){
count++;
}else{
if(a.charAt(i)=='4'){
sa4++;
sb7++;
}else{
sa7++;
sb4++;
}
}
}
System.out.println(a.length() - count - (int) Math.min(sa4,sb4));
}
}
|
Qingshan and Daniel are going to play a card game. But it will be so boring if only two persons play this. So they will make n robots in total to play this game automatically. Robots made by Qingshan belong to the team 1, and robots made by Daniel belong to the team 2. Robot i belongs to team t_i. Before the game starts, a_i cards are given for robot i.
The rules for this card game are simple:
* Before the start, the robots are arranged in a circle in the order or their indices. The robots will discard cards in some order, in each step one robot discards a single card. When the game starts, robot 1 will discard one of its cards. After that, robots will follow the following rules:
* If robot i discards the card last, the nearest robot whose team is opposite from i's will discard the card next. In another word j will discard a card right after i, if and only if among all j that satisfy t_i≠ t_j, dist(i,j) (definition is below) is minimum.
* The robot who has no cards should quit the game immediately. This robot won't be considered in the next steps.
* When no robot can discard the card next, the game ends.
We define the distance from robot x to robot y as dist(x,y)=(y-x+n)mod n. It is similar to the oriented distance on the circle.
For example, when n=5, the distance from 1 to 3 is dist(1,3)=(3-1+5)mod 5=2, the distance from 3 to 1 is dist(3,1)=(1-3+5)mod 5 =3.
Later, Qingshan finds out that it will take so much time to see how robots play. She wants to know the result as quickly as possible. You, as Qingshan's fan, are asked to calculate an array [ans_1,ans_2,…,ans_n] — ans_i is equal to the number of cards, that i-th robot will discard during the game. You need to hurry!
To avoid the large size of the input, the team and the number of cards of each robot will be generated in your code with some auxiliary arrays.
Input
The first line contains one integer n (1 ≤ n ≤ 5⋅ 10^6) — the number of robots playing this game.
The second line contains one integer m (1 ≤ m ≤ min(n,200 000)).
Each of the next m line contains four integers p_i, k_i, b_i, w_i (1 ≤ p_i ≤ n, 1 ≤ k_i ≤ 10^9+7, 0 ≤ b_i ,w_i< k_i). It's guaranteed that p_m=n and p_{j-1}<p_{j} (2 ≤ j ≤ m).
Arrays a_j and t_j should be generated by the following pseudo code:
seed = 0
base = 0
function rnd():
ret = seed
seed = (seed * base + 233) mod 1000000007
return ret
p[0] = 0
for i = 1 to m:
seed = b[i]
base = w[i]
for j = p[i - 1] + 1 to p[i]:
t[j] = (rnd() mod 2) + 1
a[j] = (rnd() mod k[i]) + 1
Output
Print a single integer \left( ∏_{i=1}^{n} ((ans_i ⊕ i^2)+1)\right) mod 10^9+7, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
Examples
Input
3
3
1 5 2 3
2 7 1 2
3 2 1 1
Output
100
Input
5000000
2
1919810 998244353 114514 19260817
5000000 233333333 623532 7175
Output
800210675
Input
1
1
1 1 0 0
Output
1
Note
In the first test case a=[5,5,1] and t=[1,2,2].
The robot 1 discards the card first.
Then robot 2 discards the card next. Robot 3 doesn't discard the card next because dist(1,2)<dist(1,3).
Then robot 1 discards the card next. Robot 3 doesn't discard the card next because t_2=t_3.
If we write down the index of the robot who discards a card in time order, it will be the sequence [1,2,1,2,1,2,1,2]. So robots 1, 2 and 3 discard 5, 5 and 0 cards, respectively. And the answer is (((5 ⊕ 1^2)+1)×((5 ⊕ 2^2)+1)×((0 ⊕ 3^2)+1)) mod 10^9+7=(5× 2 × 10)mod 10^9+7=100.
|
#include <bits/stdc++.h>
using namespace std;typedef long long ll;const int N=5000005;const int M=1000000007;int seed, base, t[N], a[N], b[N];ll s[2];
int rnd() {int ret = seed; seed = (1ll * seed * base + 233) % 1000000007;return ret;}
int main() {int n, m; scanf("%d%d", &n, &m);for (int i=1, p0=1, p, k; i<=m; i++) {scanf("%d%d%d%d", &p, &k, &seed, &base);for (;p0<=p; p0++) {t[p0]=rnd()%2;a[p0]=rnd()%k+1;}}
for (int i=1; i<=n; i++) s[t[i]]+=a[i];int st = -1;
if (s[t[1]]>s[t[1]^1]) {a[1]--;b[1]++;for (int i=1; i<=n; i++) if (t[i]!=t[1]) { st=i; break; }} else st=1;
if (st>-1) {long long cnt=0;for (int i=st,j=1; s[t[st]]; j++, i=i%n+1) {
if (t[i]==t[st]) { cnt+=a[i]; b[i]+=a[i]; a[i]=0; } else {int z=min((ll)a[i], cnt);a[i]-=z;b[i]+=z;s[t[st]]-=z;cnt-=z;} }}
ll A=1; for (int i=1; i<=n; i++) A=((b[i]^(1ll*i*i))+1)%M*1ll*A%M; printf("%lld\n", A);return 0;}
|
There is a n × m grid. You are standing at cell (1, 1) and your goal is to finish at cell (n, m).
You can move to the neighboring cells to the right or down. In other words, suppose you are standing at cell (x, y). You can:
* move right to the cell (x, y + 1) — it costs x burles;
* move down to the cell (x + 1, y) — it costs y burles.
Can you reach cell (n, m) spending exactly k burles?
Input
The first line contains the single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first and only line of each test case contains three integers n, m, and k (1 ≤ n, m ≤ 100; 0 ≤ k ≤ 10^4) — the sizes of grid and the exact amount of money you need to spend.
Output
For each test case, if you can reach cell (n, m) spending exactly k burles, print YES. Otherwise, print NO.
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as positive answer).
Example
Input
6
1 1 0
2 2 2
2 2 3
2 2 4
1 4 3
100 100 10000
Output
YES
NO
YES
NO
YES
NO
Note
In the first test case, you are already in the final cell, so you spend 0 burles.
In the second, third and fourth test cases, there are two paths from (1, 1) to (2, 2): (1, 1) → (1, 2) → (2, 2) or (1, 1) → (2, 1) → (2, 2). Both costs 1 + 2 = 3 burles, so it's the only amount of money you can spend.
In the fifth test case, there is the only way from (1, 1) to (1, 4) and it costs 1 + 1 + 1 = 3 burles.
|
import java.util.*;
public class TheCakeIsALie_B {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-->0) {
int n = sc.nextInt();
int m = sc.nextInt();
int k = sc.nextInt();
int cost = (m-1) + (m*(n-1));
if(cost==k) {
System.out.println("YES");
}
else {
System.out.println("NO");
}
}
}
}
|
AquaMoon had n strings of length m each. n is an odd number.
When AquaMoon was gone, Cirno tried to pair these n strings together. After making (n-1)/(2) pairs, she found out that there was exactly one string without the pair!
In her rage, she disrupted each pair of strings. For each pair, she selected some positions (at least 1 and at most m) and swapped the letters in the two strings of this pair at the selected positions.
For example, if m = 6 and two strings "abcdef" and "xyzklm" are in one pair and Cirno selected positions 2, 3 and 6 she will swap 'b' with 'y', 'c' with 'z' and 'f' with 'm'. The resulting strings will be "ayzdem" and "xbcklf".
Cirno then stole away the string without pair and shuffled all remaining strings in arbitrary order.
AquaMoon found the remaining n-1 strings in complete disarray. Also, she remembers the initial n strings. She wants to know which string was stolen, but she is not good at programming. Can you help her?
Input
This problem is made as interactive. It means, that your solution will read the input, given by the interactor. But the interactor will give you the full input at the beginning and after that, you should print the answer. So you should solve the problem, like as you solve the usual, non-interactive problem because you won't have any interaction process. The only thing you should not forget is to flush the output buffer, after printing the answer. Otherwise, you can get an "Idleness limit exceeded" verdict. Refer to the [interactive problems guide](https://codeforces.com/blog/entry/45307) for the detailed information about flushing the output buffer.
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains two integers n, m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5) — the number of strings and the length of each string, respectively.
The next n lines each contain a string with length m, describing the original n strings. All string consists of lowercase Latin letters.
The next n-1 lines each contain a string with length m, describing the strings after Cirno exchanged and reordered them.
It is guaranteed that n is odd and that the sum of n ⋅ m over all test cases does not exceed 10^5.
Hack format:
The first line should contain a single integer t. After that t test cases should follow in the following format:
The first line should contain two integers n and m.
The following n lines should contain n strings of length m, describing the original strings.
The following (n-1)/(2) lines should describe the pairs. They should contain, in the following order: the index of the first string i (1 ≤ i ≤ n), the index of the second string j (1 ≤ j ≤ n, i ≠ j), the number of exchanged positions k (1 ≤ k ≤ m), and the list of k positions that are exchanged (k distinct indices from 1 to m in any order).
The final line should contain a permutation of integers from 1 to n, describing the way the strings should be reordered. The strings will be placed in the order indices placed in this permutation, the stolen string index will be ignored.
Output
For each test case print a single line with the stolen string.
Example
Input
3
3 5
aaaaa
bbbbb
ccccc
aaaaa
bbbbb
3 4
aaaa
bbbb
cccc
aabb
bbaa
5 6
abcdef
uuuuuu
kekeke
ekekek
xyzklm
xbcklf
eueueu
ayzdem
ukukuk
Output
ccccc
cccc
kekeke
Note
In the first test case, "aaaaa" and "bbbbb" exchanged all positions, and "ccccc" is the stolen string.
In the second test case, "aaaa" and "bbbb" exchanged two first positions, and "cccc" is the stolen string.
This is the first test in the hack format:
3
3 5
aaaaa
bbbbb
ccccc
1 2 5 1 2 3 4 5
2 1 3
3 4
aaaa
bbbb
cccc
1 2 2 1 2
2 1 3
5 6
abcdef
uuuuuu
kekeke
ekekek
xyzklm
1 5 3 2 3 6
2 4 3 2 4 6
5 4 1 2 3
|
#include <iostream>
#include <algorithm>
#include <cmath>
#include <queue>
#include <vector>
#include <stack>
#include <list>
#include <cstring>
#include <map>
#include <cstdio>
#include <set>
#include <utility>
using namespace std;
#define ll long long
#define mem(f, z) memset(f, z, sizeof(f))
#define foi(i, x, y) for (int i = (x), _en = (y); i <= _en; i++)
#define fod(i, x, y) for (int i = (x), _en = (y); i >= _en; i--)
#define INF 0x3f3f3f3f
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int cnt[100050][30];
int main()
{
int t = read();
while(t--)
{
mem(cnt, 0);
int n = read(), m = read();
char s1[n + 5][m + 5];
char s[m + 5];
for(int i = 0; i < n; i++)
{
scanf("%s", s1[i]);
for(int j = 0; j < m; j++)
{
cnt[j][s1[i][j] - 'a']++;
}
}
for(int i = 0; i < n - 1; i++)
{
scanf("%s", s);
for(int j = 0; j < m; j++)
{
cnt[j][s[j] - 'a']--;
}
}
for(int i = 0; i < m; i++)
{
for(int j = 0; j < 30; j++)
{
if(cnt[i][j])
{
s[i] = 'a' + j;
break;
}
}
}
s[m] = '\0';
printf("%s\n", s);
}
return 0;
}
|
Let's consider a k × k square, divided into unit squares. Please note that k ≥ 3 and is odd. We'll paint squares starting from the upper left square in the following order: first we move to the right, then down, then to the left, then up, then to the right again and so on. We finish moving in some direction in one of two cases: either we've reached the square's border or the square following after the next square is already painted. We finish painting at the moment when we cannot move in any direction and paint a square. The figure that consists of the painted squares is a spiral.
<image> The figure shows examples of spirals for k = 3, 5, 7, 9.
You have an n × m table, each of its cells contains a number. Let's consider all possible spirals, formed by the table cells. It means that we consider all spirals of any size that don't go beyond the borders of the table. Let's find the sum of the numbers of the cells that form the spiral. You have to find the maximum of those values among all spirals.
Input
The first line contains two integers n and m (3 ≤ n, m ≤ 500) — the sizes of the table.
Each of the next n lines contains m space-separated integers: the j-th number in the i-th line aij ( - 1000 ≤ aij ≤ 1000) is the number recorded in the j-th cell of the i-th row of the table.
Output
Print a single number — the maximum sum of numbers among all spirals.
Examples
Input
6 5
0 0 0 0 0
1 1 1 1 1
0 0 0 0 1
1 1 1 0 1
1 0 0 0 1
1 1 1 1 1
Output
17
Input
3 3
1 1 1
1 0 0
1 1 1
Output
6
Input
6 6
-3 2 0 1 5 -1
4 -1 2 -3 0 1
-5 1 2 4 1 -2
0 -2 1 3 -1 2
3 1 4 -3 -2 0
-1 2 -1 3 1 2
Output
13
Note
In the first sample the spiral with maximum sum will cover all 1's of the table.
In the second sample the spiral may cover only six 1's.
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1e18;
int n, m;
long long A[505][505];
long long cnt[505][505];
long long dp[2][505][505];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> A[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
long long a = 0;
if (i > 0) a = cnt[i - 1][j];
long long b = 0;
if (j > 0) b = cnt[i][j - 1];
long long c = 0;
if (i > 0 && j > 0) c = cnt[i - 1][j - 1];
cnt[i][j] = a + b - c + A[i][j];
}
long long ans = -INF;
int d = 0;
for (int i = 0; i + 2 < n; i++)
for (int j = 0; j + 2 < m; j++) {
dp[d][i][j] = A[i][j] + A[i][j + 1] + A[i][j + 2] + A[i + 1][j + 2] +
A[i + 2][j] + A[i + 2][j + 1] + A[i + 2][j + 2];
if (dp[d][i][j] > ans) ans = dp[d][i][j];
}
for (int l = 4; l < n && l < m; l += 2) {
for (int i = 0; i + l < n; i++)
for (int j = 0; j + l < m; j++) {
long long a = 0;
if (i > 0) a = cnt[i - 1][j + l];
long long b = 0;
if (j > 0) b = cnt[i + l][j - 1];
long long c = 0;
if (i > 0 && j > 0) c = cnt[i - 1][j - 1];
dp[d ^ 1][i][j] =
cnt[i + l][j + l] - a - b + c - dp[d][i + 1][j + 1] - A[i + 1][j];
if (dp[d ^ 1][i][j] > ans) ans = dp[d ^ 1][i][j];
}
d ^= 1;
}
cout << ans << endl;
return 0;
}
|
Nick has some permutation consisting of p integers from 1 to n. A segment [l, r] (l ≤ r) is a set of elements pi satisfying l ≤ i ≤ r.
Nick calls a pair of segments [a0, a1] and [b0, b1] (1 ≤ a0 ≤ a1 < b0 ≤ b1 ≤ n) good if all their (a1 - a0 + b1 - b0 + 2) elements, when sorted in ascending order, form an arithmetic progression with a difference of 1. That is, when they sorted in ascending order, the elements are in the form {x, x + 1, x + 2, ..., x + m - 1}, for some x and m.
Your task is to find the number of distinct pairs of good segments in the given permutation. Two pairs of segments are considered distinct if the sets of elements contained in these pairs of segments are distinct. For example, any segment [l, r] (l < r) can be represented as a pair of segments, as [l, i] and [i + 1, r] (l ≤ i ≤ r). As all these pairs consist of the same set of elements, they are considered identical.
See the notes accompanying the sample tests for clarification.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the permutation size. The second line contains n space-separated distinct integers pi, (1 ≤ pi ≤ n).
Output
Print a single integer — the number of good pairs of segments of permutation p.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 3
Output
3
Input
5
1 4 5 3 2
Output
10
Input
5
5 4 3 1 2
Output
10
Note
In the first sample the following pairs of segments are good: ([1, 1], [2, 2]); ([2, 2], [3, 3]); ([1, 2], [3, 3]). Pair of segments ([1, 1], [2, 3]) is by definition equivalent to pair ([1, 2], [3, 3]), since both of them covers the same set of elements, namely {1, 2, 3}.
In the third sample the following pairs of segments are good: ([4, 4], [5, 5]); ([3, 3],[4, 5]); ([2, 2],[3, 5]); ([1, 1],[2, 5]); ([3, 3],[5, 5]); ([2, 3],[5, 5]); ([1, 3],[5, 5]); ([2, 2],[3, 3]); ([1, 1],[2, 3]); ([1, 1],[2, 2]).
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const int maxn = 300005;
const int mn = maxn << 2;
int getint() {
int r = 0, k = 1;
char c = getchar();
for (; '0' > c || c > '9'; c = getchar())
if (c == '-') k = -1;
for (; '0' <= c && c <= '9'; c = getchar()) r = r * 10 - '0' + c;
return r * k;
}
int P[maxn], n, pos[maxn];
long long m1[mn], m2[mn], c1[mn], c2[mn], lazy[mn], ans = 0;
void add(int x, int v) {
m1[x] += v;
m2[x] += v;
lazy[x] += v;
}
void pd(int now) {
if (lazy[now]) {
add(now << 1, lazy[now]);
add(now << 1 | 1, lazy[now]);
lazy[now] = 0;
}
}
void pu(int x) {
int L = x << 1, R = x << 1 | 1;
if (m1[L] > m1[R]) swap(L, R);
if (m1[L] < m1[R]) {
m1[x] = m1[L];
c1[x] = c1[L];
if (m2[L] < m1[R]) {
m2[x] = m2[L];
c2[x] = c2[L];
} else if (m2[L] == m1[R]) {
m2[x] = m2[L];
c2[x] = c2[L] + c1[R];
} else {
m2[x] = m1[R];
c2[x] = c1[R];
}
}
if (m1[L] == m1[R]) {
m1[x] = m1[L];
c1[x] = c1[L] + c1[R];
if (m2[L] < m2[R]) {
m2[x] = m2[L];
c2[x] = c2[L];
} else if (m2[R] < m2[L]) {
m2[x] = m2[R];
c2[x] = c2[R];
} else {
m2[x] = m2[R];
c2[x] = c2[L] + c2[R];
}
}
}
void change(int now, int l, int r, int ll, int rr, int v) {
if (ll <= l && r <= rr) {
add(now, v);
return;
}
pd(now);
int mid = (l + r) >> 1;
if (ll <= mid) change(now << 1, l, mid, ll, rr, v);
if (rr > mid) change(now << 1 | 1, mid + 1, r, ll, rr, v);
pu(now);
}
void query(int x, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) {
if (m1[x] == 1 || m1[x] == 2) ans += c1[x];
if (m2[x] == 1 || m2[x] == 2) ans += c2[x];
return;
}
pd(x);
int mid = (l + r) >> 1;
if (ll <= mid) query(x << 1, l, mid, ll, rr);
if (rr > mid) query(x << 1 | 1, mid + 1, r, ll, rr);
}
void build(int x, int l, int r) {
if (l == r) {
c1[x] = 1;
m2[x] = 1;
return;
}
int mid = (l + r) >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
pu(x);
}
int main() {
n = getint();
for (int i = 1; i <= n; ++i) {
P[i] = getint();
pos[P[i]] = i;
}
build(1, 1, n);
for (int l = n; l; --l) {
int x = pos[l];
if (l > P[x - 1] && l > P[x + 1]) change(1, 1, n, l, n, 1);
if (l > P[x - 1] && l < P[x + 1]) change(1, 1, n, l, P[x + 1] - 1, 1);
if (l < P[x - 1] && l > P[x + 1]) change(1, 1, n, l, P[x - 1] - 1, 1);
if (l < P[x - 1] && l < P[x + 1]) {
int L = P[x - 1], R = P[x + 1];
if (L > R) swap(L, R);
change(1, 1, n, l, L - 1, 1);
change(1, 1, n, R, n, -1);
}
query(1, 1, n, l, n);
}
ans = ans - n;
printf("%I64d", ans);
}
|
Byteland is trying to send a space mission onto the Bit-X planet. Their task is complicated by the fact that the orbit of the planet is regularly patrolled by Captain Bitonix, the leader of the space forces of Bit-X.
There are n stations around Bit-X numbered clockwise from 1 to n. The stations are evenly placed on a circular orbit, so the stations number i and i + 1 (1 ≤ i < n), and the stations number 1 and n, are neighboring. The distance between every pair of adjacent stations is equal to m space miles. To go on a patrol, Captain Bitonix jumps in his rocket at one of the stations and flies in a circle, covering a distance of at least one space mile, before finishing in some (perhaps the starting) station.
Bitonix' rocket moves by burning fuel tanks. After Bitonix attaches an x-liter fuel tank and chooses the direction (clockwise or counter-clockwise), the rocket flies exactly x space miles along a circular orbit in the chosen direction. Note that the rocket has no brakes; it is not possible for the rocket to stop before depleting a fuel tank.
For example, assume that n = 3 and m = 60 and Bitonix has fuel tanks with volumes of 10, 60, 90 and 100 liters. If Bitonix starts from station 1, uses the 100-liter fuel tank to go clockwise, then uses the 90-liter fuel tank to go clockwise, and then uses the 10-liter fuel tank to go counterclockwise, he will finish back at station 1. This constitutes a valid patrol. Note that Bitonix does not have to use all available fuel tanks. Another valid option for Bitonix in this example would be to simply use the 60-liter fuel tank to fly to either station 2 or 3.
However, if n was equal to 3, m was equal to 60 and the only fuel tanks available to Bitonix were one 10-liter tank and one 100-liter tank, he would have no way of completing a valid patrol (he wouldn't be able to finish any patrol exactly at the station).
The Byteland space agency wants to destroy some of Captain Bitonix' fuel tanks so that he cannot to complete any valid patrol. Find how many different subsets of the tanks the agency can destroy to prevent Captain Bitonix from completing a patrol and output the answer modulo 1000000007 (109 + 7).
Input
The first line of the input contains three integers n (2 ≤ n ≤ 1000) — the number of stations, m (1 ≤ m ≤ 120) — the distance between adjacent stations, and t (1 ≤ t ≤ 10000) — the number of fuel tanks owned by Captain Bitonix.
The second line of the input contains t space-separated integers between 1 and 109, inclusive — the volumes of Bitonix' fuel tanks.
Output
Output a single number — the number of distinct subsets of tanks that the Bytelandian space agency can destroy in order to prevent Captain Bitonix from completing a patrol, modulo 109 + 7.
Examples
Input
7 6 5
5 4 12 6 5
Output
6
Input
3 60 2
10 100
Output
4
Note
All the fuel tanks are distinct, even if some of them have the same capacity.
|
#include <bits/stdc++.h>
using namespace std;
void Get(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
int N, M;
int Cnt[125];
void Init() {
Get(N);
Get(M);
Get(N);
for (int i = 1, T; i <= N; i++) {
Get(T);
Cnt[std::min(T % M, M - T % M)]++;
}
}
long long Ans;
void DFS(int X, bitset<125> Hash, int Last, long long Ans0) {
(Ans += Ans0) %= (1000000007);
if ((1 << X) > M) return;
for (int i = Last + 1; i <= M; i++) {
if (Cnt[i] == 0) continue;
if ((Hash[M - i]) == 0 && (Hash[i]) == 0)
DFS(X + 1,
Hash | (Hash << i) | (Hash >> (M - i)) | (Hash >> i) |
(Hash << (M - i)),
i, (Ans0 * Cnt[i]) % (1000000007));
}
}
void Work() { DFS(1, 1, 0, 1); }
void Output() { printf("%I64d\n", Ans); }
int main() {
Init();
Work();
Output();
return 0;
}
|
Mirror Box is a name of a popular game in the Iranian National Amusement Park (INAP). There is a wooden box, 105 cm long and 100 cm high in this game. Some parts of the box's ceiling and floor are covered by mirrors. There are two negligibly small holes in the opposite sides of the box at heights hl and hr centimeters above the floor. The picture below shows what the box looks like.
<image>
In the game, you will be given a laser gun to shoot once. The laser beam must enter from one hole and exit from the other one. Each mirror has a preset number vi, which shows the number of points players gain if their laser beam hits that mirror. Also — to make things even funnier — the beam must not hit any mirror more than once.
Given the information about the box, your task is to find the maximum score a player may gain. Please note that the reflection obeys the law "the angle of incidence equals the angle of reflection".
Input
The first line of the input contains three space-separated integers hl, hr, n (0 < hl, hr < 100, 0 ≤ n ≤ 100) — the heights of the holes and the number of the mirrors.
Next n lines contain the descriptions of the mirrors. The i-th line contains space-separated vi, ci, ai, bi; the integer vi (1 ≤ vi ≤ 1000) is the score for the i-th mirror; the character ci denotes i-th mirror's position — the mirror is on the ceiling if ci equals "T" and on the floor if ci equals "F"; integers ai and bi (0 ≤ ai < bi ≤ 105) represent the x-coordinates of the beginning and the end of the mirror.
No two mirrors will share a common point. Consider that the x coordinate increases in the direction from left to right, so the border with the hole at height hl has the x coordinate equal to 0 and the border with the hole at height hr has the x coordinate equal to 105.
Output
The only line of output should contain a single integer — the maximum possible score a player could gain.
Examples
Input
50 50 7
10 F 1 80000
20 T 1 80000
30 T 81000 82000
40 T 83000 84000
50 T 85000 86000
60 T 87000 88000
70 F 81000 89000
Output
100
Input
80 72 9
15 T 8210 15679
10 F 11940 22399
50 T 30600 44789
50 F 32090 36579
5 F 45520 48519
120 F 49250 55229
8 F 59700 80609
35 T 61940 64939
2 T 92540 97769
Output
120
Note
The second sample is depicted above. The red beam gets 10 + 50 + 5 + 35 + 8 + 2 = 110 points and the blue one gets 120.
The red beam on the picture given in the statement shows how the laser beam can go approximately, this is just illustration how the laser beam can gain score. So for the second sample there is no such beam that gain score 110.
|
#include <bits/stdc++.h>
int t[100005], f[100005], v[105];
int hl, hr, n;
bool used[105];
double first, last, unit, upd;
int trytry(int init) {
int x, up = init, pt = 0;
double loc = first;
memset(used, false, sizeof used);
while (loc < 100000) {
x = loc;
if (up) {
if (t[x] && !used[t[x]]) {
used[t[x]] = true;
pt += v[t[x]];
} else
return 0;
} else {
if (f[x] && !used[f[x]]) {
used[f[x]] = true;
pt += v[f[x]];
} else
return 0;
}
up ^= 1;
loc += unit;
}
return pt;
}
int main(int argc, char** argv) {
int a, b, ac, pt;
char c;
memset(t, 0, sizeof t);
memset(f, 0, sizeof f);
scanf("%d%d%d", &hl, &hr, &n);
for (int i = 1; i <= n; i++) {
scanf("%d%*c%c%d%d", &v[i], &c, &a, &b);
if (c == 'T')
for (int j = a; j <= b; j++) t[j] = i;
else
for (int j = a; j <= b; j++) f[j] = i;
}
ac = 0;
for (int i = 1; i <= 105; i += 2) {
upd = i * 100 + hl + 100 - hr;
first = hl / upd * 100000;
unit = 100.0 / upd * 100000;
last = 100000.0 - (100.0 - hr) / upd * 100000;
pt = trytry(0);
if (ac < pt) ac = pt;
}
for (int i = 0; i <= 105; i += 2) {
upd = i * 100 + hl + hr;
first = hl / upd * 100000;
unit = 100.0 / upd * 100000;
last = 100000.0 - hr / upd * 100000;
pt = trytry(0);
if (ac < pt) ac = pt;
}
for (int i = 1; i <= 105; i += 2) {
upd = i * 100 + (100 - hl) + hr;
first = (100 - hl) / upd * 100000;
unit = 100.0 / upd * 100000;
last = 100000.0 - hr / upd * 100000;
pt = trytry(1);
if (ac < pt) ac = pt;
}
for (int i = 0; i <= 105; i += 2) {
upd = i * 100 + (100.0 - hl) + (100.0 - hr);
first = (100.0 - hl) / upd * 100000;
unit = 100.0 / upd * 100000;
last = 100000.0 - (100.0 - hr) / upd * 100000;
pt = trytry(1);
if (ac < pt) ac = pt;
}
printf("%d\n", ac);
return 0;
}
|
During the break the schoolchildren, boys and girls, formed a queue of n people in the canteen. Initially the children stood in the order they entered the canteen. However, after a while the boys started feeling awkward for standing in front of the girls in the queue and they started letting the girls move forward each second.
Let's describe the process more precisely. Let's say that the positions in the queue are sequentially numbered by integers from 1 to n, at that the person in the position number 1 is served first. Then, if at time x a boy stands on the i-th position and a girl stands on the (i + 1)-th position, then at time x + 1 the i-th position will have a girl and the (i + 1)-th position will have a boy. The time is given in seconds.
You've got the initial position of the children, at the initial moment of time. Determine the way the queue is going to look after t seconds.
Input
The first line contains two integers n and t (1 ≤ n, t ≤ 50), which represent the number of children in the queue and the time after which the queue will transform into the arrangement you need to find.
The next line contains string s, which represents the schoolchildren's initial arrangement. If the i-th position in the queue contains a boy, then the i-th character of string s equals "B", otherwise the i-th character equals "G".
Output
Print string a, which describes the arrangement after t seconds. If the i-th position has a boy after the needed time, then the i-th character a must equal "B", otherwise it must equal "G".
Examples
Input
5 1
BGGBG
Output
GBGGB
Input
5 2
BGGBG
Output
GGBGB
Input
4 1
GGGB
Output
GGGB
|
n, t = map(int, input().split())
a = list(input())
for i in range(t):
j = 0
while j < n:
while j < n and a[j] == 'G':
j += 1
while j < n and a[j] == 'B':
j += 1
if j < n:
a[j - 1], a[j] = 'G', 'B'
j += 1
for i in a:
print(i, end = '')
|
One day n cells of some array decided to play the following game. Initially each cell contains a number which is equal to it's ordinal number (starting from 1). Also each cell determined it's favourite number. On it's move i-th cell can exchange it's value with the value of some other j-th cell, if |i - j| = di, where di is a favourite number of i-th cell. Cells make moves in any order, the number of moves is unlimited.
The favourite number of each cell will be given to you. You will also be given a permutation of numbers from 1 to n. You are to determine whether the game could move to this state.
Input
The first line contains positive integer n (1 ≤ n ≤ 100) — the number of cells in the array. The second line contains n distinct integers from 1 to n — permutation. The last line contains n integers from 1 to n — favourite numbers of the cells.
Output
If the given state is reachable in the described game, output YES, otherwise NO.
Examples
Input
5
5 4 3 2 1
1 1 1 1 1
Output
YES
Input
7
4 3 5 1 2 7 6
4 6 6 1 6 6 1
Output
NO
Input
7
4 2 5 1 3 7 6
4 6 6 1 6 6 1
Output
YES
|
#include <bits/stdc++.h>
using namespace std;
int g[102];
int a[102];
int find(int i) {
if (i != g[i]) g[i] = find(g[i]);
return g[i];
}
int main() {
int n;
cin >> n;
for (int i = 0; i <= n; i++) g[i] = i;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
int d;
cin >> d;
if (i + d <= n) g[find(i)] = find(i + d);
if (i - d > 0) g[find(i)] = find(i - d);
}
for (int i = 1; i <= n; i++)
if (find(i) == i) {
int c[102];
memset(c, 0, sizeof(c));
for (int j = 1; j <= n; j++)
if (find(j) == i) {
c[j]++;
c[a[j]]--;
}
for (int j = 1; j <= n; j++)
if (c[j]) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
|
Sereja has got an array, consisting of n integers, a1, a2, ..., an. Sereja is an active boy, so he is now going to complete m operations. Each operation will have one of the three forms:
1. Make vi-th array element equal to xi. In other words, perform the assignment avi = xi.
2. Increase each array element by yi. In other words, perform n assignments ai = ai + yi (1 ≤ i ≤ n).
3. Take a piece of paper and write out the qi-th array element. That is, the element aqi.
Help Sereja, complete all his operations.
Input
The first line contains integers n, m (1 ≤ n, m ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the original array.
Next m lines describe operations, the i-th line describes the i-th operation. The first number in the i-th line is integer ti (1 ≤ ti ≤ 3) that represents the operation type. If ti = 1, then it is followed by two integers vi and xi, (1 ≤ vi ≤ n, 1 ≤ xi ≤ 109). If ti = 2, then it is followed by integer yi (1 ≤ yi ≤ 104). And if ti = 3, then it is followed by integer qi (1 ≤ qi ≤ n).
Output
For each third type operation print value aqi. Print the values in the order, in which the corresponding queries follow in the input.
Examples
Input
10 11
1 2 3 4 5 6 7 8 9 10
3 2
3 9
2 10
3 1
3 10
1 1 10
2 10
2 10
3 1
3 10
3 9
Output
2
9
11
20
30
40
39
|
import sys,math
from collections import deque,defaultdict
import operator as op
from functools import reduce
from itertools import permutations
import heapq
#sys.setrecursionlimit(10**7)
# OneDrive\Documents\codeforces
I=sys.stdin.readline
alpha="abcdefghijklmnopqrstuvwxyz"
mod=10**9 + 7
"""
x_move=[-1,0,1,0,-1,1,1,-1]
y_move=[0,1,0,-1,1,1,-1,-1]
"""
def ii():
return int(I().strip())
def li():
return list(map(int,I().strip().split()))
def mi():
return map(int,I().strip().split())
def ncr(n, r):
r = min(r, n-r)
numer = reduce(op.mul, range(n, n-r, -1), 1)
denom = reduce(op.mul, range(1, r+1), 1)
return numer // denom
def ispali(s):
i=0
j=len(s)-1
while i<j:
if s[i]!=s[j]:
return False
i+=1
j-=1
return True
def isPrime(n):
if n<=1:
return False
elif n<=2:
return True
else:
for i in range(2,int(n**.5)+1):
if n%i==0:
return False
return True
def main():
n,m=mi()
arr=li()
ans=""
cnt=0
for i in range(m):
op=li()
if op[0]==1:
arr[op[1]-1]=op[2]-cnt
elif op[0]==2:
cnt+=op[1]
else:
ans+=str(arr[op[1]-1]+cnt)+"\n"
print(ans)
if __name__ == '__main__':
main()
|
Paladin Manao caught the trail of the ancient Book of Evil in a swampy area. This area contains n settlements numbered from 1 to n. Moving through the swamp is very difficult, so people tramped exactly n - 1 paths. Each of these paths connects some pair of settlements and is bidirectional. Moreover, it is possible to reach any settlement from any other one by traversing one or several paths.
The distance between two settlements is the minimum number of paths that have to be crossed to get from one settlement to the other one. Manao knows that the Book of Evil has got a damage range d. This means that if the Book of Evil is located in some settlement, its damage (for example, emergence of ghosts and werewolves) affects other settlements at distance d or less from the settlement where the Book resides.
Manao has heard of m settlements affected by the Book of Evil. Their numbers are p1, p2, ..., pm. Note that the Book may be affecting other settlements as well, but this has not been detected yet. Manao wants to determine which settlements may contain the Book. Help him with this difficult task.
Input
The first line contains three space-separated integers n, m and d (1 ≤ m ≤ n ≤ 100000; 0 ≤ d ≤ n - 1). The second line contains m distinct space-separated integers p1, p2, ..., pm (1 ≤ pi ≤ n). Then n - 1 lines follow, each line describes a path made in the area. A path is described by a pair of space-separated integers ai and bi representing the ends of this path.
Output
Print a single number — the number of settlements that may contain the Book of Evil. It is possible that Manao received some controversial information and there is no settlement that may contain the Book. In such case, print 0.
Examples
Input
6 2 3
1 2
1 5
2 3
3 4
4 5
5 6
Output
3
Note
Sample 1. The damage range of the Book of Evil equals 3 and its effects have been noticed in settlements 1 and 2. Thus, it can be in settlements 3, 4 or 5.
<image>
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 3;
int n, m, d, p[N], mx[N][2], us[N];
vector<vector<int> > v;
void up(int ind, int ch) {
if (mx[ind][0] <= ch) {
mx[ind][1] = mx[ind][0];
mx[ind][0] = ch;
} else if (mx[ind][1] < ch) {
mx[ind][1] = ch;
}
}
void dfs(int x) {
us[x] = 1;
for (auto u : v[x]) {
if (!us[u]) {
dfs(u);
up(x, mx[u][0] + 1);
}
}
if (p[x]) up(x, 0);
}
int ans = 0;
void dfs1(int x, int way) {
us[x] = 1;
if (way <= d && mx[x][0] <= d) ans++;
for (auto u : v[x]) {
if (!us[u])
if (mx[u][0] + 1 == mx[x][0])
dfs1(u, max(way, mx[x][1]) + 1);
else
dfs1(u, max(way, mx[x][0]) + 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> d;
v.resize(n);
for (int i = 0; i < m; i++) {
int x;
cin >> x;
--x;
p[x] = 1;
}
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
--x;
--y;
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 0; i < n; i++) mx[i][0] = mx[i][1] = -(int)2e9;
dfs(0);
fill(us, us + n, 0);
int huihuihhuiuuuuuuuuuuuihuiui = -(int)2e9;
dfs1(0, huihuihhuiuuuuuuuuuuuihuiui);
cout << ans;
}
|
Levko loves array a1, a2, ... , an, consisting of integers, very much. That is why Levko is playing with array a, performing all sorts of operations with it. Each operation Levko performs is of one of two types:
1. Increase all elements from li to ri by di. In other words, perform assignments aj = aj + di for all j that meet the inequation li ≤ j ≤ ri.
2. Find the maximum of elements from li to ri. That is, calculate the value <image>.
Sadly, Levko has recently lost his array. Fortunately, Levko has records of all operations he has performed on array a. Help Levko, given the operation records, find at least one suitable array. The results of all operations for the given array must coincide with the record results. Levko clearly remembers that all numbers in his array didn't exceed 109 in their absolute value, so he asks you to find such an array.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 5000) — the size of the array and the number of operations in Levko's records, correspondingly.
Next m lines describe the operations, the i-th line describes the i-th operation. The first integer in the i-th line is integer ti (1 ≤ ti ≤ 2) that describes the operation type. If ti = 1, then it is followed by three integers li, ri and di (1 ≤ li ≤ ri ≤ n, - 104 ≤ di ≤ 104) — the description of the operation of the first type. If ti = 2, then it is followed by three integers li, ri and mi (1 ≤ li ≤ ri ≤ n, - 5·107 ≤ mi ≤ 5·107) — the description of the operation of the second type.
The operations are given in the order Levko performed them on his array.
Output
In the first line print "YES" (without the quotes), if the solution exists and "NO" (without the quotes) otherwise.
If the solution exists, then on the second line print n integers a1, a2, ... , an (|ai| ≤ 109) — the recovered array.
Examples
Input
4 5
1 2 3 1
2 1 2 8
2 3 4 7
1 1 3 3
2 3 4 8
Output
YES
4 7 4 7
Input
4 5
1 2 3 1
2 1 2 8
2 3 4 7
1 1 3 3
2 3 4 13
Output
NO
|
#include <bits/stdc++.h>
using namespace std;
int q[10000][5];
int t[10000];
int m;
int main() {
int n;
cin >> n >> m;
for (int i = 0; i < m; i++) cin >> q[i][0] >> q[i][1] >> q[i][2] >> q[i][3];
for (int i = 1; i <= n; i++) {
t[i] = 1000000000;
int tot = 0;
for (int j = 0; j < m; j++) {
if (q[j][0] == 1) {
if (q[j][1] <= i && q[j][2] >= i) tot += q[j][3];
} else {
if (q[j][1] <= i && q[j][2] >= i) t[i] = min(q[j][3] - tot, t[i]);
}
}
}
for (int i = 1; i <= n; i++) {
long long tot = 0;
for (int j = 0; j < m; j++) {
if (q[j][0] == 1) {
if (q[j][1] <= i && q[j][2] >= i) tot += q[j][3];
} else {
if (q[j][1] <= i && q[j][2] >= i)
if (t[i] + tot == q[j][3]) q[j][4] = 1;
}
}
}
int u = 1;
for (int i = 0; i < m; i++)
if (q[i][0] != 1 && q[i][4] == 0) u = 0;
if (u) {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << t[i] << " ";
cout << endl;
} else
cout << "NO" << endl;
}
|
Iahub accidentally discovered a secret lab. He found there n devices ordered in a line, numbered from 1 to n from left to right. Each device i (1 ≤ i ≤ n) can create either ai units of matter or ai units of antimatter.
Iahub wants to choose some contiguous subarray of devices in the lab, specify the production mode for each of them (produce matter or antimatter) and finally take a photo of it. However he will be successful only if the amounts of matter and antimatter produced in the selected subarray will be the same (otherwise there would be overflowing matter or antimatter in the photo).
You are requested to compute the number of different ways Iahub can successful take a photo. A photo is different than another if it represents another subarray, or if at least one device of the subarray is set to produce matter in one of the photos and antimatter in the other one.
Input
The first line contains an integer n (1 ≤ n ≤ 1000). The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1000).
The sum a1 + a2 + ... + an will be less than or equal to 10000.
Output
Output a single integer, the number of ways Iahub can take a photo, modulo 1000000007 (109 + 7).
Examples
Input
4
1 1 1 1
Output
12
Note
The possible photos are [1+, 2-], [1-, 2+], [2+, 3-], [2-, 3+], [3+, 4-], [3-, 4+], [1+, 2+, 3-, 4-], [1+, 2-, 3+, 4-], [1+, 2-, 3-, 4+], [1-, 2+, 3+, 4-], [1-, 2+, 3-, 4+] and [1-, 2-, 3+, 4+], where "i+" means that the i-th element produces matter, and "i-" means that the i-th element produces antimatter.
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const long long OO = 1LL << 61;
const int MOD = 1000000007;
long long dp[1005][20005];
int a[1005];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(dp, 0, sizeof dp);
for (int i = 0; i <= n; i++) dp[i][10000] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 20000; j++) {
if (j + a[i] <= 20000)
dp[i][j + a[i]] = (dp[i][j + a[i]] + dp[i - 1][j] + MOD) % MOD;
if (j - a[i] >= 0)
dp[i][j - a[i]] = (dp[i][j - a[i]] + dp[i - 1][j] + MOD) % MOD;
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) ans = (ans + dp[i][10000] - 1 + MOD) % MOD;
cout << ans << endl;
}
return 0;
}
|
Valera had an undirected connected graph without self-loops and multiple edges consisting of n vertices. The graph had an interesting property: there were at most k edges adjacent to each of its vertices. For convenience, we will assume that the graph vertices were indexed by integers from 1 to n.
One day Valera counted the shortest distances from one of the graph vertices to all other ones and wrote them out in array d. Thus, element d[i] of the array shows the shortest distance from the vertex Valera chose to vertex number i.
Then something irreparable terrible happened. Valera lost the initial graph. However, he still has the array d. Help him restore the lost graph.
Input
The first line contains two space-separated integers n and k (1 ≤ k < n ≤ 105). Number n shows the number of vertices in the original graph. Number k shows that at most k edges were adjacent to each vertex in the original graph.
The second line contains space-separated integers d[1], d[2], ..., d[n] (0 ≤ d[i] < n). Number d[i] shows the shortest distance from the vertex Valera chose to the vertex number i.
Output
If Valera made a mistake in his notes and the required graph doesn't exist, print in the first line number -1. Otherwise, in the first line print integer m (0 ≤ m ≤ 106) — the number of edges in the found graph.
In each of the next m lines print two space-separated integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi), denoting the edge that connects vertices with numbers ai and bi. The graph shouldn't contain self-loops and multiple edges. If there are multiple possible answers, print any of them.
Examples
Input
3 2
0 1 1
Output
3
1 2
1 3
3 2
Input
4 2
2 0 1 3
Output
3
1 3
1 4
2 3
Input
3 1
0 0 0
Output
-1
|
from sys import exit
n, k = map(int, input().split())
nodes = [[] for _ in range(n+1)]
edges = []
for node, dist in enumerate(map(int, input().split())):
nodes[dist].append(node)
if len(nodes[0]) != 1 or len(nodes[1]) > k:
print(-1)
else:
for i in range(1, n):
if len(nodes[i])*(k-1) < len(nodes[i+1]):
print(-1)
exit(0)
for i in range(n):
next = 0
if len(nodes[i+1]) > 0:
for j, node in enumerate(nodes[i]):
current = 0
while current < (k if i == 0 else k-1) and next < len(nodes[i+1]):
edges.append((node+1, nodes[i+1][next]+1))
next += 1
current += 1
print(len(edges))
print('\n'.join(map(lambda x: ' '.join([str(x[0]), str(x[1])]), edges)))
|
One day, after a difficult lecture a diligent student Sasha saw a graffitied desk in the classroom. She came closer and read: "Find such positive integer n, that among numbers n + 1, n + 2, ..., 2·n there are exactly m numbers which binary representation contains exactly k digits one".
The girl got interested in the task and she asked you to help her solve it. Sasha knows that you are afraid of large numbers, so she guaranteed that there is an answer that doesn't exceed 1018.
Input
The first line contains two space-separated integers, m and k (0 ≤ m ≤ 1018; 1 ≤ k ≤ 64).
Output
Print the required number n (1 ≤ n ≤ 1018). If there are multiple answers, print any of them.
Examples
Input
1 1
Output
1
Input
3 2
Output
5
|
import java.util.*;
import java.io.*;
public class D {
static int [] bits ;
static long [][][] memo ; // less , k , pos
static long dp(int less , int rem , int pos)
{
if(rem == 0)
return 1 ;
if(pos == bits.length)
return 0 ;
if(memo[less][rem][pos] != -1)
return memo[less][rem][pos] ;
long take = (less | bits[pos]) == 0 ? 0 : dp(less, rem - 1, pos + 1);
long leave = dp(less | bits[pos] , rem, pos + 1) ;
return memo[less][rem][pos] = take + leave ;
}
static int len(long num)
{
int ans = 0 ;
while(num > 0)
{
num /= 2 ;
ans ++ ;
}
return ans ;
}
static long sum(long num , int k)
{
long l = num , r = num << 1l ;
long ans = 0l ;
int len = len(r);
bits = new int[len];
long temp = r ;
for(int i = len - 1 ; i >= 0 ; i-- , temp >>= 1)
bits[i] = (temp & 1) != 0 ? 1 : 0 ;
memo = new long [2][k+1][len];
for(int i = 0 ; i < 2 ; i++)
for(int j = 0 ; j <= k ; j++)
Arrays.fill(memo[i][j], -1);
ans += dp(0, k , 0);
len = len(l) ;
bits = new int [len];
temp = l ;
for(int i = len - 1 ; i >= 0 ; i-- , temp >>= 1)
bits[i] = (temp & 1) != 0 ? 1 : 0 ;
memo = new long [2][k+1][len];
for(int i = 0 ; i < 2 ; i++)
for(int j = 0 ; j <= k ; j++)
Arrays.fill(memo[i][j], -1);
ans -= dp(0, k , 0);
return ans ;
}
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner();
long m = sc.nextLong() , ans = -1 , start = 1 , end = (long)1e18;
int k = sc.nextInt() ;
while(start <= end)
{
long mid = (start + end) / 2 ;
long cnt = sum(mid , k);
if(cnt >= m)
{
end = mid - 1 ;
ans = mid ;
}
else
start = mid + 1;
}
System.out.println(ans);
}
static class Scanner {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st;
String next() throws Exception {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
int nextInt() throws Exception {
return Integer.parseInt(next());
}
long nextLong () throws Exception
{
return Long.parseLong(next());
}
}
}
|
Twilight Sparkle once got a crystal from the Crystal Mine. A crystal of size n (n is odd; n > 1) is an n × n matrix with a diamond inscribed into it.
You are given an odd integer n. You need to draw a crystal of size n. The diamond cells of the matrix should be represented by character "D". All other cells of the matrix should be represented by character "*". Look at the examples to understand what you need to draw.
Input
The only line contains an integer n (3 ≤ n ≤ 101; n is odd).
Output
Output a crystal of size n.
Examples
Input
3
Output
*D*
DDD
*D*
Input
5
Output
**D**
*DDD*
DDDDD
*DDD*
**D**
Input
7
Output
***D***
**DDD**
*DDDDD*
DDDDDDD
*DDDDD*
**DDD**
***D***
|
#include <bits/stdc++.h>
using namespace std;
long long int INF = 1e18 + 5;
long long int power(long long int a, long long int n) {
long long int res = 1;
if (n & 1) {
n--;
res *= a;
} else {
n /= 2;
a = a * a;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
const long long int N = 1e6 + 5;
const long long int MOD = 1e9 + 7;
void solve() {
list<string> ans;
long long int n;
cin >> n;
string s(n, 'D');
ans.push_back(s);
long long int a = 0, b = n - 1;
for (long long int i = 1; i <= n / 2; i++) {
s[a] = '*';
s[b] = '*';
ans.push_back(s);
ans.push_front(s);
a++;
b--;
}
for (auto it : ans) cout << it << "\n";
return;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int T = 1;
for (long long int i = 1; i <= T; i++) solve();
}
|
Dreamoon likes to play with sets, integers and <image>. <image> is defined as the largest positive integer that divides both a and b.
Let S be a set of exactly four distinct integers greater than 0. Define S to be of rank k if and only if for all pairs of distinct elements si, sj from S, <image>.
Given k and n, Dreamoon wants to make up n sets of rank k using integers from 1 to m such that no integer is used in two different sets (of course you can leave some integers without use). Calculate the minimum m that makes it possible and print one possible solution.
Input
The single line of the input contains two space separated integers n, k (1 ≤ n ≤ 10 000, 1 ≤ k ≤ 100).
Output
On the first line print a single integer — the minimal possible m.
On each of the next n lines print four space separated integers representing the i-th set.
Neither the order of the sets nor the order of integers within a set is important. If there are multiple possible solutions with minimal m, print any one of them.
Examples
Input
1 1
Output
5
1 2 3 5
Input
2 2
Output
22
2 4 6 22
14 18 10 16
Note
For the first example it's easy to see that set {1, 2, 3, 4} isn't a valid set of rank 1 since <image>.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long k;
cin >> k;
long long ans = k * (6 * n - 1);
cout << ans << endl;
long long tmp = 0;
for (int i = 0; i < n; i++) {
cout << k * (tmp + 1) << " " << k * (tmp + 2) << " " << k * (tmp + 3) << " "
<< k * (tmp + 5) << endl;
tmp += 6;
}
return 0;
}
|
The DNA sequence for every living creature in Berland can be represented as a non-empty line consisting of lowercase Latin letters. Berland scientists found out that all the creatures evolve by stages. During one stage exactly one symbol of the DNA line is replaced by exactly two other ones. At that overall there are n permissible substitutions. The substitution ai->bici means that any one symbol ai can be replaced with two symbols bici. Every substitution could happen an unlimited number of times.
They say that two creatures with DNA sequences s1 and s2 can have a common ancestor if there exists such a DNA sequence s3 that throughout evolution it can result in s1 and s2, perhaps after a different number of stages. Your task is to find out by the given s1 and s2 whether the creatures possessing such DNA sequences can have a common ancestor. If the answer is positive, you have to find the length of the shortest sequence of the common ancestor’s DNA.
Input
The first line contains a non-empty DNA sequence s1, the second line contains a non-empty DNA sequence s2. The lengths of these lines do not exceed 50, the lines contain only lowercase Latin letters. The third line contains an integer n (0 ≤ n ≤ 50) — the number of permissible substitutions. Then follow n lines each of which describes a substitution in the format ai->bici. The characters ai, bi, and ci are lowercase Latin letters. Lines s1 and s2 can coincide, the list of substitutions can contain similar substitutions.
Output
If s1 and s2 cannot have a common ancestor, print -1. Otherwise print the length of the shortest sequence s3, from which s1 and s2 could have evolved.
Examples
Input
ababa
aba
2
c->ba
c->cc
Output
2
Input
ababa
aba
7
c->ba
c->cc
e->ab
z->ea
b->ba
d->dd
d->ab
Output
1
Input
ababa
aba
1
c->ba
Output
-1
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double PI = acos((long double)-1.0);
const int INF = 1 << 30;
const long long LINF = 1ll << 61;
const int BUFFER_SZ = 1 << 20;
const int MOD = 1000 * 1000 * 1000 + 7;
char BUFFER[BUFFER_SZ];
int gi() {
int x;
scanf("%d", &x);
return x;
}
double gd() {
double x;
scanf("%lf", &x);
return x;
}
long long gll() {
long long x;
cin >> x;
return x;
}
vector<int> gvi(int n) {
vector<int> a;
while (n-- > 0) a.push_back(gi());
return a;
}
string gs() {
scanf("%s", BUFFER);
return string(BUFFER);
}
template <class T>
void print(vector<T> &x, string format) {
format += "%c";
for (int i = 0; i < x.size(); ++i)
printf(format.c_str(), x[i], i + 1 == x.size() ? '\n' : ' ');
}
int dp[64][64];
int N;
int rulesIn[64];
int rulesOut1[64];
int rulesOut2[64];
string A, B;
int dp1[64][64];
int dp2[64][64];
int go(string &s, int (&dp)[64][64], int a, int b) {
int &r = dp[a][b];
if (r != -1) return r;
if (a == b) return r = 1 << (s[a] - 'a');
r = 0;
for (int i = a; i < b; ++i) {
for (int k = 0; k < N; ++k) {
if ((go(s, dp, a, i) >> rulesOut1[k] & 1) &&
(go(s, dp, i + 1, b) >> rulesOut2[k] & 1)) {
r |= 1 << rulesIn[k];
}
}
}
return r;
}
int rec(int a, int b) {
int &r = dp[a][b];
if (r != -1) return r;
r = INF;
if (a == A.size() && b == B.size()) return r = 0;
if (a == A.size() || b == B.size()) return INF;
for (int ai = 1; a + ai <= A.size(); ++ai) {
for (int bi = 1; b + bi <= B.size(); ++bi) {
if (go(A, dp1, a, a + ai - 1) & go(B, dp2, b, b + bi - 1)) {
r = min(r, 1 + rec(a + ai, b + bi));
}
}
}
return r;
}
void solve() {
A = gs();
B = gs();
N = gi();
for (int i = 0; i < N; ++i) {
string s = gs();
rulesIn[i] = s[0] - 'a';
rulesOut1[i] = s[3] - 'a';
rulesOut2[i] = s[4] - 'a';
}
memset((dp), (-1), sizeof(dp));
memset((dp1), (-1), sizeof(dp1));
memset((dp2), (-1), sizeof(dp2));
int res = rec(0, 0);
if (res == INF) res = -1;
cout << res << endl;
}
int main() {
solve();
return 0;
}
|
Polycarpus has a chessboard of size n × m, where k rooks are placed. Polycarpus hasn't yet invented the rules of the game he will play. However, he has already allocated q rectangular areas of special strategic importance on the board, they must be protected well. According to Polycarpus, a rectangular area of the board is well protected if all its vacant squares can be beaten by the rooks that stand on this area. The rooks on the rest of the board do not affect the area's defense. The position of the rooks is fixed and cannot be changed. We remind you that the the rook beats the squares located on the same vertical or horizontal line with it, if there are no other pieces between the square and the rook. Help Polycarpus determine whether all strategically important areas are protected.
Input
The first line contains four integers n, m, k and q (1 ≤ n, m ≤ 100 000, 1 ≤ k, q ≤ 200 000) — the sizes of the board, the number of rooks and the number of strategically important sites. We will consider that the cells of the board are numbered by integers from 1 to n horizontally and from 1 to m vertically. Next k lines contain pairs of integers "x y", describing the positions of the rooks (1 ≤ x ≤ n, 1 ≤ y ≤ m). It is guaranteed that all the rooks are in distinct squares. Next q lines describe the strategically important areas as groups of four integers "x1 y1 x2 y2" (1 ≤ x1 ≤ x2 ≤ n, 1 ≤ y1 ≤ y2 ≤ m). The corresponding rectangle area consists of cells (x, y), for which x1 ≤ x ≤ x2, y1 ≤ y ≤ y2. Strategically important areas can intersect of coincide.
Output
Print q lines. For each strategically important site print "YES" if it is well defended and "NO" otherwise.
Examples
Input
4 3 3 3
1 1
3 2
2 3
2 3 2 3
2 1 3 3
1 2 2 3
Output
YES
YES
NO
Note
Picture to the sample: <image> For the last area the answer is "NO", because cell (1, 2) cannot be hit by a rook.
|
#include <bits/stdc++.h>
using namespace std;
class ST {
private:
int st[400013];
int size;
int left(int w) { return w << 1; }
int right(int w) { return (w << 1) + 1; }
int queryI(int w, int L, int R, int a, int b) {
if (a > R || b < L) return 2147483647;
if (L >= a && R <= b) return st[w];
int lC = queryI(left(w), L, (L + R) / 2, a, b);
int rC = queryI(right(w), (L + R) / 2 + 1, R, a, b);
return min(lC, rC);
}
void updateI(int w, int L, int R, int a, int val) {
if (a > R || a < L) return;
if (L == R)
st[w] = val;
else {
updateI(left(w), L, (L + R) / 2, a, val);
updateI(right(w), (L + R) / 2 + 1, R, a, val);
st[w] = min(st[left(w)], st[right(w)]);
}
}
public:
ST(int s = 0) {
fill(st, st + 4 * s, 0);
size = s;
}
int query(int a, int b) { return queryI(1, 0, size - 1, a, b); }
void update(int a, int val) { updateI(1, 0, size - 1, a, val); }
};
struct Query {
int id, x1, x2, y1, y2;
};
int n, m, k, q;
vector<int> rooks[100013];
vector<int> rooks2[100013];
vector<Query> queries[100013];
vector<Query> queries2[100013];
int ans[200013];
ST tree;
int main() {
int n, m, k, q;
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = 0; i < k; i++) {
int x, y;
scanf("%d%d", &x, &y);
rooks[x].push_back(y);
rooks2[y].push_back(x);
}
for (int i = 0; i < q; i++) {
int x1, x2, y1, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
Query next;
next.id = i;
next.x1 = x1;
next.x2 = x2;
next.y1 = y1;
next.y2 = y2;
queries[x2].push_back(next);
next.id = i;
next.x1 = y1;
next.x2 = y2;
next.y1 = x1;
next.y2 = x2;
queries2[y2].push_back(next);
}
tree = ST(m + 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < rooks[i].size(); j++) tree.update(rooks[i][j], i);
for (int j = 0; j < queries[i].size(); j++) {
Query cur = queries[i][j];
if (tree.query(cur.y1, cur.y2) >= cur.x1) ans[cur.id] = 1;
}
}
swap(rooks, rooks2);
swap(queries, queries2);
tree = ST(n + 1);
for (int i = 1; i <= m; i++) {
for (int j = 0; j < rooks[i].size(); j++) tree.update(rooks[i][j], i);
for (int j = 0; j < queries[i].size(); j++) {
Query cur = queries[i][j];
if (tree.query(cur.y1, cur.y2) >= cur.x1) ans[cur.id] = 1;
}
}
for (int i = 0; i < q; i++) printf("%s\n", ans[i] ? "YES" : "NO");
return 0;
}
|
One winter evening the Hedgehog was relaxing at home in his cozy armchair and clicking through the TV channels. Stumbled on an issue of «TopShop», the Hedgehog was about to change the channel when all of a sudden he was stopped by an advertisement of a new wondrous invention.
Actually, a vacuum cleaner was advertised there. It was called Marvellous Vacuum and it doesn't even need a human to operate it while it cleans! The vacuum cleaner can move around the flat on its own: it moves in some direction and if it hits an obstacle there, it automatically chooses a new direction. Sooner or later this vacuum cleaner will travel through all the room and clean it all. Having remembered how much time the Hedgehog spends every time on cleaning (surely, no less than a half of the day), he got eager to buy this wonder.
However, the Hedgehog quickly understood that the cleaner has at least one weak point: it won't clean well in the room's corners because it often won't able to reach the corner due to its shape. To estimate how serious is this drawback in practice, the Hedgehog asked you to write for him the corresponding program.
You will be given the cleaner's shape in the top view. We will consider only the cases when the vacuum cleaner is represented as a convex polygon. The room is some infinitely large rectangle. We consider one corner of this room and want to find such a rotation of the vacuum cleaner so that it, being pushed into this corner, will leave the minimum possible area in the corner uncovered.
Input
The first line contains an integer N which represents the number of vertices of the vacuum cleaner's polygon (3 ≤ N ≤ 4·104). Then follow N lines each containing two numbers — the coordinates of a vertex of the polygon. All the coordinates are integer and their absolute values do not exceed 106.
It is guaranteed that the given polygon is nondegenerate and convex (no three points lie on the same line). The polygon vertices are given in a clockwise or counter-clockwise direction.
Output
Print the minimum possible uncovered area. The answer will be accepted if it is within 10 - 6 of absolute or relative error from the correct answer.
Examples
Input
4
0 0
1 0
1 1
0 1
Output
0.00000000000000000000
Input
8
1 2
2 1
2 -1
1 -2
-1 -2
-2 -1
-2 1
-1 2
Output
0.50000000000000000000
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
inline int sgn(double x) { return (x > eps) - (x < -eps); }
inline double sqr(double x) { return x * x; }
struct point {
double x, y;
point(double _x = 0, double _y = 0) { x = _x, y = _y; }
point operator-(const point &a) { return point(x - a.x, y - a.y); }
void input() { scanf("%lf%lf", &x, &y); }
void output() { printf("%f %f\n", x, y); }
} p[150000];
inline double mult(point a, point b, point c) {
return (a.x - c.x) * (b.y - c.y) - (a.y - c.y) * (b.x - c.x);
}
inline double dist(point a, point b) {
return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));
}
inline double dot(point a, point b) { return a.x * b.x + a.y * b.y; }
inline double cross(point a, point b) { return a.x * b.y - a.y * b.x; }
inline double _angle(point a, point b) {
double res =
acos(dot(a, b) /
((sqrt(a.x * a.x + a.y * a.y) * sqrt(b.x * b.x + b.y * b.y))));
if (sgn(cross(a, b)) < 0) return 2 * pi - res;
return res;
}
inline point intersection(point u1, point u2, point v1, point v2) {
point ret = u1;
double t = ((u1.x - v1.x) * (v1.y - v2.y) - (u1.y - v1.y) * (v1.x - v2.x)) /
((u1.x - u2.x) * (v1.y - v2.y) - (u1.y - u2.y) * (v1.x - v2.x));
ret.x += (u2.x - u1.x) * t;
ret.y += (u2.y - u1.y) * t;
return ret;
}
inline point p_to_l(point p, point l1, point l2) {
point t = p;
t.x += l1.y - l2.y, t.y += l2.x - l1.x;
return intersection(p, t, l1, l2);
}
inline void solve(point p[], int n, double &ans) {
int j = 0;
double sum = 0;
for (int i = 0; i < n; i++) {
j = max(j, i + 1);
double angle = _angle(p[i + 1] - p[i], p[j + 1] - p[j]);
while (sgn(angle - pi / 2) < 0 && j < i + n) {
j++;
sum += mult(p[j], p[j - 1], p[i]);
angle = _angle(p[i + 1] - p[i], p[j + 1] - p[j]);
}
sum -= mult(p[j], p[i + 1], p[i]);
point tmp = p_to_l(p[j], p[i + 1], p[i + n]);
double res = dist(tmp, p[j]) * dist(tmp, p[i + 1]) / 2;
ans = min(ans, res - fabs(sum) / 2);
}
}
int main() {
int n;
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; i++) p[i].input(), p[i + n] = p[i];
double ans = 1e20;
if (sgn(mult(p[2], p[1], p[0])) > 0) reverse(p, p + 2 * n);
solve(p, n, ans);
reverse(p, p + 2 * n);
for (int i = 0; i < 2 * n; i++) p[i].x = -p[i].x;
solve(p, n, ans);
printf("%.20f\n", ans);
}
}
|
Let's consider a table consisting of n rows and n columns. The cell located at the intersection of i-th row and j-th column contains number i × j. The rows and columns are numbered starting from 1.
You are given a positive integer x. Your task is to count the number of cells in a table that contain number x.
Input
The single line contains numbers n and x (1 ≤ n ≤ 105, 1 ≤ x ≤ 109) — the size of the table and the number that we are looking for in the table.
Output
Print a single number: the number of times x occurs in the table.
Examples
Input
10 5
Output
2
Input
6 12
Output
4
Input
5 13
Output
0
Note
A table for the second sample test is given below. The occurrences of number 12 are marked bold.
<image>
|
import sys
n, x = map(int, sys.stdin.readline().split())
s = 0
for i in range(1, n + 1):
if (x % i == 0 and x / i <= n):
s += 1
print(s)
|
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 × 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 ≤ x ≤ 1018) — the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k — the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality — in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 × 2 table there are 2 1 × 1 squares. So, 2 distinct squares in total.
<image>
In a 2 × 3 table there are 6 1 × 1 squares and 2 2 × 2 squares. That is equal to 8 squares in total.
<image>
|
n,i,t,r=int(input()),0,0,[]
while 1:
i+=1
n-=i*i
if n<0:break
t+=i
m=n//t
r+=[(m+i,i),(i,m+i)][m==0:]*(m*t==n)
print(len(r))
for p in sorted(r):print("%d %d"%p)
|
There are n pearls in a row. Let's enumerate them with integers from 1 to n from the left to the right. The pearl number i has the type ai.
Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type.
Split the row of the pearls to the maximal number of good segments. Note that each pearl should appear in exactly one segment of the partition.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the number of pearls in a row.
The second line contains n integers ai (1 ≤ ai ≤ 109) – the type of the i-th pearl.
Output
On the first line print integer k — the maximal number of segments in a partition of the row.
Each of the next k lines should contain two integers lj, rj (1 ≤ lj ≤ rj ≤ n) — the number of the leftmost and the rightmost pearls in the j-th segment.
Note you should print the correct partition of the row of the pearls, so each pearl should be in exactly one segment and all segments should contain two pearls of the same type.
If there are several optimal solutions print any of them. You can print the segments in any order.
If there are no correct partitions of the row print the number "-1".
Examples
Input
5
1 2 3 4 1
Output
1
1 5
Input
5
1 2 3 4 5
Output
-1
Input
7
1 2 1 3 1 2 1
Output
2
1 3
4 7
|
import java.util.*;
import java.io.*;
public class cf{
public static void main(String args[])throws Exception{
Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
int n=sc.nextInt();
ArrayList<String> ans=new ArrayList<>();
HashMap<Long,Integer> indices=new HashMap<>();
for(int i=0;i<n;i++){
long x=sc.nextLong();
if(!indices.containsKey(x))
indices.put(x,i+1);
else{
ans.add(""+indices.get(x)+" "+(i+1));
indices=new HashMap<>();
}
}
if(ans.size()==0)System.out.println("-1");
else{
int curr=1;
System.out.println(ans.size());
String y=ans.remove(ans.size()-1);
ans.add(y.substring(0,y.indexOf(' '))+" "+n);
for(String x:ans){
System.out.println(""+curr+x.substring(x.indexOf(' ')));
curr=Integer.parseInt(x.substring(x.indexOf(' ')+1))+1;
}
}
}
}
|
Little Artem likes electronics. He can spend lots of time making different schemas and looking for novelties in the nearest electronics store. The new control element was delivered to the store recently and Artem immediately bought it.
That element can store information about the matrix of integers size n × m. There are n + m inputs in that element, i.e. each row and each column can get the signal. When signal comes to the input corresponding to some row, this row cyclically shifts to the left, that is the first element of the row becomes last element, second element becomes first and so on. When signal comes to the input corresponding to some column, that column shifts cyclically to the top, that is first element of the column becomes last element, second element becomes first and so on. Rows are numbered with integers from 1 to n from top to bottom, while columns are numbered with integers from 1 to m from left to right.
Artem wants to carefully study this element before using it. For that purpose he is going to set up an experiment consisting of q turns. On each turn he either sends the signal to some input or checks what number is stored at some position of the matrix.
Artem has completed his experiment and has written down the results, but he has lost the chip! Help Artem find any initial matrix that will match the experiment results. It is guaranteed that experiment data is consistent, which means at least one valid matrix exists.
Input
The first line of the input contains three integers n, m and q (1 ≤ n, m ≤ 100, 1 ≤ q ≤ 10 000) — dimensions of the matrix and the number of turns in the experiment, respectively.
Next q lines contain turns descriptions, one per line. Each description starts with an integer ti (1 ≤ ti ≤ 3) that defines the type of the operation. For the operation of first and second type integer ri (1 ≤ ri ≤ n) or ci (1 ≤ ci ≤ m) follows, while for the operations of the third type three integers ri, ci and xi (1 ≤ ri ≤ n, 1 ≤ ci ≤ m, - 109 ≤ xi ≤ 109) are given.
Operation of the first type (ti = 1) means that signal comes to the input corresponding to row ri, that is it will shift cyclically. Operation of the second type (ti = 2) means that column ci will shift cyclically. Finally, operation of the third type means that at this moment of time cell located in the row ri and column ci stores value xi.
Output
Print the description of any valid initial matrix as n lines containing m integers each. All output integers should not exceed 109 by their absolute value.
If there are multiple valid solutions, output any of them.
Examples
Input
2 2 6
2 1
2 2
3 1 1 1
3 2 2 2
3 1 2 8
3 2 1 8
Output
8 2
1 8
Input
3 3 2
1 2
3 2 2 5
Output
0 0 0
0 0 5
0 0 0
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> mat[103][103];
int org[103][103];
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
mat[i][j] = make_pair(i, j);
}
}
for (int i = 1; i <= q; ++i) {
int t, r, c, x;
pair<int, int> temp;
cin >> t;
if (t == 1) {
cin >> r;
temp = mat[r][1];
for (int i = 1; i < m; ++i) {
mat[r][i] = mat[r][i + 1];
}
mat[r][m] = temp;
} else if (t == 2) {
cin >> c;
temp = mat[1][c];
for (int i = 1; i < n; ++i) {
mat[i][c] = mat[i + 1][c];
}
mat[n][c] = temp;
} else {
cin >> r >> c >> x;
org[mat[r][c].first][mat[r][c].second] = x;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cout << org[i][j] << " ";
}
cout << "\n";
}
return 0;
}
|
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 ≤ ai ≤ 3, 1 ≤ ti, xi ≤ 109) — type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0
|
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class Main extends PrintWriter {
final Random rand = new Random(31);
final int inf = (int) 1e9;
final long linf = (long) 1e18;
final static String IO = "_std";
class Treap {
int x, y, sz;
Treap l, r;
public Treap(int x) {
this.x = x;
y = rand.nextInt();
sz = 1;
l = r = null;
}
}
int getSz(Treap t) {
if (t == null) {
return 0;
}
return t.sz;
}
void recalc(Treap t) {
if (t != null) {
t.sz = getSz(t.l) + getSz(t.r) + 1;
}
}
Treap[] split(Treap t, int x) {
if (t == null) {
return new Treap[] {null, null};
}
Treap[] r;
if (x < t.x) {
r = split(t.l, x);
t.l = r[1];
r[1] = t;
} else {
r = split(t.r, x);
t.r = r[0];
r[0] = t;
}
recalc(r[0]);
recalc(r[1]);
return r;
}
Treap merge(Treap l, Treap r) {
if (l == null || r == null) {
return l == null ? r : l;
}
Treap t;
if (l.y < r.y) {
l.r = merge(l.r, r);
t = l;
} else {
r.l = merge(l, r.l);
t = r;
}
recalc(t);
return t;
}
Treap insert(Treap t, int x) {
Treap[] a = split(t, x);
a[0] = merge(a[0], new Treap(x));
return merge(a[0], a[1]);
}
int query(Treap t, int x) {
Treap[] a = split(t, x);
int res = getSz(a[0]);
t = merge(a[0], a[1]);
return res;
}
void solve() throws IOException {
int n = nextInt();
Map<Integer, Treap> ins = new HashMap<>(n);
Map<Integer, Treap> del = new HashMap<>(n);
for (int i = 0; i < n; i++) {
int a = nextInt();
int t = nextInt();
int x = nextInt();
if (a == 1) {
ins.compute(x, (k, v) -> insert(v, t));
} else if (a == 2) {
del.compute(x, (k, v) -> insert(v, t));
} else {
println(query(ins.get(x), t) - query(del.get(x), t));
}
}
}
BufferedReader in;
StringTokenizer stok;
Main() {
super(System.out);
in = new BufferedReader(new InputStreamReader(System.in));
}
Main(String fileIn, String fileOut) throws IOException {
super(fileOut);
in = new BufferedReader(new FileReader(fileIn));
}
public static void main(String[] args) throws IOException {
Main main;
if ("_std".equals(IO)) {
main = new Main();
} else if ("_iotxt".equals(IO)) {
main = new Main("input.txt", "output.txt");
} else {
main = new Main(IO + ".in", IO + ".out");
}
main.solve();
main.close();
}
String next() throws IOException {
while (stok == null || !stok.hasMoreTokens()) {
String s = in.readLine();
if (s == null) {
return null;
}
stok = new StringTokenizer(s);
}
return stok.nextToken();
}
int nextInt() throws IOException {
return Integer.parseInt(next());
}
long nextLong() throws IOException {
return Long.parseLong(next());
}
double nextDouble() throws IOException {
return Double.parseDouble(next());
}
int[] nextIntArray(int len) throws IOException {
int[] a = new int[len];
for (int i = 0; i < len; i++) {
a[i] = nextInt();
}
return a;
}
int[] nextIntArraySorted(int len) throws IOException {
int[] a = nextIntArray(len);
shuffle(a);
Arrays.sort(a);
return a;
}
void shuffle(int[] a) {
for (int i = 1; i < a.length; i++) {
int x = rand.nextInt(i + 1);
int _ = a[i];
a[i] = a[x];
a[x] = _;
}
}
void shuffleAndSort(int[] a) {
shuffle(a);
Arrays.sort(a);
}
boolean nextPermutation(int[] p) {
for (int a = p.length - 2; a >= 0; --a) {
if (p[a] < p[a + 1])
for (int b = p.length - 1; ; --b)
if (p[b] > p[a]) {
int t = p[a];
p[a] = p[b];
p[b] = t;
for (++a, b = p.length - 1; a < b; ++a, --b) {
t = p[a];
p[a] = p[b];
p[b] = t;
}
return true;
}
}
return false;
}
<T> List<T>[] createAdjacencyList(int n) {
List<T>[] res = new List[n];
for (int i = 0; i < n; i++) {
res[i] = new ArrayList<>();
}
return res;
}
void println(Object... a) {
for (int i = 0; i < a.length; i++) {
if (i != 0) {
print(" ");
}
print(a[i]);
}
println();
}
}
|
Zombies seem to have become much more intelligent lately – a few have somehow wandered into the base through the automatic gate. Heidi has had to beef up security, and a new gate has been installed. Unfortunately, now the questions being asked are more complicated, and even humans have trouble answering them. Can you still program the robot army to do this reliably?
The new questions are of the following form: a grayscale photograph has been divided into several horizontal pieces, which have been arbitrarily rearranged. The task is to assemble the original image back from these pieces (somewhat like in a jigsaw puzzle). To further delay the zombies, significant Gaussian-distributed noise has been added to the image.
Input
The input format is the same as in the previous version, except that the first line of every question now contains three space-separated numbers h, w and k (1 ≤ h, w ≤ 600, 2 ≤ k ≤ 16) – the height (number of rows) and width (number of columns) of the photograph and the number of pieces, respectively. The number of pieces evenly divides the height, and each piece is of the same height h / k.
Again, there is only one input file to be processed, and the same resources are provided to you as in the previous version (except that now you are given all input images in .bmp format, rather than the first 50).
Output
Your program should print q lines. The i-th line should contain your answer for the i-th question: a space-separated sequence of k numbers π1, π2, ..., πk such that:
* π is a permutation of {1, 2, ..., k}, that is, each number from 1 to k appears exactly once in π,
* for each j = 1, ..., k, πj is the position (index), in the original image, of the piece which is at position j in the input image. (See the illustration below for clarity.)
<image>
The second image from the test set. If the three pieces in the original image are numbered 1, 2, 3 from top to bottom, then the numbering in the image on the right should be 2, 3, 1. The correct answer for this image is thus 2 3 1.
Again, your answers will be accepted if they conform to this format and if at least 75% of them are correct.
Again, you may process the input locally and submit just your precomputed answers (i.e., a program which just prints your output for the input file all.in).
Note
The link to download all the necessary materials is http://assets.codeforces.com/files/690/medium_contestant_package.zip
|
#include <bits/stdc++.h>
int main() {
printf(
"2 1\n2 3 1\n4 3 2 1\n1 3 4 2 5\n1 6 11 3 10 9 15 12 7 13 2 5 4 14 8\n5 "
"1 3 11 10 7 6 9 13 15 12 4 14 2 8\n9 7 2 5 1 10 8 3 4 6\n2 1 4 3\n4 12 "
"8 2 9 14 5 7 1 6 10 13 15 3 11\n11 5 6 8 10 12 7 2 1 4 9 3 13 14 15\n11 "
"7 8 4 5 15 13 14 3 9 12 2 1 10 6\n12 7 11 4 10 2 5 14 13 1 6 3 9 8 15 "
"16\n3 2 1\n4 2 1 3 5\n1 8 11 15 3 2 7 16 13 4 6 10 9 12 5 14\n9 8 6 13 "
"11 10 2 7 14 12 5 4 15 3 1\n2 15 16 10 8 5 9 3 11 7 1 14 12 4 6 13\n15 "
"5 2 14 3 13 1 7 12 8 4 10 6 11 9\n9 7 3 14 2 12 13 5 1 15 11 10 8 4 "
"6\n9 7 13 10 15 16 5 3 6 1 2 11 8 4 14 12\n6 13 2 11 5 10 3 14 9 1 12 8 "
"16 4 15 7 \n2 6 15 13 12 7 4 9 16 11 10 1 5 8 3 14 \n3 2 6 14 7 12 10 9 "
"5 4 8 15 11 13 1 \n3 11 4 5 14 10 16 9 8 6 7 13 12 1 15 2 \n4 3 11 9 8 "
"16 6 15 2 13 7 14 10 1 12 5 \n1 12 9 7 6 5 2 13 14 10 15 8 11 4 3 \n2 1 "
"3 \n2 1 \n1 3 2 6 4 8 7 5 \n14 7 8 4 2 9 13 6 1 5 11 15 16 10 3 12 \n2 "
"7 4 3 6 5 1 8 \n13 7 6 14 12 15 3 5 1 9 8 10 4 11 2 \n11 2 15 5 14 3 9 "
"10 7 1 12 13 8 6 4 \n4 2 3 1 \n16 13 11 14 9 2 15 3 1 5 6 7 12 8 4 10 "
"\n3 1 4 9 16 15 7 10 6 13 5 11 2 14 12 8 \n9 11 16 15 5 6 8 2 1 7 14 3 "
"10 4 13 12 \n3 1 6 5 2 4 \n14 8 2 10 6 16 9 7 15 4 1 3 11 13 5 12 \n5 "
"11 13 12 6 14 10 15 8 7 1 4 3 2 9 \n5 7 3 10 6 12 8 4 11 2 1 9 \n2 1 "
"\n13 14 8 6 4 7 5 10 3 11 2 9 15 12 1 \n2 15 11 13 12 5 3 4 9 8 14 6 10 "
"1 7 \n3 1 4 2 \n2 12 15 1 3 6 16 11 4 10 9 14 5 7 13 8 \n3 1 2 \n4 10 "
"16 13 11 14 8 6 15 7 9 3 1 2 12 5 \n1 4 9 8 15 6 2 11 13 3 7 12 5 14 10 "
"\n6 3 14 15 11 10 7 2 5 16 4 13 8 1 9 12 \n5 7 11 2 10 15 1 9 3 8 14 13 "
"16 12 4 6 \n16 1 5 6 7 15 2 12 8 11 10 14 13 3 9 4 \n6 5 2 10 12 8 4 13 "
"9 11 1 15 3 14 7 \n12 13 9 1 3 11 4 8 14 15 10 7 16 5 6 2 \n4 2 3 1 \n4 "
"15 9 12 6 16 5 1 10 14 7 11 8 2 3 13 \n1 4 2 6 3 5 \n14 11 8 7 2 15 5 6 "
"4 10 1 13 3 9 12 \n10 8 2 11 15 5 1 13 16 12 14 9 6 4 3 7 \n8 2 16 11 9 "
"12 15 6 13 7 4 5 14 1 10 3 \n3 9 10 13 6 16 5 4 8 7 12 11 1 15 14 2 \n3 "
"1 2 12 6 14 5 4 9 15 8 7 13 11 10 \n6 7 3 2 5 8 1 9 10 4 \n16 15 12 10 "
"3 11 1 14 2 8 4 5 6 13 7 9 \n8 1 13 15 7 10 5 9 3 2 6 4 12 11 14 \n12 6 "
"11 14 1 5 2 8 10 16 15 7 3 9 4 13 \n3 2 1 \n4 7 8 2 1 6 5 3 \n2 1 \n10 "
"3 7 6 15 4 1 5 9 2 8 13 12 14 11 16 \n15 9 2 8 1 4 14 13 5 3 12 6 7 11 "
"10 \n4 1 5 2 3 \n3 8 1 11 9 2 6 7 5 4 10 12 \n9 2 10 13 16 6 1 12 4 7 3 "
"14 11 8 15 5 \n1 11 14 4 10 13 15 16 7 3 2 9 12 8 6 5 \n11 16 14 3 6 12 "
"4 1 2 8 7 13 10 9 15 5 \n15 14 4 6 9 5 3 2 13 12 10 11 7 1 8 \n1 16 5 2 "
"10 6 7 8 4 15 11 12 14 13 3 9 \n4 3 5 14 6 8 16 10 9 12 2 11 13 15 7 1 "
"\n1 4 5 10 9 6 8 3 2 7 \n7 6 15 5 12 13 2 4 3 14 11 1 10 8 9 \n2 14 9 3 "
"8 7 6 15 10 11 16 5 12 13 1 4 \n2 5 9 1 11 4 16 6 8 7 12 3 13 10 15 14 "
"\n3 5 8 14 1 9 7 4 10 6 11 15 2 16 12 13 \n15 14 10 13 1 5 2 12 4 11 8 "
"9 6 7 3 16 \n6 1 4 16 2 9 8 5 12 11 10 13 3 7 14 15 \n16 14 9 8 4 1 7 2 "
"12 10 3 5 11 6 15 13 \n6 1 5 2 4 3 \n3 10 4 5 9 6 1 2 7 8 \n8 2 15 10 "
"12 5 14 11 4 1 3 13 7 9 6 \n5 13 12 7 9 1 10 4 15 8 3 2 14 6 11 \n2 3 6 "
"1 4 5 \n1 15 13 6 7 11 12 3 14 4 8 9 2 10 5 \n14 7 8 6 12 13 16 15 3 10 "
"11 9 1 4 5 2 \n7 2 4 13 9 1 15 8 12 11 6 3 5 14 10 \n3 4 5 6 14 8 9 10 "
"15 12 11 13 7 1 2 \n4 11 5 12 8 14 10 7 3 9 16 13 15 1 6 2 \n2 6 3 1 4 "
"5 \n6 5 7 9 2 8 3 1 4 10 \n14 7 15 11 1 4 3 13 5 10 6 9 8 2 12 \n15 14 "
"5 3 7 4 1 9 11 6 10 2 12 13 8 \n16 14 3 7 13 2 6 1 10 12 9 4 5 8 11 15 "
"\n3 8 5 10 12 11 4 6 7 9 2 1 \n11 3 5 4 12 8 1 2 6 7 9 10 \n3 11 6 16 "
"13 15 5 2 12 7 14 8 10 9 4 1 \n6 5 1 4 3 2 \n1 4 2 10 12 11 9 5 6 13 3 "
"14 15 8 7 \n7 13 10 5 2 12 6 3 8 4 15 11 1 9 14 \n12 5 7 8 1 9 10 15 6 "
"4 14 13 3 2 11 \n2 5 3 9 13 4 7 12 6 14 10 11 15 1 8 \n5 4 2 6 1 3 \n4 "
"8 9 1 5 13 11 7 3 12 2 6 14 15 10 \n2 1 \n11 5 7 9 15 2 8 14 3 13 10 12 "
"1 6 4 \n5 14 15 4 13 6 8 10 7 12 2 11 16 3 9 1 \n12 8 7 2 3 9 15 5 11 6 "
"4 14 13 1 10 \n14 7 11 13 2 3 12 1 10 9 5 8 4 15 6 \n6 4 3 5 1 2 7 8 "
"\n8 16 4 11 13 5 2 14 9 6 3 15 12 1 10 7 \n3 5 1 8 2 9 7 12 4 11 10 6 "
"\n2 5 4 9 11 12 13 6 3 1 15 10 8 7 14 \n13 6 8 11 12 15 1 2 10 9 7 14 3 "
"5 4 \n2 11 15 12 5 8 9 1 14 10 4 3 6 7 13 \n5 8 16 3 10 6 14 7 1 15 12 "
"9 13 2 11 4 \n10 12 1 16 11 4 2 15 6 7 13 14 5 3 8 9 \n1 2 5 3 4 \n6 5 "
"1 4 2 3 \n8 4 7 5 6 1 2 3 \n4 2 3 1 \n4 5 6 8 3 1 2 9 10 7 \n1 8 10 12 "
"14 13 16 11 9 4 3 2 7 5 15 6 \n2 1 \n13 7 15 14 10 1 8 5 6 11 9 2 3 12 "
"4 \n15 13 8 2 7 11 6 5 14 9 10 12 3 4 1 \n2 1 \n8 4 5 10 6 1 14 13 12 9 "
"2 3 11 15 7 \n10 3 6 8 5 11 14 16 7 1 9 2 13 4 15 12 \n7 5 6 2 4 1 8 3 "
"\n10 2 7 9 11 6 1 8 3 5 12 4 \n4 2 3 1 \n3 13 9 7 11 15 14 10 5 2 16 12 "
"4 8 1 6 \n3 8 1 6 15 7 5 13 9 12 11 4 10 2 14 \n3 8 15 16 14 9 4 1 13 "
"12 2 5 7 6 10 11 \n4 3 1 2 5 \n3 4 11 7 15 1 13 10 9 14 16 12 5 8 2 6 "
"\n4 9 14 7 12 3 10 5 13 1 2 11 8 6 15 \n10 9 16 13 7 3 12 4 15 8 5 1 11 "
"2 6 14 \n2 1 \n14 4 1 2 13 6 3 5 12 10 7 9 15 8 11 \n3 4 1 6 2 5 \n5 10 "
"4 6 2 8 11 9 1 7 3 13 15 14 12 \n2 4 1 3 \n16 14 12 11 7 3 2 6 1 9 4 10 "
"15 13 5 8 \n13 15 1 4 16 12 2 11 5 8 10 9 6 14 7 3 \n1 3 2 4 \n8 14 2 3 "
"1 13 10 6 9 7 11 5 15 4 12 \n");
return 0;
}
|
ZS the Coder has drawn an undirected graph of n vertices numbered from 0 to n - 1 and m edges between them. Each edge of the graph is weighted, each weight is a positive integer.
The next day, ZS the Coder realized that some of the weights were erased! So he wants to reassign positive integer weight to each of the edges which weights were erased, so that the length of the shortest path between vertices s and t in the resulting graph is exactly L. Can you help him?
Input
The first line contains five integers n, m, L, s, t (2 ≤ n ≤ 1000, 1 ≤ m ≤ 10 000, 1 ≤ L ≤ 109, 0 ≤ s, t ≤ n - 1, s ≠ t) — the number of vertices, number of edges, the desired length of shortest path, starting vertex and ending vertex respectively.
Then, m lines describing the edges of the graph follow. i-th of them contains three integers, ui, vi, wi (0 ≤ ui, vi ≤ n - 1, ui ≠ vi, 0 ≤ wi ≤ 109). ui and vi denote the endpoints of the edge and wi denotes its weight. If wi is equal to 0 then the weight of the corresponding edge was erased.
It is guaranteed that there is at most one edge between any pair of vertices.
Output
Print "NO" (without quotes) in the only line if it's not possible to assign the weights in a required way.
Otherwise, print "YES" in the first line. Next m lines should contain the edges of the resulting graph, with weights assigned to edges which weights were erased. i-th of them should contain three integers ui, vi and wi, denoting an edge between vertices ui and vi of weight wi. The edges of the new graph must coincide with the ones in the graph from the input. The weights that were not erased must remain unchanged whereas the new weights can be any positive integer not exceeding 1018.
The order of the edges in the output doesn't matter. The length of the shortest path between s and t must be equal to L.
If there are multiple solutions, print any of them.
Examples
Input
5 5 13 0 4
0 1 5
2 1 2
3 2 3
1 4 0
4 3 4
Output
YES
0 1 5
2 1 2
3 2 3
1 4 8
4 3 4
Input
2 1 123456789 0 1
0 1 0
Output
YES
0 1 123456789
Input
2 1 999999999 1 0
0 1 1000000000
Output
NO
Note
Here's how the graph in the first sample case looks like :
<image>
In the first sample case, there is only one missing edge weight. Placing the weight of 8 gives a shortest path from 0 to 4 of length 13.
In the second sample case, there is only a single edge. Clearly, the only way is to replace the missing weight with 123456789.
In the last sample case, there is no weights to assign but the length of the shortest path doesn't match the required value, so the answer is "NO".
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e3 + 10;
const int mmax = 1e4 + 10;
int n, m, length, node1, node2, inf;
pair<int, int> edge[mmax];
int weight[mmax];
vector<int> m_edges, r_edges;
vector<pair<int, int> > g[nmax];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
void read_data() {
scanf("%d %d", &n, &m);
scanf("%d %d %d", &length, &node1, &node2);
node1++;
node2++;
inf = length;
for (int i = 1; i <= m; ++i) {
int x, y, w;
scanf("%d %d %d", &x, &y, &w);
x++;
y++;
g[x].push_back({y, i});
g[y].push_back({x, i});
edge[i] = {x, y};
weight[i] = w;
if (!w)
m_edges.push_back(i);
else
r_edges.push_back(i);
}
}
void print_answer(int ok, int pos, int val) {
if (!ok) {
printf("NO\n");
exit(0);
}
printf("YES\n");
pos--;
for (auto &it : r_edges)
printf("%d %d %d\n", edge[it].first - 1, edge[it].second - 1, weight[it]);
for (int i = 0; i < pos; ++i)
printf("%d %d 1\n", edge[m_edges[i]].first - 1,
edge[m_edges[i]].second - 1);
if (pos >= 0)
printf("%d %d %d\n", edge[m_edges[pos]].first - 1,
edge[m_edges[pos]].second - 1, val);
for (int i = pos + 1; i < m_edges.size(); ++i)
printf("%d %d %d\n", edge[m_edges[i]].first - 1,
edge[m_edges[i]].second - 1, inf);
exit(0);
}
long long shortest_path(int pos, int val) {
pos--;
long long cost[nmax];
bool used[nmax];
for (int i = 1; i <= n; ++i) cost[i] = 1e18, used[i] = 0;
cost[node1] = 0LL;
pq.push({cost[node1], node1});
while (pq.size()) {
int node = pq.top().second;
pq.pop();
if (used[node]) continue;
for (auto &it : g[node]) {
int act_cost = weight[it.second];
if (act_cost == 0) {
if (pos == -1)
act_cost = inf;
else if (it.second < m_edges[pos])
act_cost = 1;
else if (it.second == m_edges[pos])
act_cost = val;
else
act_cost = inf;
}
if (cost[it.first] <= cost[node] + act_cost) continue;
cost[it.first] = cost[node] + act_cost;
pq.push({cost[it.first], it.first});
}
used[node] = 1;
}
return cost[node2];
}
int find_pos(int low, int high) {
int mid, ret = 0;
while (low <= high) {
int mid = (low + high) >> 1;
if (shortest_path(mid, 1) <= 1LL * length)
ret = mid, high = mid - 1;
else
low = mid + 1;
}
return ret;
}
int find_val(int pos, int low, int high) {
int mid, ret = 0;
while (low <= high) {
int mid = (low + high) >> 1;
if (shortest_path(pos, mid) < 1LL * length)
ret = mid, low = mid + 1;
else
high = mid - 1;
}
return ret + 1;
}
void solve() {
if (m_edges.empty()) print_answer(shortest_path(0, 0) == 1LL * length, 0, 0);
if (shortest_path((int)m_edges.size(), 1) > 1LL * length ||
shortest_path(0, 0) < 1LL * length)
print_answer(0, 0, 0);
int pos = find_pos(1, (int)m_edges.size());
if (pos == 0) print_answer(0, 0, 0);
int val = find_val(pos, 1, inf);
print_answer(1, pos, val);
}
int main() {
read_data();
solve();
return 0;
}
|
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
|
#include <bits/stdc++.h>
using namespace std;
bool check_prime(int n) {
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
int check_ps(long long n) {
for (int i = n; i >= 2; i--) {
bool d = check_prime(i);
if (d) return i;
}
}
int check_div(long long n) {
int ans = 0;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) ans = i;
}
return ans;
}
int main() {
long long n, a;
while (cin >> n) {
if (n == 2 || check_prime(n))
cout << 1 << endl;
else if (n % 2 == 0)
cout << 2 << endl;
else {
int a = check_ps(n);
a = n - a;
bool d = check_prime(a);
if (d)
cout << 2 << endl;
else {
cout << 3 << endl;
}
}
}
}
|
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 ≤ n ≤ 50), and m is the number of indexes in the big array (1 ≤ m ≤ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 ≤ l ≤ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
public class BigMaximumSum {
public static int n, m;
public static class Node {
long ml, mr, m;
boolean rightAll;
long all;
public Node(long ml,long mr,long m,boolean rightAll,long all)
{
this.ml=ml;
this.mr=mr;
this.m=m;
this.rightAll=rightAll;
this.all=all;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "( "+ml+" "+m+" "+mr+" "+rightAll+" )";
}
}
public static Node nodes[];
public static long getMax(int a[]) {
int max_ending_here = 0;
int max_so_far = 0;
for (int i = 0; i < a.length; i++) {
max_ending_here = Math.max(0, max_ending_here + a[i]);
max_so_far = Math.max(max_so_far, max_ending_here);
}
return max_so_far;
}
public static long getMaxLeft(int a[])
{
int max=-100000;
int sum=0;
for(int i=0;i<a.length;i++)
{
sum+=a[i];
max=Math.max(sum, max);
}
return max;
}
public static long getMaxRight(int a[])
{
int max=-100000;
int sum=0;
for(int i=a.length-1;i>=0;i--)
{
sum+=a[i];
max=Math.max(sum, max);
}
return max;
}
public static Node getNode(int a[]) {
boolean found = false;
for (int i = 0; i < a.length && !found; i++)
if (a[i] >= 0)
found = true;
long max = -100000;
// System.out.println(found);
if (found)
max = getMax(a);
else
for(int i=0;i<a.length;i++)
max=Math.max(a[i], max);
long ml=getMaxLeft( a);
long mr=getMaxRight(a);
long sum=0;
for(int i=0;i<a.length;i++)
sum+=a[i];
// System.out.println(ml+" "+mr+" "+max+" "+sum);
return new Node(ml, mr, max,sum==mr,sum);
}
public static Node concatinate(Node n1,Node n2)
{
long max=Math.max(n1.m, n2.m);
max=Math.max(max, n1.mr+n2.ml);
long nr=n2.mr;
if(n2.rightAll)
nr=Math.max(nr, n2.mr+n1.mr);
nr=Math.max(nr, n1.all+n2.all);
nr=Math.max(nr, n2.all+n1.mr);
max=Math.max(nr, max);
return new Node(n1.ml, nr, max, false,n1.all+n2.all);
}
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(
System.in));
String st[] = reader.readLine().split(" ");
n = Integer.parseInt(st[0]);
m = Integer.parseInt(st[1]);
nodes = new Node[n];
int a[];
for (int i = 0; i < n; i++) {
st = reader.readLine().split(" ");
a = new int[st.length - 1];
for (int j = 1; j < st.length; j++)
a[j - 1] = Integer.parseInt(st[j]);
nodes[i] = getNode(a);
// System.out.println(nodes[i]);
}
st=reader.readLine().split(" ");
int num=0;
Node prevn=nodes[Integer.parseInt(st[0])-1];
for(int i=1;i<m;i++)
{
num=Integer.parseInt(st[i])-1;
prevn=concatinate(prevn, nodes[num]);
}
System.out.println(prevn.m);
}
}
|
Andryusha goes through a park each day. The squares and paths between them look boring to Andryusha, so he decided to decorate them.
The park consists of n squares connected with (n - 1) bidirectional paths in such a way that any square is reachable from any other using these paths. Andryusha decided to hang a colored balloon at each of the squares. The baloons' colors are described by positive integers, starting from 1. In order to make the park varicolored, Andryusha wants to choose the colors in a special way. More precisely, he wants to use such colors that if a, b and c are distinct squares that a and b have a direct path between them, and b and c have a direct path between them, then balloon colors on these three squares are distinct.
Andryusha wants to use as little different colors as possible. Help him to choose the colors!
Input
The first line contains single integer n (3 ≤ n ≤ 2·105) — the number of squares in the park.
Each of the next (n - 1) lines contains two integers x and y (1 ≤ x, y ≤ n) — the indices of two squares directly connected by a path.
It is guaranteed that any square is reachable from any other using the paths.
Output
In the first line print single integer k — the minimum number of colors Andryusha has to use.
In the second line print n integers, the i-th of them should be equal to the balloon color on the i-th square. Each of these numbers should be within range from 1 to k.
Examples
Input
3
2 3
1 3
Output
3
1 3 2
Input
5
2 3
5 3
4 3
1 3
Output
5
1 3 2 5 4
Input
5
2 1
3 2
4 3
5 4
Output
3
1 2 3 1 2
Note
In the first sample the park consists of three squares: 1 → 3 → 2. Thus, the balloon colors have to be distinct.
<image> Illustration for the first sample.
In the second example there are following triples of consequently connected squares:
* 1 → 3 → 2
* 1 → 3 → 4
* 1 → 3 → 5
* 2 → 3 → 4
* 2 → 3 → 5
* 4 → 3 → 5
We can see that each pair of squares is encountered in some triple, so all colors have to be distinct. <image> Illustration for the second sample.
In the third example there are following triples:
* 1 → 2 → 3
* 2 → 3 → 4
* 3 → 4 → 5
We can see that one or two colors is not enough, but there is an answer that uses three colors only. <image> Illustration for the third sample.
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 * 4 + 100;
vector<int> vec[maxn];
queue<int> q;
int n, c[maxn], fa[maxn], maxe;
bool check[maxn];
void bfs() {
check[1] = 1;
q.push(1);
while (!q.empty()) {
int cur = q.front();
q.pop();
int cnt = 0;
for (auto nei : vec[cur])
if (!check[nei]) {
fa[nei] = cur;
q.push(nei);
check[nei] = 1;
while (cnt == c[cur] || cnt == c[fa[cur]]) {
cnt++;
cnt %= maxe;
}
c[nei] = cnt++;
cnt %= maxe;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int f, g;
cin >> f >> g;
vec[f].push_back(g);
vec[g].push_back(f);
}
maxe = 0;
for (int i = 1; i <= n; i++) maxe = max(maxe, (int)vec[i].size() + 1);
cout << maxe << endl;
bfs();
for (int i = 1; i <= n; i++) cout << c[i] + 1 << " ";
}
|
You are given an array a consisting of positive integers and q queries to this array. There are two types of queries:
* 1 l r x — for each index i such that l ≤ i ≤ r set ai = x.
* 2 l r — find the minimum among such ai that l ≤ i ≤ r.
We decided that this problem is too easy. So the array a is given in a compressed form: there is an array b consisting of n elements and a number k in the input, and before all queries a is equal to the concatenation of k arrays b (so the size of a is n·k).
Input
The first line contains two integers n and k (1 ≤ n ≤ 105, 1 ≤ k ≤ 104).
The second line contains n integers — elements of the array b (1 ≤ bi ≤ 109).
The third line contains one integer q (1 ≤ q ≤ 105).
Then q lines follow, each representing a query. Each query is given either as 1 l r x — set all elements in the segment from l till r (including borders) to x (1 ≤ l ≤ r ≤ n·k, 1 ≤ x ≤ 109) or as 2 l r — find the minimum among all elements in the segment from l till r (1 ≤ l ≤ r ≤ n·k).
Output
For each query of type 2 print the answer to this query — the minimum on the corresponding segment.
Examples
Input
3 1
1 2 3
3
2 1 3
1 1 2 4
2 1 3
Output
1
3
Input
3 2
1 2 3
5
2 4 4
1 4 4 5
2 4 4
1 1 6 1
2 6 6
Output
1
5
1
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Iterator;
import java.io.BufferedWriter;
import java.util.Collection;
import java.util.Random;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author Jialin Ouyang ([email protected])
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
QuickScanner in = new QuickScanner(inputStream);
QuickWriter out = new QuickWriter(outputStream);
TaskG solver = new TaskG();
solver.solve(1, in, out);
out.close();
}
static class TaskG {
QuickWriter out;
SimpleIT itree;
int globalMin;
int[] oldMinValue;
IntMinimumRMQ rmq;
int[] left;
int[] right;
int valueCnt;
int repeatCnt;
int[] value;
int queryCnt;
int[] oldLeft;
int[] oldRight;
int[] op;
int[] setValue;
IntArrayList disIdx;
public void solve(int testNumber, QuickScanner in, QuickWriter out) {
this.out = out;
input(in);
discrete();
rmq();
oldMinValue();
calc();
}
void calc() {
itree = new SimpleIT(oldMinValue.length);
itree.init(oldMinValue.length);
//System.out.printf("=====start=====\n%s\n", itree.toString());
for (int queryIdx = 0; queryIdx < queryCnt; ++queryIdx) {
if (op[queryIdx] == 1) {
itree.update(left[queryIdx], right[queryIdx], setValue[queryIdx]);
} else {
out.println(itree.calc(left[queryIdx], right[queryIdx]));
}
//System.out.printf("=====%d=====\n%s\n", queryIdx, itree.toString());
}
}
void oldMinValue() {
globalMin = IntArrayUtils.min(value, 0, valueCnt);
oldMinValue = new int[disIdx.size - 1];
for (int i = 1; i < disIdx.size; ++i) {
int left = disIdx.get(i - 1);
int right = disIdx.get(i);
int res;
if (right - left >= valueCnt) {
res = globalMin;
} else {
left %= valueCnt;
right %= valueCnt;
res = left < right ? rmq.calc(left, right) : rmq.calc(left, right + valueCnt);
}
oldMinValue[i - 1] = res;
}
}
void rmq() {
rmq = new IntMinimumRMQ(valueCnt << 1);
rmq.init(valueCnt << 1, value);
}
void discrete() {
disIdx.sortAndUnique();
left = new int[queryCnt];
right = new int[queryCnt];
for (int i = 0; i < queryCnt; ++i) {
left[i] = disIdx.lowerBound(oldLeft[i]);
right[i] = disIdx.lowerBound(oldRight[i]);
}
}
void input(QuickScanner in) {
valueCnt = in.nextInt();
repeatCnt = in.nextInt();
value = new int[valueCnt << 1];
for (int i = 0, j = valueCnt; i < valueCnt; ++i, ++j) {
value[i] = in.nextInt();
value[j] = value[i];
}
queryCnt = in.nextInt();
op = new int[queryCnt];
oldLeft = new int[queryCnt];
oldRight = new int[queryCnt];
setValue = new int[queryCnt];
disIdx = new IntArrayList(queryCnt << 1);
for (int i = 0; i < queryCnt; ++i) {
op[i] = in.nextInt();
oldLeft[i] = in.nextInt() - 1;
oldRight[i] = in.nextInt();
disIdx.add(oldLeft[i]);
disIdx.add(oldRight[i]);
if (op[i] == 1) {
setValue[i] = in.nextInt();
}
}
}
class SimpleIT extends AbstractSimpleIntervalTree {
int[] minValue;
boolean[] overwritten;
int[] overwriteValue;
int res;
public SimpleIT(int leafCapacity) {
super(leafCapacity);
}
public void createSubclass(int nodeCapacity) {
minValue = new int[nodeCapacity];
overwritten = new boolean[nodeCapacity];
overwriteValue = new int[nodeCapacity];
}
public void initLazyPropagation(int nodeCapacity) {
Arrays.fill(overwritten, 0, nodeCapacity, false);
}
public void initLeaf(int nodeIdx, int idx) {
minValue[nodeIdx] = oldMinValue[idx];
}
public void calcNonLeafNode(int nodeIdx) {
if (overwritten[nodeIdx]) {
minValue[nodeIdx] = overwriteValue[nodeIdx];
} else {
minValue[nodeIdx] = Math.min(minValue[nodeIdx << 1], minValue[(nodeIdx << 1) | 1]);
}
}
public void calcAppend(int nodeIdx) {
res = Math.min(res, minValue[nodeIdx]);
}
public void pushLazyPropagation(int fromNodeIdx, int toNodeIdx) {
//if (fromNodeIdx == 0) System.out.printf("push %d -> %d\n", fromNodeIdx, toNodeIdx);
if (overwritten[fromNodeIdx]) {
overwritten[toNodeIdx] = true;
overwriteValue[toNodeIdx] = overwriteValue[fromNodeIdx];
minValue[toNodeIdx] = overwriteValue[toNodeIdx];
}
}
public void clearLazyPropagation(int nodeIdx) {
overwritten[nodeIdx] = false;
}
public String valueToString(int nodeIdx) {
return String.format("min:%d", minValue[nodeIdx]);
}
public String lazyPropagationToString(int nodeIdx) {
return "set:" + (overwritten[nodeIdx] ? overwriteValue[nodeIdx] : "X");
}
public void update(int lower, int upper, int updateValue) {
overwritten[0] = true;
overwriteValue[0] = updateValue;
updateRange(lower, upper);
}
public int calc(int lower, int upper) {
res = Integer.MAX_VALUE;
calcRange(lower, upper);
return res;
}
}
}
static class IntArrayUtils {
private static final Random RANDOM = new Random(1000000007);
public static int min(int[] values, int fromIdx, int toIdx) {
int res = Integer.MAX_VALUE;
for (int i = fromIdx; i < toIdx; ++i) {
if (res > values[i]) res = values[i];
}
return res;
}
public static int unique(int[] values, int fromIdx, int toIdx) {
if (fromIdx == toIdx) return 0;
int res = 1;
for (int i = fromIdx + 1; i < toIdx; ++i) {
if (values[i - 1] != values[i]) {
values[fromIdx + res++] = values[i];
}
}
return res;
}
public static void sort(int[] values, int fromIdx, int toIdx) {
shuffle(values, fromIdx, toIdx);
Arrays.sort(values, fromIdx, toIdx);
}
public static int lowerBound(int[] values, int fromIdx, int toIdx, int value) {
int res = toIdx;
for (int lower = fromIdx, upper = toIdx - 1; lower <= upper; ) {
int medium = (lower + upper) >> 1;
if (value <= values[medium]) {
res = medium;
upper = medium - 1;
} else {
lower = medium + 1;
}
}
return res;
}
public static void swap(int[] values, int uIdx, int vIdx) {
if (uIdx == vIdx) return;
values[uIdx] ^= values[vIdx];
values[vIdx] ^= values[uIdx];
values[uIdx] ^= values[vIdx];
}
public static void shuffle(int[] values, int fromIdx, int toIdx) {
for (int i = toIdx - fromIdx - 1; i > 0; --i) {
swap(values, i + fromIdx, RANDOM.nextInt(i + 1) + fromIdx);
}
}
public static String toString(int[] values, int fromIdx, int toIdx) {
StringBuilder sb = new StringBuilder("[");
for (int i = fromIdx; i < toIdx; ++i) {
if (i != fromIdx) sb.append(", ");
sb.append(values[i]);
}
return sb.append("]").toString();
}
}
static class QuickWriter {
private final PrintWriter writer;
public QuickWriter(OutputStream outputStream) {
this.writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public QuickWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void print(Object... objects) {
for (int i = 0; i < objects.length; ++i) {
if (i > 0) {
writer.print(' ');
}
writer.print(objects[i]);
}
}
public void println(Object... objects) {
print(objects);
writer.print('\n');
}
public void close() {
writer.close();
}
}
static class IntMinimumRMQ extends AbstractRMQ {
private int[][] rmq;
private int[][] rmqIdx;
private int[] initValues;
private int resIdx;
public IntMinimumRMQ(int capacity) {
super(capacity);
}
public void createArrays(int capacityHighBit) {
rmq = new int[capacityHighBit][];
rmqIdx = new int[capacityHighBit][];
}
public void createArray(int bit, int capacity) {
rmq[bit] = new int[capacity];
rmqIdx[bit] = new int[capacity];
}
public void initSubclass(int n) {
for (int i = 0; i < n; ++i) {
rmq[0][i] = initValues[i];
rmqIdx[0][i] = i;
}
}
public void initMerge(int targetBit, int targetIdx, int sourceBit, int sourceIdx1, int sourceIdx2) {
if (rmq[sourceBit][sourceIdx1] <= rmq[sourceBit][sourceIdx2]) {
rmq[targetBit][targetIdx] = rmq[sourceBit][sourceIdx1];
rmqIdx[targetBit][targetIdx] = rmqIdx[sourceBit][sourceIdx1];
} else {
rmq[targetBit][targetIdx] = rmq[sourceBit][sourceIdx2];
rmqIdx[targetBit][targetIdx] = rmqIdx[sourceBit][sourceIdx2];
}
}
public void calcMerge(int bit, int x, int y) {
resIdx = rmq[bit][x] <= rmq[bit][y] ? rmqIdx[bit][x] : rmqIdx[bit][y];
}
public void init(int n, int[] initValues) {
this.initValues = initValues;
initInternal(n);
}
public int calc(int fromIdx, int toIdx) {
return rmq[0][calcIdx(fromIdx, toIdx)];
}
public int calcIdx(int fromIdx, int toIdx) {
calcInternal(fromIdx, toIdx);
return resIdx;
}
}
static abstract class AbstractSimpleIntervalTree {
public int[] lower;
public int[] upper;
private int n;
private int height;
private IntArrayList calcLeftIdx;
private IntArrayList calcRightIdx;
public abstract void createSubclass(int nodeCapacity);
public abstract void initLazyPropagation(int nodeCapacity);
public abstract void initLeaf(int nodeIdx, int idx);
public abstract void calcNonLeafNode(int nodeIdx);
public abstract void calcAppend(int nodeIdx);
public abstract void pushLazyPropagation(int fromNodeIdx, int toNodeIdx);
public abstract void clearLazyPropagation(int nodeIdx);
public abstract String valueToString(int nodeIdx);
public abstract String lazyPropagationToString(int nodeIdx);
public AbstractSimpleIntervalTree(int leafCapacity) {
calcLeftIdx = new IntArrayList();
calcRightIdx = new IntArrayList();
int leafCapacity2 = leafCapacity << 1;
lower = new int[leafCapacity2];
upper = new int[leafCapacity2];
createSubclass(leafCapacity2);
init(leafCapacity);
}
public void init(int n) {
this.n = n;
this.height = 32 - Integer.numberOfLeadingZeros(n);
initLazyPropagation(n << 1);
for (int i = 0; i < n; ++i) {
lower[n + i] = i;
upper[n + i] = i + 1;
initLeaf(n + i, i);
}
for (int i = n - 1; i > 0; --i) {
int left = i << 1, right = left | 1;
if (upper[left] == lower[right]) {
lower[i] = lower[left];
upper[i] = upper[right];
calcNonLeafNode(i);
} else {
lower[i] = n;
upper[i] = -1;
}
}
}
public void updateRange(int lower, int upper) {
pushInternal(lower);
pushInternal(upper - 1);
boolean toCalcLeft = false, toCalcRight = false;
for (lower += n, upper += n; lower < upper; lower >>= 1, upper >>= 1) {
if (toCalcLeft) calcNonLeafNode(lower - 1);
if (toCalcRight) calcNonLeafNode(upper);
if ((lower & 1) > 0) {
pushLazyPropagation(0, lower++);
toCalcLeft = true;
}
if ((upper & 1) > 0) {
pushLazyPropagation(0, --upper);
toCalcRight = true;
}
}
for (--lower; upper > 0; lower >>= 1, upper >>= 1) {
if (toCalcLeft) calcNonLeafNode(lower);
if (toCalcRight && (!toCalcLeft || lower != upper)) calcNonLeafNode(upper);
}
}
public void calcRange(int lower, int upper) {
pushInternal(lower);
pushInternal(upper - 1);
calcLeftIdx.clear();
calcRightIdx.clear();
for (lower += n, upper += n; lower < upper; lower >>= 1, upper >>= 1) {
if ((lower & 1) > 0) calcLeftIdx.add(lower++);
if ((upper & 1) > 0) calcRightIdx.add(--upper);
}
for (int i = 0; i < calcLeftIdx.size; ++i) {
int idx = calcLeftIdx.get(i);
calcAppend(idx);
}
for (int i = calcRightIdx.size - 1; i >= 0; --i) {
int idx = calcRightIdx.get(i);
calcAppend(idx);
}
}
public String toString() {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n << 1; ++i)
if (lower[i] < upper[i]) {
sb.append(String.format("@%d[%d,%d):%s", i, lower[i], upper[i], valueToString(i)));
if (lower[i] + 1 < upper[i]) sb.append(String.format(" | %s", lazyPropagationToString(i)));
if (i + 1 < n << 1) sb.append('\n');
}
return sb.toString();
}
private void pushInternal(int nodeIdx) {
for (int s = height, l = nodeIdx + n, r = l; s > 0; --s) {
for (int i = l >> s; i <= r >> s; ++i)
if (lower[i] < upper[i]) {
//if (i == 0) System.out.printf("pushInternal 0: nodeIdx(%d)\n", nodeIdx);
pushLazyPropagation(i, i << 1);
pushLazyPropagation(i, (i << 1) | 1);
clearLazyPropagation(i);
}
}
}
}
static class IntArrayList implements IntCollection, Iterable<Integer> {
private static final int[] EMPTY = {};
public int[] values;
public int size;
public IntArrayList() {
values = EMPTY;
clear();
}
public IntArrayList(int capacity) {
values = new int[IntUtils.nextPow2(capacity)];
clear();
}
public IntArrayList(Collection<Integer> collection) {
this(collection.size());
addAll(collection);
}
public void clear() {
size = 0;
}
public void add(int value) {
ensureCapacity(size + 1);
addInternal(value);
}
public void addAll(Collection<Integer> values) {
ensureCapacity(size + values.size());
for (int value : values) {
addInternal(value);
}
}
public int get(int idx) {
if (idx >= size) throw new ArrayIndexOutOfBoundsException();
return values[idx];
}
public void sort() {
IntArrayUtils.sort(values, 0, size);
}
public void unique() {
size = IntArrayUtils.unique(values, 0, size);
}
public void sortAndUnique() {
sort();
unique();
}
public int lowerBound(int value) {
return IntArrayUtils.lowerBound(values, 0, size, value);
}
public void ensureCapacity(int capacity) {
if (capacity <= values.length) return;
int[] newValues = new int[IntUtils.nextPow2(capacity)];
for (int i = 0; i < size; ++i) {
newValues[i] = values[i];
}
values = newValues;
}
public String toString() {
return IntArrayUtils.toString(values, 0, size);
}
public Iterator<Integer> iterator() {
return new Iterator<Integer>() {
private int i = 0;
public boolean hasNext() {
return i < size;
}
public Integer next() {
return values[i++];
}
};
}
private void addInternal(int value) {
values[size++] = value;
}
}
static abstract class AbstractRMQ {
public abstract void createArrays(int capacityHighBit);
public abstract void createArray(int bit, int capacity);
public abstract void initSubclass(int n);
public abstract void initMerge(int targetBit, int targetIdx, int sourceBit, int sourceIdx1, int sourceIdx2);
public abstract void calcMerge(int bit, int x, int y);
public AbstractRMQ(int capacity) {
int highBit = 32 - Integer.numberOfLeadingZeros(capacity);
createArrays(highBit);
for (int bit = 0; bit < highBit; ++bit) {
createArray(bit, capacity - (1 << bit) + 1);
}
}
protected void initInternal(int n) {
initSubclass(n);
for (int bitI = 1; 1 << bitI <= n; ++bitI) {
for (int i = n - (1 << bitI), j = i + (1 << (bitI - 1)); i >= 0; --i, --j) {
initMerge(bitI, i, bitI - 1, i, j);
}
}
}
protected void calcInternal(int fromIdx, int toIdx) {
int bit = 31 - Integer.numberOfLeadingZeros(toIdx - fromIdx);
calcMerge(bit, fromIdx, toIdx - (1 << bit));
}
}
static class QuickScanner {
private static final int BUFFER_SIZE = 1024;
private InputStream stream;
private byte[] buffer;
private int currentPosition;
private int numberOfChars;
public QuickScanner(InputStream stream) {
this.stream = stream;
this.buffer = new byte[BUFFER_SIZE];
this.currentPosition = 0;
this.numberOfChars = 0;
}
public int nextInt() {
int c = nextNonSpaceChar();
boolean positive = true;
if (c == '-') {
positive = false;
c = nextChar();
}
int res = 0;
do {
if (c < '0' || '9' < c) throw new RuntimeException();
res = res * 10 + c - '0';
c = nextChar();
} while (!isSpaceChar(c));
return positive ? res : -res;
}
public int nextNonSpaceChar() {
int res = nextChar();
for (; isSpaceChar(res) || res < 0; res = nextChar()) ;
return res;
}
public int nextChar() {
if (numberOfChars == -1) {
throw new RuntimeException();
}
if (currentPosition >= numberOfChars) {
currentPosition = 0;
try {
numberOfChars = stream.read(buffer);
} catch (Exception e) {
throw new RuntimeException(e);
}
if (numberOfChars <= 0) {
return -1;
}
}
return buffer[currentPosition++];
}
public boolean isSpaceChar(int c) {
return c == ' ' || c == '\t' || isEndOfLineChar(c);
}
public boolean isEndOfLineChar(int c) {
return c == '\n' || c == '\r' || c < 0;
}
}
static class IntUtils {
public static boolean isPow2(int n) {
return n > 0 && (n & (n - 1)) == 0;
}
public static int nextPow2(int n) {
if (n < 1) return 1;
return isPow2(n) ? n : Integer.highestOneBit(n) << 1;
}
}
static interface IntCollection {
}
}
|
Everyone knows that DNA strands consist of nucleotides. There are four types of nucleotides: "A", "T", "G", "C". A DNA strand is a sequence of nucleotides. Scientists decided to track evolution of a rare species, which DNA strand was string s initially.
Evolution of the species is described as a sequence of changes in the DNA. Every change is a change of some nucleotide, for example, the following change can happen in DNA strand "AAGC": the second nucleotide can change to "T" so that the resulting DNA strand is "ATGC".
Scientists know that some segments of the DNA strand can be affected by some unknown infections. They can represent an infection as a sequence of nucleotides. Scientists are interested if there are any changes caused by some infections. Thus they sometimes want to know the value of impact of some infection to some segment of the DNA. This value is computed as follows:
* Let the infection be represented as a string e, and let scientists be interested in DNA strand segment starting from position l to position r, inclusive.
* Prefix of the string eee... (i.e. the string that consists of infinitely many repeats of string e) is written under the string s from position l to position r, inclusive.
* The value of impact is the number of positions where letter of string s coincided with the letter written under it.
Being a developer, Innokenty is interested in bioinformatics also, so the scientists asked him for help. Innokenty is busy preparing VK Cup, so he decided to delegate the problem to the competitors. Help the scientists!
Input
The first line contains the string s (1 ≤ |s| ≤ 105) that describes the initial DNA strand. It consists only of capital English letters "A", "T", "G" and "C".
The next line contains single integer q (1 ≤ q ≤ 105) — the number of events.
After that, q lines follow, each describes one event. Each of the lines has one of two formats:
* 1 x c, where x is an integer (1 ≤ x ≤ |s|), and c is a letter "A", "T", "G" or "C", which means that there is a change in the DNA: the nucleotide at position x is now c.
* 2 l r e, where l, r are integers (1 ≤ l ≤ r ≤ |s|), and e is a string of letters "A", "T", "G" and "C" (1 ≤ |e| ≤ 10), which means that scientists are interested in the value of impact of infection e to the segment of DNA strand from position l to position r, inclusive.
Output
For each scientists' query (second type query) print a single integer in a new line — the value of impact of the infection on the DNA.
Examples
Input
ATGCATGC
4
2 1 8 ATGC
2 2 6 TTT
1 4 T
2 2 6 TA
Output
8
2
4
Input
GAGTTGTTAA
6
2 3 4 TATGGTG
1 1 T
1 6 G
2 5 9 AGTAATA
1 10 G
2 2 6 TTGT
Output
0
3
1
Note
Consider the first example. In the first query of second type all characters coincide, so the answer is 8. In the second query we compare string "TTTTT..." and the substring "TGCAT". There are two matches. In the third query, after the DNA change, we compare string "TATAT..."' with substring "TGTAT". There are 4 matches.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int bit[4][12][12][N], n, m, id[307];
string a;
void add(int flag, int start, int gap, int pos, int val) {
while (pos <= n) bit[flag][start][gap][pos] += val, pos += pos & -pos;
}
int sum(int flag, int start, int gap, int pos) {
int res = 0;
while (pos) res += bit[flag][start][gap][pos], pos -= pos & -pos;
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
id['A'] = 0;
id['T'] = 1;
id['G'] = 2;
id['C'] = 3;
cin >> a;
n = a.size();
a = string("*") + a;
for (int i = 1; i <= 10; ++i)
for (int j = 1; j <= i; ++j)
for (int k = j; k <= n; k += i) {
int c = id[a[k]];
add(c, j, i, k, 1);
}
cin >> m;
while (m--) {
int op, l, r, x;
string e;
cin >> op;
if (op == 1) {
cin >> x >> e;
int c = id[a[x]];
a[x] = e[0];
int cc = id[a[x]];
for (int i = 1; i <= 10; ++i)
for (int j = 1; j <= i; ++j)
if ((x - j) % i == 0) {
add(c, j, i, x, -1);
add(cc, j, i, x, 1);
}
} else {
cin >> l >> r >> e;
int res = 0, gap = e.size();
for (int k = 0; k < e.size(); ++k) {
int pos = k + l;
int c = id[e[k]];
for (int j = 1; j <= gap; ++j)
if ((pos - j) % gap == 0) {
res += sum(c, j, gap, r) - sum(c, j, gap, l - 1);
}
}
cout << res << endl;
}
}
return 0;
}
|
You are given set of n points in 5-dimensional space. The points are labeled from 1 to n. No two points coincide.
We will call point a bad if there are different points b and c, not equal to a, from the given set such that angle between vectors <image> and <image> is acute (i.e. strictly less than <image>). Otherwise, the point is called good.
The angle between vectors <image> and <image> in 5-dimensional space is defined as <image>, where <image> is the scalar product and <image> is length of <image>.
Given the list of points, print the indices of the good points in ascending order.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 103) — the number of points.
The next n lines of input contain five integers ai, bi, ci, di, ei (|ai|, |bi|, |ci|, |di|, |ei| ≤ 103) — the coordinates of the i-th point. All points are distinct.
Output
First, print a single integer k — the number of good points.
Then, print k integers, each on their own line — the indices of the good points in ascending order.
Examples
Input
6
0 0 0 0 0
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1
Output
1
1
Input
3
0 0 1 2 0
0 0 9 2 0
0 0 5 9 0
Output
0
Note
In the first sample, the first point forms exactly a <image> angle with all other pairs of points, so it is good.
In the second sample, along the cd plane, we can see the points look as follows:
<image>
We can see that all angles here are acute, so no points are good.
|
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
public class C {
static PrintWriter out = new PrintWriter(System.out);
static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
public static void main(String[] args) throws Exception{
long[][] coo = new long[1010][5];
int n = Integer.valueOf(reader.readLine());
for (int i = 0; i < n; i++) {
String[] ar = reader.readLine().split(" ");
for (int j = 0; j < 5; j++) {
coo[i][j] = Long.valueOf(ar[j]);
}
}
if (n > 32) {
System.out.println(0);
return;
}
List<Integer> ret = new ArrayList<>();
for (int i = 0; i < n; i++) {
if (check(i, n, coo)){
ret.add(i + 1);
}
}
System.out.println(ret.size());
ret.forEach(out::println);
out.flush();
}
static boolean check(int ith, int n, long[][] coo){
for (int i = 0; i < n; i++) {
if (i == ith) continue;
for (int j = 0; j < n; j++) {
if (j == i || j == ith) continue;
if (!isAcute(ith, i, j, coo)) return false;
}
}
return true;
}
static boolean isAcute(int a, int b, int c, long[][] coo){
long sum = 0;
for (int i = 0; i < 5; i++) {
sum += (coo[b][i] - coo[a][i]) * (coo[c][i] - coo[a][i]);
}
if (sum > 0) return false;
return true;
}
}
|
Ivan is playing a strange game.
He has a matrix a with n rows and m columns. Each element of the matrix is equal to either 0 or 1. Rows and columns are 1-indexed. Ivan can replace any number of ones in this matrix with zeroes. After that, his score in the game will be calculated as follows:
1. Initially Ivan's score is 0;
2. In each column, Ivan will find the topmost 1 (that is, if the current column is j, then he will find minimum i such that ai, j = 1). If there are no 1's in the column, this column is skipped;
3. Ivan will look at the next min(k, n - i + 1) elements in this column (starting from the element he found) and count the number of 1's among these elements. This number will be added to his score.
Of course, Ivan wants to maximize his score in this strange game. Also he doesn't want to change many elements, so he will replace the minimum possible number of ones with zeroes. Help him to determine the maximum possible score he can get and the minimum possible number of replacements required to achieve that score.
Input
The first line contains three integer numbers n, m and k (1 ≤ k ≤ n ≤ 100, 1 ≤ m ≤ 100).
Then n lines follow, i-th of them contains m integer numbers — the elements of i-th row of matrix a. Each number is either 0 or 1.
Output
Print two numbers: the maximum possible score Ivan can get and the minimum number of replacements required to get this score.
Examples
Input
4 3 2
0 1 0
1 0 1
0 1 0
1 1 1
Output
4 1
Input
3 2 1
1 0
0 1
0 0
Output
2 0
Note
In the first example Ivan will replace the element a1, 2.
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
long double PI = 4 * atan(1);
int k, n, m, a[101][101], dp[101][101], ans[101], rom[101];
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> m >> k;
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < m + 1; j++) {
cin >> a[i][j];
}
}
for (int j = 1; j < m + 1; j++) {
for (int i = 1; i < n + 1; i++) {
dp[i][j] = a[i][j];
dp[i][j] += dp[i - 1][j];
}
}
for (int j = 1; j < m + 1; j++) {
for (int i = n + 1 - 1; i >= 1; i--) {
int rm = dp[i - 1][j];
int tot = dp[min(i + k - 1, n)][j];
int cur = tot - rm;
if (cur >= ans[j]) {
ans[j] = cur;
rom[j] = rm;
}
}
}
for (int j = 2; j < m + 1; j++) {
ans[j] += ans[j - 1];
rom[j] += rom[j - 1];
}
cout << ans[m] << " " << rom[m];
return 0;
}
|
Everybody in Russia uses Gregorian calendar. In this calendar there are 31 days in January, 28 or 29 days in February (depending on whether the year is leap or not), 31 days in March, 30 days in April, 31 days in May, 30 in June, 31 in July, 31 in August, 30 in September, 31 in October, 30 in November, 31 in December.
A year is leap in one of two cases: either its number is divisible by 4, but not divisible by 100, or is divisible by 400. For example, the following years are leap: 2000, 2004, but years 1900 and 2018 are not leap.
In this problem you are given n (1 ≤ n ≤ 24) integers a1, a2, ..., an, and you have to check if these integers could be durations in days of n consecutive months, according to Gregorian calendar. Note that these months could belong to several consecutive years. In other words, check if there is a month in some year, such that its duration is a1 days, duration of the next month is a2 days, and so on.
Input
The first line contains single integer n (1 ≤ n ≤ 24) — the number of integers.
The second line contains n integers a1, a2, ..., an (28 ≤ ai ≤ 31) — the numbers you are to check.
Output
If there are several consecutive months that fit the sequence, print "YES" (without quotes). Otherwise, print "NO" (without quotes).
You can print each letter in arbitrary case (small or large).
Examples
Input
4
31 31 30 31
Output
Yes
Input
2
30 30
Output
No
Input
5
29 31 30 31 30
Output
Yes
Input
3
31 28 30
Output
No
Input
3
31 31 28
Output
Yes
Note
In the first example the integers can denote months July, August, September and October.
In the second example the answer is no, because there are no two consecutive months each having 30 days.
In the third example the months are: February (leap year) — March — April – May — June.
In the fourth example the number of days in the second month is 28, so this is February. March follows February and has 31 days, but not 30, so the answer is NO.
In the fifth example the months are: December — January — February (non-leap year).
|
a1 = '31 28 31 30 31 30 31 31 30 31 30 31 '
a2 = '31 29 31 30 31 30 31 31 30 31 30 31 '
s = a1 + a1 + a1 + a2 + a1 + a1
n = input()
ss = input().strip()
print(["NO",'YES'][ss in s])
|
A ski base is planned to be built in Walrusland. Recently, however, the project is still in the constructing phase. A large land lot was chosen for the construction. It contains n ski junctions, numbered from 1 to n. Initially the junctions aren't connected in any way.
In the constructing process m bidirectional ski roads will be built. The roads are built one after another: first the road number 1 will be built, then the road number 2, and so on. The i-th road connects the junctions with numbers ai and bi.
Track is the route with the following properties:
* The route is closed, that is, it begins and ends in one and the same junction.
* The route contains at least one road.
* The route doesn't go on one road more than once, however it can visit any junction any number of times.
Let's consider the ski base as a non-empty set of roads that can be divided into one or more tracks so that exactly one track went along each road of the chosen set. Besides, each track can consist only of roads from the chosen set. Ski base doesn't have to be connected.
Two ski bases are considered different if they consist of different road sets.
After building each new road the Walrusland government wants to know the number of variants of choosing a ski base based on some subset of the already built roads. The government asks you to help them solve the given problem.
Input
The first line contains two integers n and m (2 ≤ n ≤ 105, 1 ≤ m ≤ 105). They represent the number of junctions and the number of roads correspondingly. Then on m lines follows the description of the roads in the order in which they were built. Each road is described by a pair of integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) — the numbers of the connected junctions. There could be more than one road between a pair of junctions.
Output
Print m lines: the i-th line should represent the number of ways to build a ski base after the end of construction of the road number i. The numbers should be printed modulo 1000000009 (109 + 9).
Examples
Input
3 4
1 3
2 3
1 2
1 2
Output
0
0
1
3
Note
Let us have 3 junctions and 4 roads between the junctions have already been built (as after building all the roads in the sample): 1 and 3, 2 and 3, 2 roads between junctions 1 and 2. The land lot for the construction will look like this:
<image>
The land lot for the construction will look in the following way:
<image>
We can choose a subset of roads in three ways:
<image>
In the first and the second ways you can choose one path, for example, 1 - 2 - 3 - 1. In the first case you can choose one path 1 - 2 - 1.
|
#include <bits/stdc++.h>
int nextInt() {
int x;
scanf("%d", &x);
return x;
}
double nextDouble() {
double x;
scanf("%lf", &x);
return x;
}
long long nextLong() {
long long x;
scanf("%I64d", &x);
return x;
}
char nextChar() {
char x;
scanf("%c", &x);
return x;
}
void newLine() { printf("\n"); }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long powM(long long a, long long b, long long MOD) {
long long x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y);
if (x > MOD) x %= MOD;
}
y = (y * y);
if (y > MOD) y %= MOD;
b /= 2;
}
return x;
}
long long ModExp(long long n, long long k, long long MOD) {
long long ans = 1;
while (k > 0) {
if (k & 1) ans = (ans * n) % MOD;
n = (n * n) % MOD;
k /= 2;
}
return ans;
}
long long Exp(long long n, long long k) {
long long ans = 1;
while (k > 0) {
if (k & 1) ans = (ans * n);
n = (n * n);
k /= 2;
}
return ans;
}
int countSetBits(long long n) {
int ans = 0;
while (n != 0) {
n -= (n & -n);
++ans;
}
return ans;
}
const int N = 100100;
const int M = 12;
const int INF = 1e6;
const double EPS = 1e-6;
const long double PI = 2 * acos(0);
using namespace std;
const int LOG = 18;
long long mod = 1000000009;
int par[N];
int getPar(int x) { return x == par[x] ? x : par[x] = getPar(par[x]); };
bool same(int x, int y) { return getPar(x) == getPar(y); }
void merge(int x, int y) {
int xx = getPar(x);
int yy = getPar(y);
if (xx != yy) par[xx] = yy;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) par[i] = i;
long long ans = 1;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--, y--;
if (same(x, y)) {
ans = (ans * 2ll) % mod;
} else {
merge(x, y);
}
cout << (ans + mod - 1) % mod << endl;
}
return 0;
}
|
Bob is a farmer. He has a large pasture with many sheep. Recently, he has lost some of them due to wolf attacks. He thus decided to place some shepherd dogs in such a way that all his sheep are protected.
The pasture is a rectangle consisting of R × C cells. Each cell is either empty, contains a sheep, a wolf or a dog. Sheep and dogs always stay in place, but wolves can roam freely around the pasture, by repeatedly moving to the left, right, up or down to a neighboring cell. When a wolf enters a cell with a sheep, it consumes it. However, no wolf can enter a cell with a dog.
Initially there are no dogs. Place dogs onto the pasture in such a way that no wolf can reach any sheep, or determine that it is impossible. Note that since you have many dogs, you do not need to minimize their number.
Input
First line contains two integers R (1 ≤ R ≤ 500) and C (1 ≤ C ≤ 500), denoting the number of rows and the numbers of columns respectively.
Each of the following R lines is a string consisting of exactly C characters, representing one row of the pasture. Here, 'S' means a sheep, 'W' a wolf and '.' an empty cell.
Output
If it is impossible to protect all sheep, output a single line with the word "No".
Otherwise, output a line with the word "Yes". Then print R lines, representing the pasture after placing dogs. Again, 'S' means a sheep, 'W' a wolf, 'D' is a dog and '.' an empty space. You are not allowed to move, remove or add a sheep or a wolf.
If there are multiple solutions, you may print any of them. You don't have to minimize the number of dogs.
Examples
Input
6 6
..S...
..S.W.
.S....
..W...
...W..
......
Output
Yes
..SD..
..SDW.
.SD...
.DW...
DD.W..
......
Input
1 2
SW
Output
No
Input
5 5
.S...
...S.
S....
...S.
.S...
Output
Yes
.S...
...S.
S.D..
...S.
.S...
Note
In the first example, we can split the pasture into two halves, one containing wolves and one containing sheep. Note that the sheep at (2,1) is safe, as wolves cannot move diagonally.
In the second example, there are no empty spots to put dogs that would guard the lone sheep.
In the third example, there are no wolves, so the task is very easy. We put a dog in the center to observe the peacefulness of the meadow, but the solution would be correct even without him.
|
R,C=map(int, input().split())
m=[[str(j) for j in input()] for i in range(R)]
row=0
for i in range(R):
if row == 1:
break
for j in range(C):
if m[i][j] == ".":
m[i][j] = "D"
elif m[i][j] == "S":
if j > 0 and m[i][j-1] == "W":
row=1
break
elif j < C-1 and m[i][j+1] == "W":
row=1
break
elif i < R-1 and m[i+1][j] == "W":
row=1
break
elif i > 0 and m[i-1][j] == "W":
row=1
break
if row == 1:
print("NO")
else:
print("YES")
for i in m:
print("".join(i))
|
String can be called correct if it consists of characters "0" and "1" and there are no redundant leading zeroes. Here are some examples: "0", "10", "1001".
You are given a correct string s.
You can perform two different operations on this string:
1. swap any pair of adjacent characters (for example, "101" <image> "110");
2. replace "11" with "1" (for example, "110" <image> "10").
Let val(s) be such a number that s is its binary representation.
Correct string a is less than some other correct string b iff val(a) < val(b).
Your task is to find the minimum correct string that you can obtain from the given one using the operations described above. You can use these operations any number of times in any order (or even use no operations at all).
Input
The first line contains integer number n (1 ≤ n ≤ 100) — the length of string s.
The second line contains the string s consisting of characters "0" and "1". It is guaranteed that the string s is correct.
Output
Print one string — the minimum correct string that you can obtain from the given one.
Examples
Input
4
1001
Output
100
Input
1
1
Output
1
Note
In the first example you can obtain the answer by the following sequence of operations: "1001" <image> "1010" <image> "1100" <image> "100".
In the second example you can't obtain smaller answer no matter what operations you use.
|
n=int(input())
a=input()
count1=0
for item in a:
if(item=='1'):
count1=count1+1
if(count1>=1):
print(1,end="")
for i in range(0,len(a)-count1):
print(0,end="")
|
Allen is playing Number Clicker on his phone.
He starts with an integer u on the screen. Every second, he can press one of 3 buttons.
1. Turn u → u+1 \pmod{p}.
2. Turn u → u+p-1 \pmod{p}.
3. Turn u → u^{p-2} \pmod{p}.
Allen wants to press at most 200 buttons and end up with v on the screen. Help him!
Input
The first line of the input contains 3 positive integers: u, v, p (0 ≤ u, v ≤ p-1, 3 ≤ p ≤ 10^9 + 9). p is guaranteed to be prime.
Output
On the first line, print a single integer ℓ, the number of button presses. On the second line, print integers c_1, ..., c_ℓ, the button presses. For 1 ≤ i ≤ ℓ, 1 ≤ c_i ≤ 3.
We can show that the answer always exists.
Examples
Input
1 3 5
Output
2
1 1
Input
3 2 5
Output
1
3
Note
In the first example the integer on the screen changes as 1 → 2 → 3.
In the second example the integer on the screen changes as 3 → 2.
|
#include <bits/stdc++.h>
using namespace std;
using nagai = long long;
int u, v, p;
int mult(int a, int b) { return 1LL * a * b % p; }
int pw(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = mult(ans, a);
a = mult(a, a);
b >>= 1;
}
return ans;
}
int inv(int a) { return pw(a, p - 2); }
struct st {
int start, d, from;
};
unordered_map<int, st> mem;
vector<int> au, av;
int md(int x) {
if (x < 0) return x + p;
if (x >= p) return x - p;
return x;
}
vector<int> q;
void go(int x, int a, int b, int from) {
if (mem.count(x)) return;
mem[x] = {a, b, from};
q.push_back(x);
}
int go1(int x) { return md(x + 1); }
int go2(int x) { return md(x - 1); }
vector<int> restore(int x) {
vector<int> ans;
while (mem[x].d > 0) ans.push_back(x), x = mem[x].from;
ans.push_back(x);
reverse(ans.begin(), ans.end());
return ans;
}
int main() {
cin >> u >> v >> p;
if (u == v) {
cout << 0 << '\n';
return 0;
}
mem.rehash(1000000);
mem[u] = {u, 0};
mem[v] = {v, 0};
q.push_back(u);
q.push_back(v);
for (int i = 0; i < q.size() && i < 1000000; ++i) {
int x = q[i];
auto p = mem[x];
go(md(x - 1), p.start, p.d + 1, x);
go(md(x + 1), p.start, p.d + 1, x);
go(inv(x), p.start, p.d + 1, x);
}
vector<pair<int, st>> arr;
for (int x : q) arr.emplace_back(x, mem[x]);
sort(arr.begin(), arr.end(),
[&](pair<int, st>& a, pair<int, st>& b) { return a.first < b.first; });
for (int i = 0; i + 1 < arr.size(); ++i) {
auto x = arr[i];
auto y = arr[i + 1];
if (x.second.start == y.second.start) continue;
if (x.second.d + y.second.d + abs(x.first - y.first) <= 200) {
if (x.second.start == v) swap(x, y);
auto mem = restore(x.first);
auto kek = restore(y.first);
reverse(kek.begin(), kek.end());
vector<int> ans;
for (int i = 0; i + 1 < mem.size(); ++i)
if (go1(mem[i]) == mem[i + 1])
ans.push_back(1);
else if (go2(mem[i]) == mem[i + 1])
ans.push_back(2);
else
ans.push_back(3);
int lol = x.first - y.first;
for (int i = 0; i < abs(lol); ++i) ans.push_back(lol > 0 ? 2 : 1);
for (int i = 0; i + 1 < kek.size(); ++i)
if (go1(kek[i]) == kek[i + 1])
ans.push_back(1);
else if (go2(kek[i]) == kek[i + 1])
ans.push_back(2);
else
ans.push_back(3);
cout << ans.size() << '\n';
for (int x : ans) cout << x << ' ';
cout << '\n';
return 0;
}
}
}
|
Cat Noku recently picked up construction working as a hobby. He's currently working with a row of buildings and would like to make it beautiful.
There are n buildings in a row. The height of the i-th building is xi.
Cat Noku can modify the buildings by adding or removing floors to change the heights.
It costs him P dollars to increase the height of one building by 1, and M dollars to lower the height of one building by 1. Note that the heights of all the buildlings must remain integers (i.e. Cat Noku cannot choose to raise the height of a building by 0.5).
At the end of the day Cat Noku will get a bonus for the number of buildings which are adjacent and have the same height. For each section i, if section i+1 has the same height, Cat Noku will gain a profit of S (of course, it is not possible to get this bonus for the last building in the row).
Thus, his net profit can be described by his total profit minus the cost it took him to change the building heights.
Help Cat Noku determine the maximum possible net profit he can gain.
Input format:
The first line will contain four space separated integers n, S, M, P.
The second line will contain n space separated integers. The i-th integer in this line will be equal to xi.
Output format:
Print a single integer on its own line, the maximum net profit that Cat Noku can earn.
Constraints:
For all subtasks:
2 ≤ n
1 ≤ xi
1 ≤ S, M, P
Subtask 1 (56 pts):
n ≤ 5
xi ≤ 10
S, M, P ≤ 100
Subtask 2 (32 pts):
n ≤ 50
xi ≤ 100
S, M, P ≤ 1,000
Subtask 3 (12 pts):
n ≤ 2,500
xi ≤ 1,000,000
S, M, P ≤ 1,000,000,000
SAMPLE INPUT
5 4 2 1
1 2 1 5 4
SAMPLE OUTPUT
9
Explanation
In this case, we have 5 buildings with heights 1,2,1,5,4. Cat Noku will get a bonus of 4 for adjacent buildings with the same height. It costs 2 dollars to lower the height of a building by 1, and 1 dollar to raise the height by 1.
One optimal solution is to modify the buildings heights to be 1,1,1,5,5. This costs 2+1=3 dollars. Cat Noku gets the bonus 3 times (i.e. the first, second and fourth buildings qualify for the bonus). Thus, his gross profit is 3*4=12. His net profit is 12-3=9 in this case.
|
n,S,M,P=map(int, raw_input().split())
his=map(int, raw_input().split())
maxhi=max(his)
minhi=min(his)
earned={}
act=n-1
for i in xrange(minhi,maxhi+1):
earned[i]=(i-his[act])*M if his[act]>i else (his[act]-i)*P # all neg!
while act>0:
nextearn=earned
maxnext=max(nextearn.values())
earned={}
act-=1
for i in his:
earned[i]=max(maxnext,S+nextearn[i])+((i-his[act])*M if his[act]>i else (his[act]-i)*P)
print max(earned.values())
|
There are 26 letters in the English alphabet and 6 of them are vowels: a,e,i,o,u,y.
Other 20 letters are called consonants.
Limak is a little polar bear.
He found a string s consisting of lowercase English letters.
He is going to read and pronounce s but it may be hard for him.
Some letters are harder to pronounce, some are easier.
Generally, little polar bears like vowels (letters a,e,i,o,u,y) and hate consonants.
Your task is to check whether pronouncing s will be hard or easy.
We define s to be hard if at least one of the two conditions holds true:
There are more consonants than vowels.
Some 3 consecutive letters are all consonants.
For each test case in one line print "hard" (without the quotes) if s is hard to pronounce.
Otherwise, print "easy" (without the quotes).
Input format
The first line of the input contains one integer T denoting the number of test cases.
The first line of each test case description contains one string s denoting a string found by Limak.
Each character in s is one of 26 lowercase English letters.
Output format
For each test case, output a single line containing the answer — either "hard" or "easy".
Constraints
1 ≤ T ≤ 50
1 ≤ |s| ≤ 50
SAMPLE INPUT
5
qiewldoaa
life
ayayayyy
szczebrzeszyn
gg
SAMPLE OUTPUT
hard
easy
easy
hard
hard
Explanation
In the first sample test case, Limak found a string "qiewldoaa".
It's hard to pronounce because there are 3 consecutive consonants: w,l,d.
In the last sample test case, a string "gg" is hard to pronounce because it contains more consonants than vowels.
|
def hardness(s):
consective_consonants = 0
consective_condition = False
consonants, vowels = 0, 0
for c in s:
if c not in ['a', 'e', 'i', 'o', 'u', 'y']:
consonants += 1
consective_consonants += 1
if consective_consonants == 3:
consective_condition = True
else:
vowels += 1
consective_consonants = 0
# print(consonants, vowels, consective_condition)
if (consonants > vowels) or consective_condition:
return 'hard'
return 'easy'
def main():
T = int(raw_input().strip())
for t in range(T):
s = raw_input().strip()
ans = hardness(s)
print ans
if __name__ == '__main__':
main()
|
Chinna and Chinnu has recently started developing a website for their startup from scratch. But they found it difficult to validate an Email field for their login forum. Help them build one.
An Email Address is of the form <username>@<hostname>
<username> consists of 1 - 16 characters inclusive and contains only small, capital letters, digits [0-9], underscore '_'
<username> and <hostname> are separated by an ‘@’ character
<hostname> consists of 1 - 16 characters inclusive and contains only small, capital letters, digits [0-9], hyphens (‘-’) (this part has to contain at least one alphabet) and a dot (‘.’) followed by 1- 10 characters with small letter characters only
NOTE : <hostname> is [1-16] characters + '.' + [1-10] characters
Input :
Given a number n and n email addresses to validate
Output:
For each email address, print “YES” without quotes if the email is valid else “NO”
Constraint:
1 ≤ n ≤ 100
SAMPLE INPUT
3
[email protected]
[email protected]
[email protected]
SAMPLE OUTPUT
YES
NO
YES
|
t=input()
while t:
t-=1
e = raw_input()
yes = True
try:
u,h = e.split('@')
except:
print("NO")
continue
else:
if len(u) >16 or len(u) < 1:
yes = False
for x in u:
if not ((x >= 'a' and x <= 'z') or (x >= 'A' and x <= 'Z') or (x >= '0' and x <= '9') or x =='_'):
yes = False
h_alpha = False
try:
bdot ,adot = h.split('.')
except:
print("NO")
continue
if len(bdot) >16 or len(bdot)<1:
yes = False
for x in bdot:
if not ((x >= 'a' and x <= 'z') or (x >= 'A' and x <= 'Z') or (x >= '0' and x <= '9') or x =='-'):
yes = False
if (x >= 'a' and x <= 'z') or (x >= 'A' and x <= 'Z'):
h_alpha = True
if not h_alpha:
yes = False
if not (len(adot) >=1 and len(adot)<=10):
yes = False
for x in adot:
if not (x>='a' and x <='z'):
yes=False
if yes:
print("YES")
else:
print("NO")
|
"She loves me", "She loves me not", "She loves me", "She loves me not", OH WAIT, I'm LALA,
"They love me", "They love me not", "They love me", "They love me not". Lala was indeed overwhelmed by the
'runner's high' and the turbulence inside him. Heart-broken by one of his many lalis, he decided to code out his frustration,
and also having read somewhere that some specific amount of 'so-called high' heightens brain power and creativity.
He thinks of making a large palindrome, using the formula
S(n)=S(n-1)+"0"+reverse(S(n-1))
but instead makes it up as
S(n)=S(n-1)+"0"+switch(reverse(S(n-1)))
After lala's passing out, in came patrick and wanted to check out what lala has done. Due to his over-technical abilities,
lala has encrypted the code such that at a time only the kth digit of the string will be visible.
As lala is lala, he has taken the upper limit to a whole another level and has coded it for 10^100.
As a programmer you are asked to fill in lala's shoes and code the program generating the kth digit for the last string.
The digits used are 0 and 1 and the functions are as follows:
switch:
the digit will be interchanged (0 for 1, 1 for 0)
reverse:
the string will be reversed.
Input
The first line of the input gives the number of test cases, T. Each of the next T lines contains a number K.
Output
For each test case, output one line containing is the Kth character of S
SAMPLE INPUT
4
1
2
3
10
SAMPLE OUTPUT
0
0
1
0
|
def f(x):
while x%2==0:
x /= 2
return x%4 == 3
for i in range(int(raw_input())):
if f(int(raw_input())):
print(1)
else:
print(0)
|
Lucky numbers are those numbers which are greater than all numbers to its right side.You task is to count all lucky numbers in a given array.
RightMost Element is always lucky Number
INPUT First line contain number of test case T. Each test case contain number of elements N.Next line contains elements of array.
OUTPUT Print numbers of lucky numbers.
Constraints
1 ≤ T ≤ 100
1 ≤ N ≤ 1000000
1 ≤ Elements ≤ 1000000
SAMPLE INPUT
1
6
16 17 4 3 5 2
SAMPLE OUTPUT
3
Explanation
Lucky numbers are 17 , 5 , 2
|
import sys
for __ in range(input()) :
n = input()
lists = list(map(int,sys.stdin.readline().split()))
lucky = lists[-1]
ans = 1
for i in range(n-2,-1,-1) :
if lucky < lists[i] :
lucky = lists[i]
ans += 1
print ans
|
Subly is a very naughty kid. His father gave a set of numbers to him. In the set no number is repeated and the set has N elements. He wanted Subly to keep that set safe. When his Father was busy watching a new season of his favourite TV series, Subly became bored. He started playing with the set of numbers that his father gave. He observed that he didn't like a few of the numbers in the set. So, he changed all numbers that he doesn't like to the number that he likes and is in the Set.
When his father came to know about this, he got very angry. He wants to find the numbers of elements that his son changed. But he also wants to continue watching the Series, as his favourite character is kidnapped and the plot is getting very exciting.
Can you help him identify how many numbers his son changed?
Input:
First Line contains a Number N denoting the number of elements in the set.
Next Line will contain N numbers. These numbers are the elements of the changed set.
Output:
A single Integer Denoting the answer.
Constraints:
1 ≤ N ≤ 100000
1 ≤ x ≤ 1000 ; x := An element of the changed Set
Example:
Input:
6
1 6 3 9 6 3
Output:
2
Input:
10
1 2 3 4 5 6 6 8 9 9
Output:
2
SAMPLE INPUT
6
1 6 3 9 6 3
SAMPLE OUTPUT
2
|
test=input()
arr=[]
c=0
arr=raw_input().split()
if len(arr)==test:
print len(arr)-len(set(arr))
|
There are 'n' coins kept on the table, numbered from 0 to 'n-1'. Initially, each coin is kept tails up. You have to perform two types of operations :
1) Flip all coins numbered between A and B inclusive. This is represented by the command:
0
A
B
2) Answer how many coins numbered between A and B inclusive are heads up. This is represented by the command
1
A
B
Input:
The first two lines contain two integers, N and Q.The first line after inputting N and Q has to be of form (1).Each of the next Q lines are of the form (2) as mentioned above.
Output:
Output 1 line for each of the queries of the form 2 containing the required answer for the corresponding query just after the query.
7
3
0
3
5
1
0
6
3 <-- this is the first output
1
3
4
2 <-- this is output
SAMPLE INPUT
7
3
0
3
5
1
0
6
1
3
4
SAMPLE OUTPUT
3
2
|
lst=[0]*input()
for i in range(input()):
a=int(raw_input())
b=int(raw_input())
c=int(raw_input())
c=c+1
if a==0:
for i in range(b,c):
if lst[i]==0:
lst[i]=1
else:
lst[i]=0
else:
count=0
for i in range(b,c):
if lst[i]==1:
count=count+1
print count
|
WizKid went on a trip to Wonderland with his classmates. Now, as you know, going on trips incurs costs including hotel costs, fooding, shopping, etc. And when many people go together, usually one person pays and it is expected that the others will pay back their share. But, after a few days people lost track of who owed whom how much and there was a lot of confusion.
So WizKid set down to make a program which will help solve all these problems in future. He will record the details of all the people going on the trip and the details of each transaction made on the trip.
Note: It is not necessary that all the people were present in all transactions. Only those present will share the amount. So he also has to note who all were present, who paid and the amount paid.
Even after this, one more issue remained about what happens when the amount spent could not be divided equally integrally to each person. Well, he decided that the person who paid the bill will have to bear the little extra cost himself on each bill.
Now, we need you to simulate the same and give the final summary for each person accordingly.
Input:
First line contains T which is the number of test cases.
First line of each test case consists of 2 integers N and Q where N is the number of people who went on the trip and Q is the number of transactions made.
N lines follow, each containing the names of the N persons who went on the trip. Each name will be distinct and will be a single word consisting of lowercase or uppercase alphabets only.
Q transactions follow each containing the details of each transaction made.
The first line of each transaction contains the name of the person who paid for the transaction.
The second line of each transaction contains the amount paid by the person for the transaction.
The third line of each transaction contains the number of people(other than the person who paid) M between whom this amount is to be split.
M lines follow each containing the names of the people between whom this amount is to be split.
Output:
For each test case, print N lines containing the final dues for each person in the following manner :
If a person X is supposed to get Y money from the others, then print "X is owed Y"
If a person X is supposed to pay Y money to the others, then print "X owes Y"
If a person X has no dues, then print "X neither owes nor is owed"
Constraints:
1 ≤ T ≤ 10
2 ≤ N ≤ 50
1 ≤ Q ≤ 50
1 ≤ M ≤ N-1
1 ≤ length of each name ≤ 10
1 ≤ all amounts ≤ 1000
Scoring:
2 ≤ N ≤ 5, 1 ≤ Q ≤ 5 : (30 pts)
2 ≤ N ≤ 10, 1 ≤ Q ≤ 10 : (30 pts)
Original Constraints : (40 pts)
SAMPLE INPUT
1
4 2
Alice
Bob
Daniel
Mike
Bob
97
1
Alice
Mike
24
2
Alice
Bob
SAMPLE OUTPUT
Alice owes 56
Bob is owed 40
Daniel neither owes nor is owed
Mike is owed 16
Explanation
After the first transaction, Bob pays 97 for Alice and himself. The share will have to divided as 49 for Bob and 48 for Alice.
ALICE: Expenses = 48, Paid = 0
BOB: Expenses = 49, Paid = 49
After the second transaction, Mike spends 24 on Alice, Bob and himself. The share will have to divided equally. So now,
ALICE: Expenses = 48+8 , Paid = 0
BOB: Expenses = 49+8, Paid = 97
MIKE: Expenses = 8, Paid = 24
Thus finally,
ALICE has to pay 56.
BOB will get back 97-49-8 = 40.
MIKE will get back 16.
DANIEL has no dues.
|
t=input('')
cnt=0
while int(t)>int(cnt):
d={}
n_person,q_transaction=raw_input('').split(' ')
tourist_name=[]
for i in range(int(n_person)):
tourist_name.append(str(raw_input('')))
d[tourist_name[i]]=[0,0]#expense,paid
for j in range(int(q_transaction)):
payee_name=str(raw_input(''))#who paid for transaction
payee_amount=int(raw_input(''))#amount paid in transaction
payee_divide=int(raw_input(''))#hw many person to divide including payee
divide_list=[]
for k in range(int(payee_divide)):
divide_list.append(str(raw_input('')))#name of other than payee
#print divide_list
amnt_to_share =int(payee_amount/(payee_divide+1))
if (amnt_to_share*(payee_divide+1))==payee_amount:
other_share=amnt_to_share
payee_share=amnt_to_share
else:
other_share=amnt_to_share
payee_share=(amnt_to_share+(payee_amount-(amnt_to_share*int(payee_divide+1))))
for l in range(len(divide_list)):
d[str(divide_list[l])][1]+=int(other_share)
d[str(payee_name)][0]+=int(payee_amount)
d[str(payee_name)][1]+=int(payee_share)
#print d
for i in range(int(n_person)):
if (d[tourist_name[i]][0]-d[tourist_name[i]][1])<0:
print str(tourist_name[i])+" owes "+str(abs(d[tourist_name[i]][0]-d[tourist_name[i]][1]))
else:
if (d[tourist_name[i]][0]-d[tourist_name[i]][1])>0:
print str(tourist_name[i])+" is owed "+str(abs(d[tourist_name[i]][0]-d[tourist_name[i]][1]))
if (d[tourist_name[i]][0]-d[tourist_name[i]][1])==0:
print str(tourist_name[i])+" neither owes nor is owed"
t-=1
|
This is 1526 A.D. Third Battle of Panipat between Babur and Ibrahim Lodi, the current ruler of India is going on.
Realising that Lodi has much larger army, Babur planned to attack the cities of India to bring the moral of the soldiers of Lodi down.
Now, Lodi had been ordered by his ancestors that, if he is to rule India, the cities in India should be connected and this system should always form a tree.
Now, in 1526, India had N cities(numbered 0 to N-1) all connected by roads and the whole system formed a tree. Lodi had to plan to save his cities. So he decided to use his special power S.H.I.E.L.D. And since all the other cities would be destroyed he wanted the protected cities system should form a tree.
S.H.I.E.L.D was an expensive power and Lodi decided that he would use it only on some specific cities.
Now you being the prime minister of the ruler, need to tell him in how many ways he can do this. Lodi may even not use this power at all on any city or he may even select all the cities.
INPUT
First line contains the N: number of cities.
Next N-1 lines contain u and v, denoting a path between city number 'u' and city number 'v'.
OUTPUT
Print the required number of ways modulo 10^9 + 7.
CONSTRAINTS
2 ≤ N ≤ 10^5
0 ≤ u,v < N
Given arrangement will be a tree.
SAMPLE INPUT
3
0 1
1 2
SAMPLE OUTPUT
7
Explanation
He has eight options. {},{0},{1},{2},{0,1},{1,2},{0,2},{0,1,2}.
But he cannot select {0,2} since this system doesn't form a tree.
|
n=int(raw_input())
r=[True]*(n)
G=[[] for i in xrange(n)]
A=[-1]*(n)
B=[-1]*(n)
m=(10**9+7)
for i in xrange(n-1):
u,v=map(int,raw_input().split())
G[u].append(v)
r[v]=False
for i in xrange(0,n):
if r[i]==True:
root=i
def f(x):
#print x
p=1
t=0
if len(G[x])==0:
A[x]=1
B[x]=0
#return (A[x],B[x])
else:
for i in G[x]:
#print "i",i
if A[i]!=-1 and B[i]!=-1:
#x,y=f(i)
p=p*(1+A[i])
p%=m
t+=(A[i]+B[i])
t%=m
else:
f(i)
p=p*(1+A[i])
p%=m
t+=(A[i]+B[i])
t%=m
A[x]=p
B[x]=t
#return A[x]+B[x]
f(root)
#print A,B
print (A[root]+B[root]+1)%m
|
Today, teacher taught Xenny the chapter 'Prime numbers and Composite numbers'. Xenny liked it and being a studious boy, wanted some homework. So teacher gave him a simple task. The task is to find the smallest composite number greater than given no. Xenny was happy to get the simple task. But Xenny didn't get the time for complting the homework being busy in helping his mother throughout the day. You, a best friend of Xenny, don't want Xenny to get punished by teacher. So its your job to complete his homework.
Formally, there will be t numbers and you have to find smallest greater composite number for each of them.
Input:
The first line of input will be t i.e. number of test-cases.
Followed by t lines each containing n.
Output:
For each test-case, Print the smallest greater number than n which is a composite number on new line.
Constraints:
SMALL:
1 ≤ t ≤ 10
0 ≤ n ≤ 10
MEDIUM:
1 ≤ t ≤ 500
0 ≤ n ≤ 1000
LARGE:
1 ≤ t ≤ 50000
0 ≤ n ≤ 100000
SAMPLE INPUT
2
3
8
SAMPLE OUTPUT
4
9
Explanation
Test-cases are 2.
For first case, the smallest composite no. greater than 3 is 4 .
For second case, the smallest composite no. greater than 8 is 9 .
|
def isprime(n):
for x in xrange(2, int(n**0.5)+1):
if n % x == 0:
return False
return True
t=input()
while(t):
n=input()
flag=1
i=n+1
while(flag):
if not isprime(i):
print i
flag=0
else:
i+=1
t-=1
|
When you asked some guy in your class his name, he called himself S, where S is a string of length between 3 and 20 (inclusive) consisting of lowercase English letters. You have decided to choose some three consecutive characters from S and make it his nickname. Print a string that is a valid nickname for him.
Constraints
* 3 \leq |S| \leq 20
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
Output
Print your answer.
Examples
Input
takahashi
Output
tak
Input
naohiro
Output
nao
|
import sys
s = input()
print(s[:3])
|
We have N integers A_1, A_2, ..., A_N.
There are \frac{N(N-1)}{2} ways to choose two of them and form a pair. If we compute the product of each of those pairs and sort the results in ascending order, what will be the K-th number in that list?
Constraints
* All values in input are integers.
* 2 \leq N \leq 2 \times 10^5
* 1 \leq K \leq \frac{N(N-1)}{2}
* -10^9 \leq A_i \leq 10^9\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N K
A_1 A_2 \dots A_N
Output
Print the answer.
Examples
Input
4 3
3 3 -4 -2
Output
-6
Input
10 40
5 4 3 2 -1 0 0 0 0 0
Output
6
Input
30 413
-170202098 -268409015 537203564 983211703 21608710 -443999067 -937727165 -97596546 -372334013 398994917 -972141167 798607104 -949068442 -959948616 37909651 0 886627544 -20098238 0 -948955241 0 -214720580 277222296 -18897162 834475626 0 -425610555 110117526 663621752 0
Output
448283280358331064
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 1LL<<61;
int main(){
ll n, k; cin >> n >> k;
vector<ll> A(n);
for(int i = 0; i < n; i++) cin >> A[i];
sort(A.begin(), A.end());
ll left = -INF, right = INF;
while(right - left > 1){
ll x = (right+left)/2;
ll s = 0, t = 0;
for(int i = 0; i < n; i++){
if(A[i] > 0){
int l1 = -1, r1 = n;
while(r1 - l1 > 1){
int m = (r1 + l1) / 2;
if(A[i] * A[m] <= x) l1 = m;
else r1 = m;
}
s += r1;
}
else if(A[i] < 0){
int l1 = -1, r1 = n;
while(r1 - l1 > 1){
int m = (r1 + l1) / 2;
if(A[i] * A[m] <= x) r1 = m;
else l1 = m;
}
s += n - r1;
}
else if(x >= 0) s += n;
if(A[i] * A[i] <= x) t++;
}
ll num = (s - t) / 2;
if(num >= k) right = x;
else left = x;
}
cout << right << endl;
}
|
The weather in Takahashi's town changes day by day, in the following cycle: Sunny, Cloudy, Rainy, Sunny, Cloudy, Rainy, ...
Given is a string S representing the weather in the town today. Predict the weather tomorrow.
Constraints
* S is `Sunny`, `Cloudy`, or `Rainy`.
Input
Input is given from Standard Input in the following format:
S
Output
Print a string representing the expected weather tomorrow, in the same format in which input is given.
Examples
Input
Sunny
Output
Cloudy
Input
Rainy
Output
Sunny
|
#include <iostream>
using namespace std;
int main()
{
string s, a="Sunny", b="Cloudy", c="Rainy";
cin>>s;
if(s==a)s=b;
else if(s==b)s=c;
else if(s==c)s=a;
cout<<s<<endl;
return 0;
}
|
We have a tree with N vertices numbered 1 to N. The i-th edge in the tree connects Vertex u_i and Vertex v_i, and its length is w_i. Your objective is to paint each vertex in the tree white or black (it is fine to paint all vertices the same color) so that the following condition is satisfied:
* For any two vertices painted in the same color, the distance between them is an even number.
Find a coloring of the vertices that satisfies the condition and print it. It can be proved that at least one such coloring exists under the constraints of this problem.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq u_i < v_i \leq N
* 1 \leq w_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
u_1 v_1 w_1
u_2 v_2 w_2
.
.
.
u_{N - 1} v_{N - 1} w_{N - 1}
Output
Print a coloring of the vertices that satisfies the condition, in N lines. The i-th line should contain `0` if Vertex i is painted white and `1` if it is painted black.
If there are multiple colorings that satisfy the condition, any of them will be accepted.
Examples
Input
3
1 2 2
2 3 1
Output
0
0
1
Input
5
2 5 2
2 3 10
1 3 8
3 4 2
Output
1
0
1
0
1
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int>>> G;
vector<int> V;
vector<int> ans;
void dfs(int v, int dist) {
ans.at(v) = dist % 2;
for (auto g : G.at(v)) {
if (V.at(g.first)) continue;
V.at(v) = 1;
dfs(g.first, dist + g.second);
V.at(v) = 0;
}
}
int main() {
int N;
cin >> N;
G.resize(N);
V.resize(N);
ans.resize(N);
for (int i = 0, a, b, c; cin >> a >> b >> c; i++) {
G.at(--a).push_back({--b, c % 2});
G.at(b).push_back({a, c % 2});
}
V.at(0) = 1;
dfs(0, 0);
for (auto a : ans) cout << a << "\n";
}
|
Takahashi has A untasty cookies containing antidotes, B tasty cookies containing antidotes and C tasty cookies containing poison.
Eating a cookie containing poison results in a stomachache, and eating a cookie containing poison while having a stomachache results in a death. As he wants to live, he cannot eat one in such a situation. Eating a cookie containing antidotes while having a stomachache cures it, and there is no other way to cure stomachaches.
Find the maximum number of tasty cookies that Takahashi can eat.
Constraints
* 0 \leq A,B,C \leq 10^9
* A,B and C are integers.
Input
Input is given from Standard Input in the following format:
A B C
Output
Print the maximum number of tasty cookies that Takahashi can eat.
Examples
Input
3 1 4
Output
5
Input
5 2 9
Output
10
Input
8 8 1
Output
9
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int A = sc.nextInt();
int B = sc.nextInt();
int C = sc.nextInt();
if (A + B >= C - 1) {
System.out.println(B + C);
} else {
System.out.println(B + A + B + 1);
}
sc.close();
}
}
|
Takahashi and Aoki will play a game with a number line and some segments. Takahashi is standing on the number line and he is initially at coordinate 0. Aoki has N segments. The i-th segment is [L_i,R_i], that is, a segment consisting of points with coordinates between L_i and R_i (inclusive).
The game has N steps. The i-th step proceeds as follows:
* First, Aoki chooses a segment that is still not chosen yet from the N segments and tells it to Takahashi.
* Then, Takahashi walks along the number line to some point within the segment chosen by Aoki this time.
After N steps are performed, Takahashi will return to coordinate 0 and the game ends.
Let K be the total distance traveled by Takahashi throughout the game. Aoki will choose segments so that K will be as large as possible, and Takahashi walks along the line so that K will be as small as possible. What will be the value of K in the end?
Constraints
* 1 ≤ N ≤ 10^5
* -10^5 ≤ L_i < R_i ≤ 10^5
* L_i and R_i are integers.
Input
Input is given from Standard Input in the following format:
N
L_1 R_1
:
L_N R_N
Output
Print the total distance traveled by Takahashi throughout the game when Takahashi and Aoki acts as above. It is guaranteed that K is always an integer when L_i,R_i are integers.
Examples
Input
3
-5 1
3 7
-4 -2
Output
10
Input
3
1 2
3 4
5 6
Output
12
Input
5
-2 0
-2 0
7 8
9 10
-2 -1
Output
34
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main()
{
int n;
cin >> n;
vector<int> x(n+1);
vector<int> y(n+1);
for(int i = 0; i < n; i++)
{
cin >> x[i] >> y[i];
}
sort(x.rbegin(), x.rend());
sort(y.begin(), y.end());
ll ans = 0;
for(int i = 0; i < n+1; i++)
{
if(x[i] - y[i] > 0)
{
ans += 2*(x[i] - y[i]);
}
}
cout << ans << endl;
}
|
There is a tree with N vertices. The vertices are numbered 1 through N. The i-th edge (1 \leq i \leq N - 1) connects Vertex x_i and y_i. For vertices v and w (1 \leq v, w \leq N), we will define the distance between v and w d(v, w) as "the number of edges contained in the path v-w".
A squirrel lives in each vertex of the tree. They are planning to move, as follows. First, they will freely choose a permutation of (1, 2, ..., N), p = (p_1, p_2, ..., p_N). Then, for each 1 \leq i \leq N, the squirrel that lived in Vertex i will move to Vertex p_i.
Since they like long travels, they have decided to maximize the total distance they traveled during the process. That is, they will choose p so that d(1, p_1) + d(2, p_2) + ... + d(N, p_N) will be maximized. How many such ways are there to choose p, modulo 10^9 + 7?
Constraints
* 2 \leq N \leq 5,000
* 1 \leq x_i, y_i \leq N
* The input graph is a tree.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_{N - 1} y_{N - 1}
Output
Print the number of the ways to choose p so that the condition is satisfied, modulo 10^9 + 7.
Examples
Input
3
1 2
2 3
Output
3
Input
4
1 2
1 3
1 4
Output
11
Input
6
1 2
1 3
1 4
2 5
2 6
Output
36
Input
7
1 2
6 3
4 5
1 7
1 5
2 3
Output
396
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 5003;
const ll MOD = 1e9+7;
ll fac[5010], fnv[5010];
ll D[5010][5010];
int ni[5010], sz[5010];
int n;
vector<int> lis[5010];
int idfs(int here, int p) {
sz[here] = 1;
for (int &there : lis[here]) {
if (there==p) continue;
sz[here] += idfs(there,here);
}
return sz[here];
}
int cdfs(int here, int p) {
for (int &there :lis[here]) {
if (there==p) continue;
if (sz[there]>n/2) return cdfs(there,here);
}
return here;
}
ll power(ll a, ll n) {
if (!n) return 1;
ll t = power(a,n/2);
return t*t%MOD*((n&1)?a:1)%MOD;
}
void init() {
int i;
fac[0] = 1;
for (i=1;i<MAXN;i++) fac[i]=fac[i-1]*i%MOD;
for (i=0;i<MAXN;i++) fnv[i]=power(fac[i],MOD-2);
}
ll calc(int p) {
int i, j, k, s = ni[0];
for (i=0;i<=ni[0];i++) D[0][i] = fnv[ni[0]-i]*fnv[ni[0]-i]%MOD*fnv[i]%MOD;
for (i=1;i<p;i++) {
s += ni[i];
for (j=0;j<=s;j++) {
D[i][j] = 0;
for (k=0;k<=min(j,ni[i]);k++) D[i][j] += D[i-1][j-k]*fnv[ni[i]-k]%MOD*fnv[ni[i]-k]%MOD*fnv[k]%MOD;
D[i][j]%=MOD;
}
}
int q = 1;
ll res = 0, val = 1;
for (i=0;i<p;i++) val = val*fac[ni[i]]%MOD*fac[ni[i]]%MOD;
for (i=0;i<=s;i++,q=-q) {
res = (res+q*D[p-1][i]*fac[s-i]%MOD)%MOD;
}
return (res*val%MOD+MOD)%MOD;
}
int main() {
scanf("%d",&n);
int i;
init();
for (i=0;i<n-1;i++){
int a, b;
scanf("%d%d",&a,&b);--a;--b;
lis[a].push_back(b);lis[b].push_back(a);
}
idfs(0,-1);
int cen = cdfs(0,-1);
idfs(cen,-1);
if (n%2==0) {
bool flag = 0;
for (int &there : lis[cen]) {
if (sz[there]==n/2) {
flag = 1;
break;
}
}
if (flag) {
printf("%lld\n",fac[n/2]*fac[n/2]%MOD);
return 0;
}
}
int p = 0;
for (int &there : lis[cen]) ni[p++] = sz[there];
ni[p++] = 1;
printf("%lld\n",(calc(p-1)+calc(p))%MOD);
return 0;
}
|
There is a tree with N vertices, numbered 1 through N. The i-th edge in this tree connects Vertices A_i and B_i and has a length of C_i.
Joisino created a complete graph with N vertices. The length of the edge connecting Vertices u and v in this graph, is equal to the shortest distance between Vertices u and v in the tree above.
Joisino would like to know the length of the longest Hamiltonian path (see Notes) in this complete graph. Find the length of that path.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq A_i < B_i \leq N
* The given graph is a tree.
* 1 \leq C_i \leq 10^8
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{N-1} B_{N-1} C_{N-1}
Output
Print the length of the longest Hamiltonian path in the complete graph created by Joisino.
Examples
Input
5
1 2 5
3 4 7
2 3 3
2 5 2
Output
38
Input
8
2 8 8
1 5 1
4 8 2
2 5 4
3 8 6
6 8 9
2 7 12
Output
132
|
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int MX = 100500;
int sz[MX];
vector<pair<int,int>> e[MX];
void dfs(int u, int pr){
sz[u] = 1;
for(int i = 0; i < e[u].size(); i++){
int v = e[u][i].first;
if(v == pr) continue;
dfs(v, u);
sz[u] += sz[v];
}
}
long long ans = 0;
void dfs2(int u, int pr){
for(int i = 0; i < e[u].size(); i++){
int v = e[u][i].first;
if(v == pr) continue;
long long t = e[u][i].second;
t *= 2 * sz[v];
ans += t;
//cout << u << ' ' << t << endl;
dfs2(v, u);
}
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for(int i = 1; i < n; i++){
int u, v, w;
cin >> u >> v >> w;
u--; v--;
e[u].push_back({v, w});
e[v].push_back({u, w});
}
int mid = (n + 1) / 2;
dfs(0, 0);
int u = 0;
while(true){
bool ok = false;
for(int i = 0; i < e[u].size(); i++){
int v = e[u][i].first;
if(sz[u] < sz[v]) continue;
if(sz[v] >= mid) {u = v; ok = true; break;}
}
if(!ok) break;
}
//cout << u << endl;
dfs(u, u);
dfs2(u, u);
int r2 = 1e9;
for(int i = 0; i < e[u].size(); i++)
r2 = min(r2, e[u][i].second);
for(int i = 0; i < e[u].size(); i++)
if(sz[e[u][i].first] >= mid) r2 = e[u][i].second;
// cout << ans << endl;
cout << ans - r2 << endl;
return 0;
}
|
There are N integers written on a blackboard. The i-th integer is A_i, and the greatest common divisor of these integers is 1.
Takahashi and Aoki will play a game using these integers. In this game, starting from Takahashi the two player alternately perform the following operation:
* Select one integer on the blackboard that is not less than 2, and subtract 1 from the integer.
* Then, divide all the integers on the black board by g, where g is the greatest common divisor of the integers written on the blackboard.
The player who is left with only 1s on the blackboard and thus cannot perform the operation, loses the game. Assuming that both players play optimally, determine the winner of the game.
Constraints
* 1 ≦ N ≦ 10^5
* 1 ≦ A_i ≦ 10^9
* The greatest common divisor of the integers from A_1 through A_N is 1.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
Output
If Takahashi will win, print `First`. If Aoki will win, print `Second`.
Examples
Input
3
3 6 7
Output
First
Input
4
1 2 4 8
Output
First
Input
5
7 8 8 8 8
Output
Second
|
#include <bits/stdc++.h>
using namespace std;
int T,n,m,k,q,a[100010];
int gcd(int x,int y){
return y?gcd(y,x%y):x;
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
int cur=0,o_cnt,e_cnt,pos;
bool flag;
while(true){
o_cnt=e_cnt=flag=0,pos=-1;
for(int i=1;i<=n;i++){
if(a[i]%2==0) o_cnt++;
else pos=i,e_cnt++;
if(a[i]==1) flag=true;
}
if(flag) return puts((o_cnt&1)^cur?"First":"Second"),0;
if(o_cnt&1) return puts(cur?"Second":"First"),0;
if(e_cnt>1&&!(o_cnt&1)) return puts(cur?"First":"Second"),0;
cur^=1;
a[pos]--;
int g=a[1];
for(int i=2;i<=n;i++) g=gcd(a[i],g);
for(int i=1;i<=n;i++) a[i]/=g;
}
}
|
There is a long blackboard with 2 rows and N columns in a classroom of Kyoto University. This blackboard is so long that it is impossible to tell which cells are already used and which unused.
Recently, a blackboard retrieval device was installed at the classroom. To use this device, you type a search query that forms a rectangle with 2 rows and any length of columns, where each cell is used or unused. When you input a query, the decive answers whether the rectangle that corresponds to the query exists in the blackboard. Here, for a rectangle that corresponds to a search query, if two integer i, j ( i < j ) exist and the rectangle equals to the partial blackboard between column i and j , the rectangle is called a sub-blackboard of the blackboard.
You are currently preparing for a presentation at this classroom. To make the presentation go well, you decided to write a program to detect the status of the whole blackboard using the retrieval device. Since it takes time to use the device, you want to use it as few times as possible.
The status of the whole blackboard is already determined at the beginning and does not change while you are using the device.
Input
The first input is given in the following format:
N
N (1 \leq N \leq 100) is an integer that represents the length of the blackboard.
After this input value, your program must print search queries. A search query has the following format.
s_1
s_2
Here, s_1 represents the upper part of the blackboard and s_2 represents the lower. `#` in s_1 and s_2 represents the cell is already used and `.` represents the cell is still unused. The lengths of s_1 and s_2 are arbitrary, but they must be the same. Make sure to insert a line break at the end of the lines.
Every time your program prints a search query, a string that represents the search result of the device is returned in the followin format.
r
r is either `T` or `F` . The meaning of each character is as follows.
* `T` represents that the sub-blackboard that corresponds to the search query exists in the blackboard.
* `F` represents that the sub-blackboard that corresponds to the search query does not exist in the blackboard.
If the search query equals to the whole blackboard or the number of the search queries exceeds the limit, string `end` is given instead of r . Once you receive this string, exit your program immediately. If your program prints the whole blackboard as a search query before exceedin the limit, it is judged as Accepted. Note that the search query that represents the whole blackboard is also counted as the number of search queries.
Example
Input
Output
|
#include<iostream>
#include<vector>
#include<iomanip>
#include<algorithm>
#include<numeric>
#include<cmath>
#include<queue>
#include<set>
#include<map>
using namespace std;
using ulong = unsigned long;
using ll = long long;
const int M = 1e9 + 7;
#pragma unused(M)
int main(){
int n;
cin >> n;
string s1, s2;
char q[2][4] = {
{'.', '.', '#', '#',},
{'.', '#', '.', '#',},
};
string ans;
bool next = false;
//right
while(!next){
s1 += ' '; s2 += ' ';
for(int i=0;i<4;i++){
s1.back() = q[0][i];
s2.back() = q[1][i];
cout << s1 << '\n' << s2 << endl;
cin >> ans;
if(ans == "F"){
if(i == 3){
next = true;
s1.pop_back();
s2.pop_back();
}
continue;
}else if(ans == "T"){
break;
}else{
return 0;
}
}
}
//left
while(1){
s1 = ' ' + s1; s2 = ' ' + s2;
for(int i=0;i<4;i++){
s1[0] = q[0][i];
s2[0] = q[1][i];
cout << s1 << '\n' << s2 << endl;
cin >> ans;
if(ans == "F"){
continue;
}else if(ans == "T"){
break;
}else{
return 0;
}
}
}
}
|
There is a plan view consisting of 12 vertical and 12 horizontal squares showing the terrain. Each square is painted white or black. White represents the sea and black represents the land. When two black squares touch each other vertically or horizontally, they are said to be continuous. In this plan view, the area created by only one black square or a continuous black square is called an "island". For example, in the figure below, there are five islands.
■■■■ □□□□ ■■■■
■■■ □□□□□ ■■■■
■■ □□□□□□ ■■■■
■ □□□□□□□ ■■■■
□□□ ■ □□□ ■ □□□□
□□□□□□ ■■■ □□□
□□□□□ ■■■■■ □□
■ □□□ ■■■■■■■ □
■■ □□□ ■■■■■ □□
■■■ □□□ ■■■ □□□
■■■■ □□□ ■ □□□□
□□□□□□□□□□□□
Create a program that reads the mass data and outputs the number of islands.
Hint
The following shows the sample inputs with ■ and □.
■■■■ □□□□ ■■■■ □ ■ □□□ ■■■■■ □□ □□□□□□□□□□□□
■■■ □□□□□ ■■■■ ■■ □□ ■ □□□□□ ■ □ ■■■■■■■■■■■■
■■ □□□□□□ ■■■■ □ ■ □□ ■ □□□□□□ ■ ■ □□□ ■ □ ■ □□□□ ■
■ □□□□□□□ ■■■■ □ ■ □□□□□□□□□ ■ ■ □□□ ■ □ ■ □□□□ ■
□□□ ■ □□□ ■ □□□□ □ ■ □□□□□□□ ■■ □ ■ □□□ ■ □ ■ □□□□ ■
□□□□□□ ■■■ □□□ □ ■ □□□□ ■■■ □□□ ■ □□□ ■ □ ■ □□□□ ■
□□□□□ ■■■■■ □□ □ ■ □□□□□□□ ■ □□ ■ □□ ■ □□ ■ □□ ■ □ ■
■ □□□ ■■■■■■■ □ □ ■ □□□□□□□□ ■ □ ■ □ ■ □□□□ ■■■ □ ■
■■ □□□ ■■■■■ □□ □ ■ □□□□□□□□□ ■ ■ □□□□□□□□□□ ■
■■■ □□□ ■■■ □□□ □ ■ □□ ■ □□□□□□ ■ ■ □□□□□□□□□□ ■
■■■■ □□□ ■ □□□□ □ ■ □□ ■ □□□□□ ■ □ ■■■■■■■■■■■■
□□□□□□□□□□□□ ■■■ □□ ■■■■■ □□ ■ □□□□□□□□□□ ■
Input
The input consists of multiple datasets. One plan view is given for each dataset. A plan view is represented by 12 rows of 12 number columns, with black squares represented by 1 and white squares represented by 0. The datasets are separated by a single blank line.
The number of datasets does not exceed 20.
Output
Outputs the number of islands on one line for each dataset.
Example
Input
111100001111
111000001111
110000001111
100000001111
000100010000
000000111000
000001111100
100011111110
110001111100
111000111000
111100010000
000000000000
010001111100
110010000010
010010000001
010000000001
010000000110
010000111000
010000000100
010000000010
010000000001
010010000001
010010000010
111001111100
000000000000
111111111111
100010100001
100010100001
100010100001
100010100001
100100100101
101000011101
100000000001
100000000001
111111111111
100000000001
Output
5
13
4
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
using namespace std;
void dfs(vector<string>& m,int i,int j){
int di[]={1,0,-1,0};
int dj[]={0,1,0,-1};
for(int k=0;k<4;++k){
int ni=i+di[k];
int nj=j+dj[k];
if(ni<0||ni>=12||nj<0||nj>=12)continue;
if(m[ni][nj]=='1'){
m[ni][nj]='0';
dfs(m,ni,nj);
}
}
}
int main() {
while(1){
vector<string> m(12);
for(int i=0;i<12;++i){
cin>>m[i];
}
if(m[11].size()!=12)break;
int cnt=0;
for(int i=0;i<12;++i)
for(int j=0;j<12;++j)
if(m[i][j]=='1'){
cnt++;
dfs(m,i,j);
}
cout<<cnt<<endl;
string wl;
//cin>>wl;
}
return 0;
}
|
The neutral city of Eyes City, in the heart of the four countries, is home to the transcontinental train Bandai. The platform has a row of chairs for passengers waiting for the Bandai, and people who enter the platform can use the chairs freely.
The Bandai is cheap, fast and comfortable, so there are a constant number of users from the four surrounding countries. Today is the anniversary of the opening, so I'm thinking of doing something special for the people sitting at home. To do this, you need to know where the people who pass through the ticket gate are sitting. Consider the difficult personalities of people from four countries and create a program that simulates how the chairs are buried. People who pass through the ticket gate sit in a row of chairs one after another. People from four countries have their own personalities and ways of sitting. Each sitting style is as follows.
Personality of Country A | Country A should be able to sit down. Look from the left end and sit in an empty chair.
--- | ---
<image>
Personality of country B | Country B is not good at country A. A Sit in an empty chair from the right end, except next to a national. However, if only the person next to Country A is vacant, be patient and sit in the vacant chair from the left end.
--- | ---
<image> <image>
Personality of C country | C country wants to sit next to a person. Look at the person sitting in order from the left side and try to sit to the right of the person sitting on the far left, but if it is full, try to sit to the left of that person. If it is also filled, try to sit next to the next person under the same conditions. If no one is sitting in any of the chairs, sit in the middle chair (n / 2 + 1 if the number of chairs n is odd (n + 1) / 2).
--- | ---
<image> <image>
Personality of D country | D country does not want to sit next to a person. Trying to sit in the chair that is the closest to the closest person. If you have more than one chair with the same conditions, or if you have to sit next to someone, sit on the leftmost chair. If no one is sitting, sit in the leftmost chair.
--- | ---
<image> <image>
Create a program that takes in the information of the passengers trying to get on the Bandai and outputs how they are sitting in the chair. The nationality of the person sitting in order from the left is output. However, if the seat is vacant, output # (half-width sharp).
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
n m
a1
a2
::
am
The first line gives the number of chairs n (1 ≤ n ≤ 100) and the number of passengers m (m ≤ n). The next m line is given the i-th information ai. ai is a single letter, with'A' representing country A,'B' representing country B,'C' representing country C, and'D' representing country D.
The number of datasets does not exceed 100.
Output
Outputs the final chair status on one line for each dataset.
Example
Input
5 4
A
B
C
D
5 4
D
C
B
A
0 0
Output
ACD#B
DCA#B
|
#include<bits/stdc++.h>
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;
char s[200], a[2];
int main() {
bool b;
int n, m;
while (scanf("%d%d", &n, &m), n) {
memset(s, 0, sizeof(s)); rep(i, n)s[i] = '#';
rep(i, m) {
scanf("%s", a);
switch (a[0]) {
case 'A':
rep(i, n) { if (s[i] == '#') { s[i] = 'A'; break; } }
break;
case 'B':
b = false;
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '#' && (!i || s[i - 1] != 'A') && (i + 1 >= n || s[i + 1] != 'A')) {
b = true; s[i] = 'B'; break;
}
}
if (!b)rep(i, n) { if (s[i] == '#') { s[i] = 'B'; break; } }
break;
case 'C':
b = false;
rep(i, n) {
if (s[i] != '#') {
if (i + 1 < n&&s[i + 1] == '#') { s[i + 1] = 'C'; b = true; break; }
if (i&&s[i - 1] == '#') { s[i - 1] = 'C'; b = true; break; }
}
}
if (!b)s[n / 2] = 'C';
break;
case 'D':
int k, Max = -1;
rep(i, n) {
if (s[i] != '#')continue;
int cnt = INT_MAX;
int t = i - 1;
for (; t >= 0 && s[t] == '#'; t--);
cnt = t == -1 ? INT_MAX : i - t;
t = i + 1;
for (; t < n&&s[t] == '#'; t++);
cnt = min(cnt, t == n ? INT_MAX : t - i);
if (Max < cnt) {
k = i; Max = cnt;
}
}
s[k] = 'D';
break;
}
}
printf("%s\n", s);
}
}
|
You are now in a bookshop with your friend Alice to buy a book, "The Winning Strategy for the Programming Koshien Contest,” just released today. As you definitely want to buy it, you are planning to borrow some money from Alice in case the amount you have falls short of the price. If the amount you receive from Alice still fails to meet the price, you have to abandon buying the book this time.
Write a program to calculate the minimum amount of money you need to borrow from Alice given the following three items of data: the money you and Alice have now and the price of the book.
Input
The input is given in the following format.
m f b
A line containing the three amounts of money is given: the amount you have with you now m (0 ≤ m ≤ 10000), the money Alice has now f (0 ≤ f ≤ 10000) and the price of the book b (100 ≤ b ≤ 20000).
Output
Output a line suggesting the minimum amount of money you need to borrow from Alice. Output "NA" if all the money Alice has with him now is not a sufficient amount for you to buy the book.
Examples
Input
1000 3000 3000
Output
2000
Input
5000 3000 4500
Output
0
Input
500 1000 2000
Output
NA
|
m,a,b=map(int,input().split())
if m>=b:
print(0)
elif m+a<b:
print("NA")
else:
print(b-m)
|
The JOI Railways is the only railway company in the Kingdom of JOI. There are $N$ stations numbered from $1$ to $N$ along a railway. Currently, two kinds of trains are operated; one is express and the other one is local.
A local train stops at every station. For each $i$ ($1 \leq i < N$), by a local train, it takes $A$ minutes from the station $i$ to the station ($i + 1$).
An express train stops only at the stations $S_1, S_2, ..., S_M$ ($1 = S_1 < S_2 < ... < S_M = N$). For each $i$ ($1 \leq i < N$), by an express train, it takes $B$ minutes from the station $i$ to the station ($i + 1$).
The JOI Railways plans to operate another kind of trains called "semiexpress." For each $i$ ($1 \leq i < N$), by a semiexpress train, it takes $C$ minutes from the station $i$ to the station ($i + 1$). The stops of semiexpress trains are not yet determined. But they must satisfy the following conditions:
* Semiexpress trains must stop at every station where express trains stop.
* Semiexpress trains must stop at $K$ stations exactly.
The JOI Railways wants to maximize the number of stations (except for the station 1) to which we can travel from the station 1 within $T$ minutes. The JOI Railways plans to determine the stops of semiexpress trains so that this number is maximized. We do not count the standing time of trains.
When we travel from the station 1 to another station, we can take trains only to the direction where the numbers of stations increase. If several kinds of trains stop at the station $i$ ($2 \leq i \leq N - 1$), you can transfer between any trains which stop at that station.
When the stops of semiexpress trains are determined appropriately, what is the maximum number of stations (except for the station 1) to which we can travel from the station 1 within $T$ minutes?
Task
Given the number of stations of the JOI Railways, the stops of express trains, the speeds of the trains, and maximum travel time, write a program which calculates the maximum number of stations which satisfy the condition on the travel time.
Input
Read the following data from the standard input.
* The first line of input contains three space separated integers $N$, $M$, $K$. This means there are $N$ stations of the JOI Railways, an express train stops at $M$ stations, and a semiexpress train stops at $K$ stations,
* The second line of input contains three space separated integers $A$, $B$, $C$. This means it takes $A$, $B$, $C$ minutes by a local, express, semiexpress train to travel from a station to the next station, respectively.
>li> The third line of input contains an integer $T$. This means the JOI Railways wants to maximize the number of stations (except for the station 1) to which we can travel from the station 1 within $T$ minutes.
* The $i$-th line ($1 \leq i \leq M$) of the following $M$ lines contains an integer $S_i$. This means an express train stops at the station $S_i$.
Output
Write one line to the standard output. The output contains the maximum number of stations satisfying the condition on the travel time.
Constraints
All input data satisfy the following conditions.
* $2 \leq N \leq 1 000 000 000．$
* $2 \leq M \leq K \leq 3 000．$
* $K \leq N．$
* $1 \leq B < C < A \leq 1 000 000 000．$
* $1 \leq T \leq 10^{18}$
* $1 = S_1 < S_2 < ... < S_M = N$
Sample Input and Output
Sample Input 1
10 3 5
10 3 5
30
1
6
10
Sample Output 1
8
In this sample input, there are 10 stations of the JOI Railways. An express train stops at three stations 1, 6, 10. Assume that the stops of an semiexpress train are 1, 5, 6, 8, 10. Then, among the stations 2, 3, ...10, we can travel from the station 1 to every station except for the station 9 within 30 minutes.
For some $i$, the travel time and the route from the station 1 to the station $i$ are as follows:
* From the station 1 to the station 3, we can travel using a local train only. The travel time is 20 minutes.
* From the station 1 to the station 7, we travel from the station 1 to the station 6 by an express train, and transfer to a local train. The travel time is 25 minutes.
* From the station 1 to the station 8, we travel from the station 1 to the station 6 by an express train, and transfer to a semiexpress train. The travel time is 25 minutes.
* From the station 1 to the station 9, we travel from the station 1 to the station 6 by an express train, from the station 6 to the station 8 by a semiexpress train, and from the station 8 to the station 9 by a local train. In total, the travel time is 35 minutes.
Sample Input 2
10 3 5
10 3 5
25
1
6
10
Sample Output 2
7
Sample Input 3
90 10 12
100000 1000 10000
10000
1
10
20
30
40
50
60
70
80
90
Sample Output 2
2
Sample Input 4
12 3 4
10 1 2
30
1
11
12
Sample Output 4
8
Sample Input 5
300 8 16
345678901 123456789 234567890
12345678901
1
10
77
82
137
210
297
300
Sample Output 5
72
Sample Input 6
1000000000 2 3000
1000000000 1 2
1000000000
1
1000000000
Sample Output 6
3000
Creative Commonse License
The 16th Japanese Olympiad in Informatics (JOI 2016/2017) Final Round
Example
Input
10 3 5
10 3 5
30
1
6
10
Output
8
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int64;
int main()
{
int64 N, M, K, A, B, C, T, S[3001];
cin >> N >> M >> K;
cin >> A >> B >> C;
cin >> T;
for(int i = 0; i < M; i++) cin >> S[i];
S[M] = N + 1;
K -= M;
int64 ret = -1;
priority_queue< int64, vector< int64 >, greater< int64 > > que;
for(int i = 0; i < M; i++) {
int64 rest = T - (S[i] - 1) * B;
if(rest < 0) break;
int64 pv = S[i], reach = min(S[i + 1], pv + rest / A + 1);
ret += reach - S[i];
for(int j = 0; j < K && reach < S[i + 1]; j++) {
rest -= (reach - pv) * C;
if(rest < 0) break;
pv = reach;
reach = min(S[i + 1], pv + rest / A + 1);
if(que.size() > K && que.top() >= reach - pv) continue;
que.push(reach - pv);
ret += reach - pv;
if(que.size() > K) ret -= que.top(), que.pop();
}
}
cout << ret << endl;
}
|
You are given N points in the xy-plane. You have a circle of radius one and move it on the xy-plane, so as to enclose as many of the points as possible. Find how many points can be simultaneously enclosed at the maximum. A point is considered enclosed by a circle when it is inside or on the circle.
<image>
Fig 1. Circle and Points
Input
The input consists of a series of data sets, followed by a single line only containing a single character '0', which indicates the end of the input. Each data set begins with a line containing an integer N, which indicates the number of points in the data set. It is followed by N lines describing the coordinates of the points. Each of the N lines has two decimal fractions X and Y, describing the x- and y-coordinates of a point, respectively. They are given with five digits after the decimal point.
You may assume 1 <= N <= 300, 0.0 <= X <= 10.0, and 0.0 <= Y <= 10.0. No two points are closer than 0.0001. No two points in a data set are approximately at a distance of 2.0. More precisely, for any two points in a data set, the distance d between the two never satisfies 1.9999 <= d <= 2.0001. Finally, no three points in a data set are simultaneously very close to a single circle of radius one. More precisely, let P1, P2, and P3 be any three points in a data set, and d1, d2, and d3 the distances from an arbitrarily selected point in the xy-plane to each of them respectively. Then it never simultaneously holds that 0.9999 <= di <= 1.0001 (i = 1, 2, 3).
Output
For each data set, print a single line containing the maximum number of points in the data set that can be simultaneously enclosed by a circle of radius one. No other characters including leading and trailing spaces should be printed.
Example
Input
3
6.47634 7.69628
5.16828 4.79915
6.69533 6.20378
6
7.15296 4.08328
6.50827 2.69466
5.91219 3.86661
5.29853 4.16097
6.10838 3.46039
6.34060 2.41599
8
7.90650 4.01746
4.10998 4.18354
4.67289 4.01887
6.33885 4.28388
4.98106 3.82728
5.12379 5.16473
7.84664 4.67693
4.02776 3.87990
20
6.65128 5.47490
6.42743 6.26189
6.35864 4.61611
6.59020 4.54228
4.43967 5.70059
4.38226 5.70536
5.50755 6.18163
7.41971 6.13668
6.71936 3.04496
5.61832 4.23857
5.99424 4.29328
5.60961 4.32998
6.82242 5.79683
5.44693 3.82724
6.70906 3.65736
7.89087 5.68000
6.23300 4.59530
5.92401 4.92329
6.24168 3.81389
6.22671 3.62210
0
Output
2
5
5
11
|
#include<bits/stdc++.h>
using namespace std;
#define reps(i,f,n) for(int i=f;i<int(n);i++)
#define rep(i,n) reps(i,0,n)
typedef complex<double> P;
vector<P> point;
const double EPS = 0.0000000001;
void init(){
point.clear();
}
bool input(){
int n;
cin>>n;
if(n==0)return false;
rep(i,n){
double a ,b;
cin>>a>>b;
point.push_back(P(a,b));
}
return true;
}
vector<P> make_cand(){
vector<P> ret;
rep(i,point.size()){
reps(j,i+1,point.size()){
P dist = point[j]-point[i];
double d = abs(dist)/2;
if(d>1)continue;
double h = sqrt(1-d*d);
P e = dist/(d*2);
P e1 = e*P(0,1);
P e2 = e*P(0,-1);
P c1 = point[i]+e*d+h*e1;
P c2 = point[i]+e*d+h*e2;
//cout<<"d="<<d<<" h="<<h<<endl;
//cout<<point[i]<<" "<<point[j]<<" "<<c1<<" "<<c2<<endl;
ret.push_back(c1);
ret.push_back(c2);
}
}
rep(i,point.size()){
ret.push_back(point[i]);
}
return ret;
}
int count_in(P p){
int sum = 0;
rep(i,point.size()){
P d = point[i]-p;
if(abs(d)<=1+EPS)sum++;
}
return sum;
}
int solve(){
vector<P> cand = make_cand();
int ans = 0;
rep(i,cand.size()){
ans = max(ans, count_in(cand[i]));
}
return ans;
}
int main(){
while(init(),input()){
printf("%d\n",solve());
}
}
|
Isaac is tired of his daily trip to his ofice, using the same shortest route everyday. Although this saves his time, he must see the same scenery again and again. He cannot stand such a boring commutation any more.
One day, he decided to improve the situation. He would change his route everyday at least slightly. His new scheme is as follows. On the first day, he uses the shortest route. On the second day, he uses the second shortest route, namely the shortest except one used on the first day. In general, on the k-th day, the k-th shortest route is chosen. Visiting the same place twice on a route should be avoided, of course.
You are invited to help Isaac, by writing a program which finds his route on the k-th day. The problem is easily modeled using terms in the graph theory. Your program should find the k-th shortest path in the given directed graph.
Input
The input consists of multiple datasets, each in the following format.
n m k a b
x1 y1 d1
x2 y2 d2
...
xm ym dm
Every input item in a dataset is a non-negative integer. Two or more input items in a line are separated by a space.
n is the number of nodes in the graph. You can assume the inequality 2 ≤ n ≤ 50. m is the number of (directed) edges. a is the start node, and b is the goal node. They are between 1 and n, inclusive. You are required to find the k-th shortest path from a to b. You can assume 1 ≤ k ≤ 200 and a ≠ b.
The i-th edge is from the node xi to yi with the length di (1 ≤ i ≤ m). Both xi and yi are between 1 and n, inclusive. di is between 1 and 10000, inclusive. You can directly go from xi to yi, but not from yi to xi unless an edge from yi to xi is explicitly given. The edge connecting the same pair of nodes is unique, if any, that is, if i ≠ j, it is never the case that xi equals xj and yi equals yj. Edges are not connecting a node to itself, that is, xi never equals yi . Thus the inequality 0 ≤ m ≤ n(n - 1) holds.
Note that the given graph may be quite unrealistic as a road network. Both the cases m = 0 and m = n(n - 1) are included in the judges' data.
The last dataset is followed by a line containing five zeros (separated by a space).
Output
For each dataset in the input, one line should be output as specified below. An output line should not contain extra characters such as spaces.
If the number of distinct paths from a to b is less than k, the string None should be printed. Note that the first letter of None is in uppercase, while the other letters are in lowercase.
If the number of distinct paths from a to b is k or more, the node numbers visited in the k-th shortest path should be printed in the visited order, separated by a hyphen (minus sign). Note that a must be the first, and b must be the last in the printed line.
In this problem the term shorter (thus shortest also) has a special meaning. A path P is defined to be shorter than Q, if and only if one of the following conditions holds.
1. The length of P is less than the length of Q. The length of a path is defined to be the sum of lengths of edges on the path.
2. The length of P is equal to the length of Q, and P's sequence of node numbers comes earlier than Q's in the dictionary order. Let's specify the latter condition more precisely. Denote P's sequence of node numbers by p1, p2,..., ps, and Q's by q1, q2,..., qt. p1 = q1 = a and ps = qt = b should be observed. The sequence P comes earlier than Q in the dictionary order, if for some r (1 ≤ r ≤ s and r ≤ t), p1 = q1,..., pr-1 = qr-1, and pr < qr (pr is numerically smaller than qr).
A path visiting the same node twice or more is not allowed.
Example
Input
5 20 10 1 5
1 2 1
1 3 2
1 4 1
1 5 3
2 1 1
2 3 1
2 4 2
2 5 2
3 1 1
3 2 2
3 4 1
3 5 1
4 1 1
4 2 1
4 3 1
4 5 2
5 1 1
5 2 1
5 3 1
5 4 1
4 6 1 1 4
2 4 2
1 3 2
1 2 1
1 4 3
2 3 1
3 4 1
3 3 5 1 3
1 2 1
2 3 1
1 3 1
0 0 0 0 0
Output
1-2-4-3-5
1-2-3-4
None
|
import java.util.Arrays;
import java.util.BitSet;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
public class Main {
Scanner sc;
Main() {
sc = new Scanner(System.in);
}
int n, m, k, a, b,
c[][] = new int[50][50];
void run() {
for (;;) {
n = sc.nextInt();
m = sc.nextInt();
k = sc.nextInt();
a = sc.nextInt();
b = sc.nextInt();
if ((n | m | k | a -- | b --) == 0) break;
for (int i = 0; i < n; i++) Arrays.fill(c[i], 0, n, INF);
for (int i = 0; i < m; i++) {
int x = sc.nextInt() - 1,
y = sc.nextInt() - 1;
c[x][y] = sc.nextInt();
}
kd();
if (kq.isEmpty()) System.out.println("None");
else {
P p = kq.remove();
int i;
for (i = 0; i < p.p.length - 1; i ++) {
System.out.print(p.p[i] + 1 + "-");
}
System.out.println(p.p[i] + 1);
}
}
}
class P implements Comparable<P> {
int d;
int[] p;
BitSet s;
int x;
P(int a, int[] b) {
d = a;
p = b;
}
@Override
public int compareTo(P t) {
if (t == null) return - 1;
if (d != t.d) return d - t.d;
for (int i = 0; i < p.length; i ++) {
if (i >= t.p.length) break;
if (p[i] != t.p[i]) return p[i] - t.p[i];
}
return p.length - t.p.length;
}
}
P z = new P(0, null);
Queue<P> kq = new PriorityQueue<P>(200 * 50);
void kd() {
kq.clear();
BitSet s = new BitSet(n);
Arrays.fill(d, 0, n, null);
d(a, 0, new int[]{a}, s);
if (d[b] == null) return;
d[b].s = s;
d[b].x = 1;
kq.add(d[b]);
for (int i = 1; i < k; i ++) {
if (kq.isEmpty()) break;
P p = kq.remove();
s = p.s.get(0, n);
s.set(p.p[p.x]);
int op[] = Arrays.copyOf(p.p, p.x);
int od = 0;
Arrays.fill(d, 0, n, null);
for (int j = 2; j <= p.x; j ++) {
od += c[p.p[j - 2]][p.p[j - 1]];
d[p.p[j - 2]] = z;
}
d(p.p[p.x - 1], od, op, s);
if (d[b] != null) {
d[b].s = s;
d[b].x = p.x;
kq.add(d[b]);
}
for (int j = p.x + 1; j < p.p.length; j ++) {
s = new BitSet(n);
s.set(p.p[j]);
op = Arrays.copyOf(p.p, j);
od += c[p.p[j - 2]][p.p[j - 1]];
Arrays.fill(d, 0, n, null);
for (int k = 2; k <= j; k ++) d[p.p[k - 2]] = z;
d(p.p[j - 1], od, op, s);
if (d[b] != null) {
d[b].s = s;
d[b].x = j;
kq.add(d[b]);
}
}
}
}
int INF = 10000 * 50;
P d[] = new P[50];
Queue<P> q = new PriorityQueue<P>(50 * 49);
void a(P p, int f, int t) {
if (c[f][t] >= INF) return;
P np = new P(p.d + c[f][t], Arrays.copyOf(p.p, p.p.length + 1));
np.p[np.p.length - 1] = t;
if (np.compareTo(d[t]) >= 0) return;
d[t] = np;
q.add(d[t]);
}
void d(int a, int od, int[] op, BitSet s) {
q.clear();
d[a] = new P(od, op);
for (int i = 0; i < n; i++) {
if (s.get(i)) continue;
a(d[a], a, i);
}
while (!q.isEmpty()) {
P p = q.remove();
int v = p.p[p.p.length - 1];
if (v == b) break;
if (p.compareTo(d[v]) > 0) continue;
for (int i = 0; i < n; i++) a(p, v, i);
}
}
public static void main(String args[]) {
Main m = new Main();
m.run();
}
}
|
Halting Problem
A unique law is enforced in the Republic of Finite Loop. Under the law, programs that never halt are regarded as viruses. Releasing such a program is a cybercrime. So, you want to make sure that your software products always halt under their normal use.
It is widely known that there exists no algorithm that can determine whether an arbitrary given program halts or not for a given arbitrary input. Fortunately, your products are based on a simple computation model given below. So, you can write a program that can tell whether a given program based on the model will eventually halt for a given input.
The computation model for the products has only one variable $x$ and $N + 1$ states, numbered $1$ through $N + 1$. The variable $x$ can store any integer value. The state $N + 1$ means that the program has terminated. For each integer $i$ ($1 \leq i \leq N$), the behavior of the program in the state $i$ is described by five integers $a_i$, $b_i$, $c_i$, $d_i$ and $e_i$ ($c_i$ and $e_i$ are indices of states).
On start of a program, its state is initialized to $1$, and the value of $x$ is initialized by $x_0$, the input to the program. When the program is in the state $i$ ($1 \leq i \leq N$), either of the following takes place in one execution step:
* if $x$ is equal to $a_i$, the value of $x$ changes to $x + b_i$ and the program state becomes $c_i$;
* otherwise, the value of $x$ changes to $x + d_i$ and the program state becomes $e_i$.
The program terminates when the program state becomes $N + 1$.
Your task is to write a program to determine whether a given program eventually halts or not for a given input, and, if it halts, to compute how many steps are executed. The initialization is not counted as a step.
Input
The input consists of a single test case of the following format.
$N$ $x_0$
$a_1$ $b_1$ $c_1$ $d_1$ $e_1$
.
.
.
$a_N$ $b_N$ $c_N$ $d_N$ $e_N$
The first line contains two integers $N$ ($1 \leq N \leq 10^5$) and $x_0$ ($−10^{13} \leq x_0 \leq 10^{13}$). The number of the states of the program is $N + 1$. $x_0$ is the initial value of the variable $x$. Each of the next $N$ lines contains five integers $a_i$, $b_i$, $c_i$, $d_i$ and $e_i$ that determine the behavior of the program when it is in the state $i$. $a_i$, $b_i$ and $d_i$ are integers between $−10^{13}$ and $10^{13}$, inclusive. $c_i$ and $e_i$ are integers between $1$ and $N + 1$, inclusive.
Output
If the given program eventually halts with the given input, output a single integer in a line which is the number of steps executed until the program terminates. Since the number may be very large, output the number modulo $10^9 + 7$.
Output $-1$ if the program will never halt.
Sample Input 1
2 0
5 1 2 1 1
10 1 3 2 2
Sample Output 1
9
Sample Input 2
3 1
0 1 4 2 3
1 0 1 1 3
3 -2 2 1 4
Sample Output 2
-1
Sample Input 3
3 3
1 -1 2 2 2
1 1 1 -1 3
1 1 4 -2 1
Sample Output 3
-1
Example
Input
2 0
5 1 2 1 1
10 1 3 2 2
Output
9
|
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair < int , int > pii;
typedef pair < LL , int > pli;
typedef pair < int , LL > pil;
typedef pair < LL , LL > pll;
#define mpr make_pair
#define FS first
#define SC second
#define PB push_back
template < typename T > T MAX(T a,T b){return (a>b)?a:b;}
template < typename T > T MIN(T a,T b){return (a<b)?a:b;}
template < typename T > void UMAX(T &a,T b){a=(a>b?a:b);}
template < typename T > void UMIN(T &a,T b){a=(a<b?a:b);}
LL readint(){
char c=getchar();
LL ret=0ll;
while(!(c>='0' && c<='9')) c=getchar();
while(c>='0' && c<='9'){
ret=ret*10ll+(LL)(c-'0');
c=getchar();
}
return ret;
}
void putint(LL v){
if(!v){
putchar('0');
return;
}
if(v>=10ll) putint(v/10ll);
putchar('0'+(v%10ll));
}
const LL MOD=1000000007ll;
int n,th[100005],tl[100005];
LL gh[100005],dh[100005],dl[100005];
LL mymod(LL a,LL b){
if(!b) return a;
if(b<0ll) b=-b;
return (a<0ll?(b-((-a)%b))%b:(a%b));
}
LL iter(LL a,LL b){
if(!b) return 0ll;
if(b<0ll) return iter(-a,-b);
return (a<0ll?(-((-a+b-1)/b)):(a/b));
}
int vis[100005];
vector < pil > stk;
struct grf{
pil out[100005];
vector < pil > in[100005],cycs[100005];
vector < LL > prsum[100005];
vector < int > srs;
int cyccnt,compcnt,incomp[100005],top[100005],udep[100005];
bool oncyc[100005];
LL dep[100005],cyctot[100005];
void adde(int u,int v,LL w){
out[u]=mpr(v,w);
in[v].push_back(mpr(u,w));
}
void dfs(int v){
vis[v]=1;
int u=out[v].FS;
LL w=out[v].SC;
if(u==n || u==-1){
srs.push_back(v);
vis[v]=2;
return;
}
stk.push_back(mpr(v,w));
if(vis[u]==1){
vector < pil > &tar=cycs[cyccnt];
vector < LL > &tarsum=prsum[cyccnt];
int i;
for(i=(int)stk.size()-1;i>=0;--i){
oncyc[stk[i].FS]=1;;
if(stk[i].FS==u) break;
}
// if(i<0){
// printf("forkyou!\n");
// for(int j=0;j<(int)stk.size();++j){
// printf("%d ",stk[j].FS);
// }
// printf("\nexp %d\n",u);
// }
// if(i<0) printf("fuckyou\n");
// assert(i>=0);
tar=vector < pil >(stk.begin()+i,stk.end());
tarsum.resize(tar.size(),0ll);
for(i=1;i<(int)tarsum.size();++i){
tarsum[i]=tar[i-1].SC+tarsum[i-1];
}
cyctot[cyccnt++]=tarsum.back()+tar.back().SC;
}
else if(!vis[u]) dfs(u);
stk.pop_back();
vis[v]=2;
}
void dfs2(int v,LL d,int ud,int tp,int compid){
int i;
top[v]=tp;
dep[v]=d;
udep[v]=ud;
incomp[v]=compid;
for(i=0;i<(int)in[v].size();++i){
int u=in[v][i].FS;
LL w=in[v][i].SC;
if(!oncyc[u])
dfs2(u,d+w,ud+1,tp,compid);
}
}
void build(){
int i,j,k;
memset(vis,0,sizeof(vis));
for(i=0;i<n;++i){
if(!vis[i]) dfs(i);
}
for(i=0;i<(int)srs.size();++i){
dfs2(srs[i],0ll,0,srs[i],compcnt++);
}
for(i=0;i<cyccnt;++i){
int cc=compcnt++;
for(j=0;j<(int)cycs[i].size();++j){
dfs2(cycs[i][j].FS,0ll,0,cycs[i][j].FS,cc);
}
}
}
void print(){
int i,j,k;
printf("Graph:\n");
for(i=0;i<n;++i){
printf("%d->%d [label=%lld];\n",i,out[i].FS,out[i].SC);
}
printf("cyccnt=%d compcnt=%d srcnt=%d\n",cyccnt,compcnt,(int)srs.size());
for(i=0;i<n;++i){
printf("node %d: incomp %d dep %lld udep %d oncyc %d top %d\n",i,incomp[i],dep[i],udep[i],oncyc[i],top[i]);
}
printf("\n");
}
}He,Li;
map < LL , pii > qrs[100005];
map < LL , set < pli > > mp1[100005];
map < LL , set < int > > mp2[100005];
int cycid[100005],cycrk[100005];
pii ansforcyc(int cd,int ent,LL v){
LL bas=v-Li.prsum[cd][ent],itr=iter(bas,Li.cyctot[cd]),dlt=mymod(bas,Li.cyctot[cd]);
set < int >::iterator it2=mp2[cd][bas].lower_bound(ent);
if(it2!=mp2[cd][bas].end()){
int td=*it2;
return mpr(Li.cycs[cd][td].FS,td-ent);
}
if(!Li.cyctot[cd]){
set < pli >::iterator it1=mp1[cd][dlt].lower_bound(mpr(0ll,-1));
if(it1!=mp1[cd][dlt].end()){
int td=it1->SC;
LL itc=it1->FS-itr+1ll;
return mpr(Li.cycs[cd][td].FS,(itc%MOD*(LL)Li.cycs[cd].size()+(LL)(td-ent)+MOD)%MOD);
}
}
else{
set < pli >::iterator it1=mp1[cd][dlt].lower_bound(mpr(itr+1ll,-1));
if(it1!=mp1[cd][dlt].end()){
int td=it1->SC;
LL itc=it1->FS-itr;
return mpr(Li.cycs[cd][td].FS,(itc%MOD*(LL)Li.cycs[cd].size()+(LL)(td-ent)+MOD)%MOD);
}
}
return mpr(-1,0);
}
void precalcyc(int cd,vector < pil > lst,vector < LL > sfts,LL sum){
int i,len=(int)lst.size();
for(i=0;i<len;++i){
int u=lst[i].FS;
LL w=gh[u]-sfts[i];
mp1[cd][mymod(w,sum)].insert(mpr(iter(w,sum),i));
mp2[cd][w].insert(i);
cycid[u]=cd;
cycrk[u]=i;
}
}
set < pair < LL , pii > > curstk;
void dfs(int v){
pair < LL , pii > cur=mpr(gh[v]+Li.dep[v],mpr(-Li.udep[v],v));
curstk.insert(cur);
int i;
for(i=0;i<(int)Li.in[v].size();++i){
int u=Li.in[v][i].FS;
if(cycid[u]==-1) dfs(u);
}
map < LL , pii >::iterator it;
for(it=qrs[v].begin();it!=qrs[v].end();++it){
LL cv=it->FS+Li.dep[v];
set < pair < LL , pii > >::iterator lb=curstk.lower_bound(mpr(cv,mpr(-n,-1)));
if(lb!=curstk.end() && lb->FS==cv){
it->SC.FS=lb->SC.SC;
it->SC.SC=Li.udep[v]-Li.udep[lb->SC.SC];
}
}
curstk.erase(curstk.find(cur));
}
int main(){
int i,j,k;
scanf("%d%lld",&n,gh);
++n;
th[0]=1;
Li.adde(0,1,0ll);
qrs[1][gh[0]+dh[0]]=mpr(-1,0);
for(i=1;i<n;++i){
scanf("%lld%lld%d%lld%d",gh+i,dh+i,th+i,dl+i,tl+i);
Li.adde(i,tl[i],dl[i]);
qrs[th[i]][gh[i]+dh[i]]=mpr(-1,0);
}
Li.build();
memset(cycid,-1,sizeof(cycid));
for(i=0;i<Li.cyccnt;++i){
precalcyc(i,Li.cycs[i],Li.prsum[i],Li.cyctot[i]);
}
for(i=0;i<(int)Li.srs.size();++i){
cycid[Li.srs[i]]=-2;
}
for(i=0;i<n;++i){
if(cycid[i]!=-1){
dfs(i);
}
}
for(i=0;i<n;++i){
map < LL , pii >::iterator it;
for(it=qrs[i].begin();it!=qrs[i].end();++it){
if(it->SC.FS==-1){
if(cycid[Li.top[i]]==-2){
it->SC.FS=n;
it->SC.SC=Li.udep[i]+1;
}
else{
it->SC=ansforcyc(cycid[Li.top[i]],cycrk[Li.top[i]],it->FS+Li.dep[i]);
(it->SC.SC+=Li.udep[i])%=MOD;
}
}
}
}
for(i=0;i<n;++i){
int v=th[i];
LL nx=gh[i]+dh[i];
pii pt=qrs[v][nx];
// printf("heavier outer of %d = (%d,%d) %d %lld\n",i,pt.FS,pt.SC,v,nx);
if(v==n)
He.adde(i,n,1ll);
else
He.adde(i,pt.FS,(pt.SC+1)%MOD);
}
He.build();
int tp=He.top[0],tdis=(He.dep[0]+He.out[tp].SC)%MOD;
if(He.out[tp].FS==n)
printf("%d\n",(int)((tdis+MOD-1ll)%MOD));
else
printf("-1\n");
// Li.print();
// He.print();
return 0;
}
/*
* 代码框架
* 0. 实现负数取模（除数取abs）
* 0. 将重边终点处的权值按点组织，用map存储。稍后修改此map。
* 1. 实现带权基环树森林struct，无前驱可记为-1或n
* 实现加边、标记环点、拆出环vecs和根集合、标记连通块编号、计算每个点带权/不带权深度、计算每个点上方环点
* 2. 将轻边建出基环树森林，预处理每个环点的校准值。
* 实现map<ll,set<pli>>维护初值到循环、编号二元组的映射
* 实现map<pll,set<int>>维护循环、初值二元组到编号集合的映射
* 2. 实现函数，给定环编号、进入点、进入值，返回终止点和经过步数（取模，exclusive）
* 3. 建立重边基环树森林，稍作判定
* 4. 初始时建新点。别忘记特判n+1。
*/
|
For Programming Excellence
A countless number of skills are required to be an excellent programmer. Different skills have different importance degrees, and the total programming competence is measured by the sum of products of levels and importance degrees of his/her skills.
In this summer season, you are planning to attend a summer programming school. The school offers courses for many of such skills. Attending a course for a skill, your level of the skill will be improved in proportion to the tuition paid, one level per one yen of tuition, however, each skill has its upper limit of the level and spending more money will never improve the skill level further. Skills are not independent: For taking a course for a skill, except for the most basic course, you have to have at least a certain level of its prerequisite skill.
You want to realize the highest possible programming competence measure within your limited budget for tuition fees.
Input
The input consists of no more than 100 datasets, each in the following format.
> n k
> h1 ... hn
> s1 ... sn
> p2 ... pn
> l2 ... ln
>
* The first line has two integers, n, the number of different skills between 2 and 100, inclusive, and k, the budget amount available between 1 and 105, inclusive. In what follows, skills are numbered 1 through n.
* The second line has n integers h1...hn, in which hi is the maximum level of the skill i, between 1 and 105, inclusive.
* The third line has n integers s1...sn, in which si is the importance degree of the skill i, between 1 and 109, inclusive.
* The fourth line has n−1 integers p2...pn, in which pi is the prerequisite skill of the skill i, between 1 and i−1, inclusive. The skill 1 has no prerequisites.
* The fifth line has n−1 integers l2...ln, in which li is the least level of prerequisite skill pi required to learn the skill i, between 1 and hpi , inclusive.
The end of the input is indicated by a line containing two zeros.
Output
For each dataset, output a single line containing one integer, which is the highest programming competence measure achievable, that is, the maximum sum of the products of levels and importance degrees of the skills, within the given tuition budget, starting with level zero for all the skills. You do not have to use up all the budget.
Sample Input
3 10
5 4 3
1 2 3
1 2
5 2
5 40
10 10 10 10 8
1 2 3 4 5
1 1 2 3
10 10 10 10
5 10
2 2 2 5 2
2 2 2 5 2
1 1 2 2
2 1 2 1
0 0
Output for the Sample Input
18
108
35
Example
Input
3 10
5 4 3
1 2 3
1 2
5 2
5 40
10 10 10 10 8
1 2 3 4 5
1 1 2 3
10 10 10 10
5 10
2 2 2 5 2
2 2 2 5 2
1 1 2 2
2 1 2 1
0 0
Output
18
108
35
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef int _loop_int;
#define REP(i,n) for(_loop_int i=0;i<(_loop_int)(n);++i)
#define FOR(i,a,b) for(_loop_int i=(_loop_int)(a);i<(_loop_int)(b);++i)
#define FORR(i,a,b) for(_loop_int i=(_loop_int)(b)-1;i>=(_loop_int)(a);--i)
#define CHMIN(a,b) a=min((a),(b))
#define CHMAX(a,b) a=max((a),(b))
int n,k;
int h[125252], s[125252], p[125252], l[125252];
int m[125];
int children[125][125];
ll arr[125][125252];
ll beg[125252];
ll tmp[125252];
int di[125252];
ll dv[125252];
void lk(int w, ll *v, ll a, ll n, ll *ret){
REP(i,w+1)ret[i] = v[i];
int s = 0, t = 0;
REP(i,w+1){
ll v = ret[i] - i*a;
while(s<t && dv[t-1] <= v)t--;
di[t] = i;
dv[t] = v;
t++;
ret[i] = dv[s] + i*a;
if(di[s] == i-n)s++;
}
}
void dfs(int p, int w, ll *iv){
// use s[p], max h[p]
lk(w, iv, s[p], h[p], arr[p]);
// children
REP(i,m[p]){
int c = children[p][i];
dfs(c, w-l[c], iv);
iv = arr[c];
ll adv = (ll)l[c] * s[p];
lk(w, iv, s[p], h[p]-l[c], tmp);
REP(i,w+1-l[c])CHMAX(arr[p][i+l[c]], tmp[i]+adv);
}
}
int main(){
while(true){
scanf("%d%d", &n, &k);
if(n==0 && k==0)break;
REP(i,n)scanf("%d",h+i);
REP(i,n)scanf("%d",s+i);
FOR(i,1,n)scanf("%d",p+i), p[i]--;
FOR(i,1,n)scanf("%d",l+i);
REP(i,n)m[i] = 0;
FOR(i,1,n)children[p[i]][m[p[i]]++] = i;
REP(i,n)sort(children[i], children[i]+m[i], [&](int a,int b){
return l[a] < l[b];
});
dfs(0, k, beg);
printf("%lld\n", arr[0][k]);
}
return 0;
}
|
Andrew R. Klein resides in the city of Yanwoe, and goes to his working place in this city every weekday. He has been totally annoyed with the road traffic of this city. All the roads in this city are one-way, so he has to drive a longer way than he thinks he need.
One day, the following thought has come up to Andrew’s mind: “How about making the sign of one road indicate the opposite direction? I think my act won’t be out as long as I change just one sign. Well, of course I want to make my route to the working place shorter as much as possible. Which road should I alter the direction of?” What a clever guy he is.
You are asked by Andrew to write a program that finds the shortest route when the direction of up to one road is allowed to be altered. You don’t have to worry about the penalty for complicity, because you resides in a different country from Andrew and cannot be punished by the law of his country. So just help him!
Input
The input consists of a series of datasets, each of which is formatted as follows:
N
S T
M
A1 B1
A2 B2
...
AM BM
N denotes the number of points. S and T indicate the points where Andrew’s home and working place are located respectively. M denotes the number of roads. Finally, Ai and Bi indicate the starting and ending points of the i-th road respectively. Each point is identified by a unique number from 1 to N. Some roads may start and end at the same point. Also, there may be more than one road connecting the same pair of starting and ending points.
You may assume all the following: 1 ≤ N ≤ 1000, 1 ≤ M ≤ 10000, and S ≠ T.
The input is terminated by a line that contains a single zero. This is not part of any dataset, and hence should not be processed.
Output
For each dataset, print a line that contains the shortest distance (counted by the number of passed roads) and the road number whose direction should be altered. If there are multiple ways to obtain the shortest distance, choose one with the smallest road number. If no direction change results in a shorter route, print 0 as the road number.
Separate the distance and the road number by a single space. No extra characters are allowed.
Example
Input
4
1 4
4
1 2
2 3
3 4
4 1
0
Output
1 4
|
#include<bits/stdc++.h>
#define MAX 1005
#define INF 123456789
using namespace std;
struct edge{int to;int cost;};
typedef pair<int,int> P;
int V;
vector<edge> G[MAX];
int d[MAX];
void dkstr(int s){
priority_queue<P,vector<P>,greater<P> >que;
fill(d,d+V,INF);
d[s]=0;
que.push(P(0,s));
while(!que.empty()){
P p=que.top();que.pop();
int v=p.second;
if(d[v]<p.first)continue;
for(int i=0;i<G[v].size();i++){
edge e = G[v][i];
if(d[e.to]>d[v]+e.cost){
d[e.to]=d[v]+e.cost;
//cout << d[e.to]<< endl;
que.push(P(d[e.to],e.to));
}
}
}
}
int main(){
while(1){
for(int i=0;i<MAX;i++){
G[i].clear();
}
int s,g,m;
int mp=0;
cin >> V ;
if(V==0)break;
cin >> s >> g >> m;
s--;
g--;
vector<P> ed(m);
for(int i=0;i<m;i++){
int b,e;
cin >> b >> e;
b--;
e--;
ed[i].first=b;
ed[i].second=e;
edge bu;
bu.to=e;
bu.cost=1;
G[b].push_back(bu);
}
dkstr(s);
int ma=d[g];
//cout << ma << endl;
int od[MAX];
for(int i=0;i<MAX;i++){
od[i]=d[i];
}
for(int i=0;i<m;i++){
if(od[ed[i].second]<od[ed[i].first]){
G[ed[i].second].push_back({ed[i].first,1});
dkstr(s);
int maa=ma;
ma=min(ma,d[g]);
if(maa!=ma){
mp=i+1;
}
G[ed[i].second].pop_back();
}
}
cout << ma << " " << mp << endl;
}
return 0;
}
|
Training is indispensable for achieving good results at ICPC. Rabbit wants to win at ICPC, so he decided to practice today as well.
Today's training is to develop physical strength and judgment by running on a straight road. The rabbit is now standing at the starting line and looking out over a long, long road.
There are some carrots along the way, and rabbits can accelerate by eating carrots. Rabbits run at U meters per second when not accelerating, but by eating carrots, the speed is V meters per second from the last carrot eaten to T seconds later. Rabbits can also carry up to K carrots without eating them. Even if you have a carrot, the running speed does not change.
Assuming that it does not take long to bring and eat carrots, I would like to find the shortest time required to reach the goal.
Input
N K T U V L
D1
...
DN
N is the number of carrots, L is the distance from the start to the goal (meters), and Di (1 ≤ i ≤ N) is the distance from the start where the i-th carrot is located (meters).
1 ≤ N ≤ 200, 1 ≤ K ≤ N, 1 ≤ T ≤ 10,000, 1 ≤ U <V ≤ 10,000, 2 ≤ L ≤ 10,000, 0 <D1 <D2 <... <DN <L. All input values are integers.
Output
Output the shortest required time (seconds) on one line. Absolute errors of 10-6 or less are allowed.
Examples
Input
1 1 1 2 3 100
50
Output
49.500000000
Input
3 1 1 2 3 100
49
50
51
Output
48.666666667
|
#include<bits/stdc++.h>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) for(int i = 0; i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define show(x) cerr << #x << " = " << (x) << endl;
using namespace std;
const double EPS = 1e-9;
int main(){
int n;
double k, t, u, v, l;
cin >> n >> k >> t >> u >> v >> l;
double c[205];
rep(i,n) cin >> c[i];
c[n] = l;
double m, h, s; //?????¨???????????????????????°????????????????????????
double time = 0;
int i = 0;
while(m < l){
double next = c[i] - m;
if((h > 0 && s < EPS) || h > k){
h--;
s = t;
}else if(h == 0 && s < EPS){
time += next / u;
m += next;
i++;
h++;
}else if(s > EPS){
if(next / v <= s){
s -= next / v;
time += next / v;
m += next;
i++;
h++;
}else{
m += s * v;
time += s;
s = 0;
}
}
}
cout <<fixed << setprecision(8) << time << endl;
}
|
In the year 20XX, mankind is hit by an unprecedented crisis. The power balance between the sun and the moon was broken by the total eclipse of the sun, and the end is looming! To save the world, the secret society called "Sun and Moon" decided to perform the ritual to balance the power of the sun and the moon called "Ritual of Sun and Moon".
The ritual consists of "Ritual of Sun" and "Ritual of Moon". "Ritual of Moon" is performed after "Ritual of Sun". A member of the society is divided into two groups, "Messengers of Sun" and "Messengers of Moon". Each member has some offerings and magic power.
First, the society performs "Ritual of Sun". In the ritual, each member sacrifices an offering. If he can not sacrifice an offering here, he will be killed. After the sacrifice, his magic power is multiplied by the original number of his offerings. Each member must perform the sacrifice just once.
Second, the society performs "Ritual of Moon". In the ritual, each member sacrifices all remaining offerings. After the sacrifice, his magic power is multiplied by xp. Here x is the number of days from the eclipse (the eclipse is 0th day) and p is the number of his sacrificed offerings. Each member must perform the sacrifice just once.
After two rituals, all "Messengers of Sun" and "Messengers of Moon" give all magic power to the "magical reactor". If the total power of "Messengers of Sun" and the total power of "Messengers of Moon" are equal, the society will succeed in the ritual and save the world.
It is very expensive to perform "Ritual of Sun". It may not be able to perform "Ritual of Sun" because the society is in financial trouble. Please write a program to calculate the minimum number of days from the eclipse in which the society can succeed in "Ritual of Sun and Moon" whether "Ritual of Sun" can be performed or not. The society cannot perform the ritual on the eclipse day (0-th day).
Input
The format of the input is as follows.
> N
> O1 P1
> ...
> ON PN
>
The first line contains an integer N that is the number of members of the society (0 ≤ N ≤ 1,000).
Each of the following N lines contains two integers Oi (0 ≤ Oi ≤ 1,000,000,000) and Pi (1 ≤ |Pi| ≤ 1,000,000,000,000,000). Oi is the number of the i-th member's offerings and |Pi| is the strength of his magic power. If Pi is a positive integer, the i-th member belongs to "Messengers of Sun", otherwise he belongs to "Messengers of Moon".
Output
If there exists the number of days from the eclipse that satisfies the above condition , print the minimum number of days preceded by "Yes ". Otherwise print "No".
Of course, the answer must be a positive integer.
Examples
Input
9
2 1
1 -1
1 -1
1 -1
1 -1
0 1
0 1
0 1
0 1
Output
Yes 2
Input
2
1 1
0 -1
Output
No
|
#include<map>
#include<cmath>
#include<cstdio>
#include<vector>
#include<algorithm>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
ll gcd(ll a,ll b){ return b?gcd(b,a%b):a; }
ll fast_modmul(ll a,ll b,ll m){
return (((a*(b>>20)%m)<<20)+a*(b&((1<<20)-1)))%m;
}
ll fast_modpow(ll a,ll n,ll m){
ll r=1;
for(ll x=a%m;n;n>>=1,x=(x*x)%m) if(n&1) r=(r*x)%m;
return r;
}
ll modmul(ll a,ll b,ll m){
ll r=0;
for(;b;b>>=1,a=(a<<1)%m) if(b&1) r=(r+a)%m;
return r;
}
ll modpow(ll a,ll n,ll m){
ll r=1;
for(ll x=a%m;n;n>>=1,x=modmul(x,x,m)) if(n&1) r=modmul(r,x,m);
return r;
}
bool Miller_Rabin(ll n){
if(n<=1) return false;
if(!(n&1)) return n==2;
if(n%3==0) return n==3;
int s=0; // n-1 = 2^s * d (d: odd)
ll d=n-1;
while(!(d&1)) s++, d>>=1;
const static ll a[]={2,3,5,7,11,13,17,19,23};
rep(i,sizeof a/sizeof(ll)){
if(a[i]>=n) break;
ll x=modpow(a[i],d,n);
if(x==1 || x==n-1) continue;
bool b=false;
for(int r=1;r<s;r++){
x=modmul(x,x,n);
if(x== 1 ) return false;
if(x==n-1){ b=true; break; }
}
if(!b) return false;
}
return true;
}
ll Pollard_rho(ll n,int c){
if((n&1)==0) return 2;
ll x=2,y=2,d=1;
while(d==1){
x=modmul(x,x,n)+c; if(x<0) x+=n;
y=modmul(y,y,n)+c; if(y<0) y+=n;
y=modmul(y,y,n)+c; if(y<0) y+=n;
d=gcd(llabs(x-y),n);
}
return d<n?d:-1;
}
void prime_factorize(ll n,map<ll,int> &pf){
if(n<=1) return;
if(Miller_Rabin(n)){ ++pf[n]; return; }
ll d;
for(int c=1;;c++){
d=Pollard_rho(n,c);
if(d!=-1) break;
}
prime_factorize( d ,pf);
prime_factorize(n/d,pf);
}
void dfs(int i,ll a,const vector< pair<ll,int> > &pf,vector<ll> &res){
if(i==pf.size()){
res.push_back(a);
return;
}
dfs(i+1,a,pf,res);
rep(j,pf[i].second){
a*=pf[i].first;
dfs(i+1,a,pf,res);
}
}
const ll M=1000000007;
int main(){
int n; scanf("%d",&n);
ll o[1000],p[1000];
rep(i,n) scanf("%lld%lld",o+i,p+i);
rep(i,n){
rep(j,i) if(o[i]==o[j]) {
p[j]+=p[i];
swap(o[i],o[n-1]);
swap(p[i],p[n-1]);
i--;
n--;
break;
}
}
// 多項式 Σ p[i] * x^o[i] の正の重根を求めればよい
// 0 は答えじゃないので x^hoge で割って定数項が見えるようにする
ll o_min=*min_element(o,o+n);
rep(i,n) o[i]-=o_min;
ll c; // 定数項
rep(i,n) if(o[i]==0) c=p[i];
map<ll,int> pf;
prime_factorize(llabs(c),pf);
vector<ll> d; // c の約数全体
vector< pair<ll,int> > pf2(pf.begin(),pf.end());
dfs(0,1,pf2,d);
sort(d.begin(),d.end());
rep(i,d.size()){
ll x=d[i];
if(x>M) break; // 大きい約数はどうせ答えじゃないので見ない ( TLE がきつい!! )
ll val1=0,val2=0;
rep(i,n){
ll q=llabs(p[i])%M;
int sgn=(p[i]>0?1:-1);
val1=(val1+sgn*fast_modmul(q,fast_modpow(x%M,o[i],M),M)+M)%M;
if(o[i]>0){
val2=(val2+sgn*fast_modmul(fast_modmul(o[i],q,M),fast_modpow(x%M,o[i]-1,M),M)+M)%M;
}
}
if(val1==0 && val2==0){ printf("Yes %lld\n",x); return 0; }
}
puts("No");
return 0;
}
|
Nathan O. Davis has been running an electronic bulletin board system named JAG-channel. He is now having hard time to add a new feature there --- threaded view.
Like many other bulletin board systems, JAG-channel is thread-based. Here a thread (also called a topic) refers to a single conversation with a collection of posts. Each post can be an opening post, which initiates a new thread, or a reply to a previous post in an existing thread.
Threaded view is a tree-like view that reflects the logical reply structure among the posts: each post forms a node of the tree and contains its replies as its subnodes in the chronological order (i.e. older replies precede newer ones). Note that a post along with its direct and indirect replies forms a subtree as a whole.
Let us take an example. Suppose: a user made an opening post with a message `hoge`; another user replied to it with `fuga`; yet another user also replied to the opening post with `piyo`; someone else replied to the second post (i.e. `fuga`”) with `foobar`; and the fifth user replied to the same post with `jagjag`. The tree of this thread would look like:
hoge
├─fuga
│ ├─foobar
│ └─jagjag
└─piyo
For easier implementation, Nathan is thinking of a simpler format: the depth of each post from the opening post is represented by dots. Each reply gets one more dot than its parent post. The tree of the above thread would then look like:
hoge
.fuga
..foobar
..jagjag
.piyo
Your task in this problem is to help Nathan by writing a program that prints a tree in the Nathan's format for the given posts in a single thread.
Input
Input contains a single dataset in the following format:
n
k_1
M_1
k_2
M_2
:
:
k_n
M_n
The first line contains an integer n (1 ≤ n ≤ 1,000), which is the number of posts in the thread. Then 2n lines follow. Each post is represented by two lines: the first line contains an integer k_i (k_1 = 0, 1 ≤ k_i < i for 2 ≤ i ≤ n) and indicates the i-th post is a reply to the k_i-th post; the second line contains a string M_i and represents the message of the i-th post. k_1 is always 0, which means the first post is not replying to any other post, i.e. it is an opening post.
Each message contains 1 to 50 characters, consisting of uppercase, lowercase, and numeric letters.
Output
Print the given n messages as specified in the problem statement.
Sample Input 1
1
0
icpc
Output for the Sample Input 1
icpc
Sample Input 2
5
0
hoge
1
fuga
1
piyo
2
foobar
2
jagjag
Output for the Sample Input 2
hoge
.fuga
..foobar
..jagjag
.piyo
Sample Input 3
8
0
jagjag
1
hogehoge
1
buhihi
2
fugafuga
4
ponyoponyo
5
evaeva
4
nowawa
5
pokemon
Output for the Sample Input 3
jagjag
.hogehoge
..fugafuga
...ponyoponyo
....evaeva
....pokemon
...nowawa
.buhihi
Sample Input 4
6
0
nakachan
1
fan
2
yamemasu
3
nennryou2
4
dannyaku4
5
kouzai11
Output for the Sample Input 4
nakachan
.fan
..yamemasu
...nennryou2
....dannyaku4
.....kouzai11
Sample Input 5
34
0
LoveLive
1
honoka
2
borarara
2
sunohare
2
mogyu
1
eri
6
kasikoi
7
kawaii
8
eriichika
1
kotori
10
WR
10
haetekurukotori
10
ichigo
1
umi
14
love
15
arrow
16
shoot
1
rin
18
nyanyanya
1
maki
20
6th
20
star
22
nishikino
1
nozomi
24
spiritual
25
power
1
hanayo
27
darekatasukete
28
chottomattete
1
niko
30
natsuiro
30
nikkonikkoni
30
sekaino
33
YAZAWA
Output for the Sample Input 5
LoveLive
.honoka
..borarara
..sunohare
..mogyu
.eri
..kasikoi
...kawaii
....eriichika
.kotori
..WR
..haetekurukotori
..ichigo
.umi
..love
...arrow
....shoot
.rin
..nyanyanya
.maki
..6th
..star
...nishikino
.nozomi
..spiritual
...power
.hanayo
..darekatasukete
...chottomattete
.niko
..natsuiro
..nikkonikkoni
..sekaino
...YAZAWA
Sample Input 6
6
0
2ch
1
1ostu
1
2get
1
1otsu
1
1ostu
3
pgr
Output for the Sample Input 6
2ch
.1ostu
.2get
..pgr
.1otsu
.1ostu
Example
Input
1
0
icpc
Output
icpc
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <utility>
#define REP(i,a,b) for(int i=int(a);i<int(b);i++)
using namespace std;
typedef long long int lli;
typedef pair<string, int> psi;
void print(vector<vector<psi>> &sl, int fst = 0, int depth = 0) {
REP (i, 0, sl[fst].size()) {
REP (j, 0, depth) cout << '.';
cout << sl[fst][i].first << endl;
print(sl, sl[fst][i].second, depth + 1);
}
}
int main () {
int n;
cin >> n;
vector<vector<psi>> slist(n + 1);
REP (i, 0, n) {
int k;
string s;
cin >> k >> s;
slist[k].push_back({s, i + 1});
}
print(slist);
return 0;
}
|
Problem statement
Cards with ranks of $ 2 $ and $ 8 $ are powerful in card game millionaires. Therefore, we call an integer consisting of only the numbers $ 2 $ and $ 8 $ in $ 10 $ decimal notation a good integer. The best integers are listed from the smallest to $ 2, 8, 22, 28, 82, 88, \ cdots $.
Let $ n $ be a positive integer. When $ n $ can be expressed in the form of a product of good integers, find the maximum product. If you can't, output $ -1 $.
Constraint
$ 1 \ leq n \ leq 10 ^ {18} $
sample
Sample input 1
1
Sample output 1
-1
Sample input 2
2
Sample output 2
1
Sample input 3
88
Sample output 3
3
It can be expressed as $ 2 \ times 2 \ times 22 $.
Sample input 4
100
Sample output 4
-1
Sample input 5
173553147234869248
Sample output 5
11
It can be expressed as $ 2 ^ 6 \ times 28 \ times 2222 ^ 3 \ times 8828 $.
input
$ n $
output
Print the answer on the $ 1 $ line.
Example
Input
1
Output
-1
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll INF = 1LL << 28;
ll N;
vector<ll> num;
map<ll,ll> memo;
queue<ll> q;
function<ll(ll)> seki;
int main() {
cin >> N;
q.push(2LL); q.push(8LL);
while (q.size()) {
ll n = q.front(); q.pop();
num.push_back(n);
if (n <= 1e18) {
q.push(n * 10LL + 8LL);
q.push(n * 10LL + 2LL);
}
}
sort(num.begin(), num.end());
seki = [&](ll n) -> ll {
if (memo.find(n) != memo.end()) return memo[n];
int i = (int)(lower_bound(num.begin(), num.end(), n) - num.begin());
memo[n] = -INF;
if (num[i] == n) memo[n] = 1;
for (; i > -1; i--) {
if (n % num[i] == 0 ) {
memo[n] = max(memo[n], seki(n / num[i]) + seki(num[i]));
}
}
return memo[n];
};
int ans = seki(N);
if (ans > 0) cout << ans << endl;
else cout << -1 << endl;
return 0;
}
|
Santa is going to pack gifts into a bag for a family. There are $N$ kinds of gifts. The size and the price of the $i$-th gift ($1 \leq i \leq N$) are $s_i$ and $p_i$, respectively. The size of the bag is $C$, thus Santa can pack gifts so that the total size of the gifts does not exceed $C$. Children are unhappy if they are given multiple items of the same kind gift, so Santa has to choose at most one gift of the same kind per child.
In addition, if a child did not receive a gift that the other children in the same family receive, he/she will complain about that. Hence Santa must distribute gifts fairly to all the children of a family, by giving the same set of gifts to each child. In other words, for a family with $k$ children, Santa must pack zero or $k$ items for each kind of gifts. Santa gives one bag to one family, therefore, the total size of the gifts for each family does not exceed $C$.
Santa wants to maximize the total price of packed items for a family but does not know the number of children in the family he is going to visit yet. The number seems at most $M$. To prepare all the possible cases, calculate the maximum total price of items for a family with $k$ children for each $1 \leq k \leq M$.
Input
The input consists of a single test case in the following format.
$C$ $N$ $M$
$s_1$ $p_1$
$...$
$s_N$ $p_N$
The first line contains three integers $C$, $N$ and $M$, where $C$ ($1 \leq C \leq 10^4$) is the size of the bag, $N$ ($1 \leq N \leq 10^4$) is the number of kinds of the gifts, and $M$ ($1 \leq M \leq 10^4$) is the maximum number of children in the family. The $i$-th line of the following $N$ lines contains two integers $s_i$ and $p_i$ ($1 \leq s_i, p_i \leq 10^4$), where $s_i$ and $p_i$ are the size and the price of the $i$-th gift, respectively.
Output
The output should consist of $M$ lines. In the $k$-th line, print the maximum total price of gifts for a family with $k$ children.
Examples
Input
6 3 2
1 2
2 10
3 5
Output
17
24
Input
200 5 5
31 41
59 26
53 58
97 93
23 84
Output
235
284
375
336
420
Input
1 1 2
1 1
Output
1
0
Input
2 2 2
1 1
2 100
Output
100
2
|
#include<bits/stdc++.h>
using namespace std;
#define INF (1<<28)
#define DEKAI 1000000007
#define FDST int hogehoge;cin>>hogehoge;
int main(){
int c,n,m;
int gv[10000],gs[10000];
int a[10001];
int ans[10001];
cin>>c>>n>>m;
for(int i=0;i<n;i++){
cin>>gs[i]>>gv[i];
}
for(int i=0;i<c+1;i++){
a[i]=-1;
}
a[0]=0;
for(int i=0;i<n;i++){
for(int j=c+1-gs[i];j>=0;j--){
if(a[j]!=-1) a[j+gs[i]]=max(a[j+gs[i]],a[j]+gv[i]);
}
}
ans[0]=0;
for(int i=1;i<c+1;i++){
if(ans[i-1]<a[i]) ans[i]=a[i];
else ans[i]=ans[i-1];
}
for(int i=0;i<m;i++){
cout<<ans[c/(i+1)]*(i+1)<<endl;
}
return 0;
}
|
Problem
If you bring an empty bottle of $ a $ milk, you can exchange it for a new bottle of $ b $ milk.
How many bottles of milk can Mr. Kawabayashi, who initially has a bottle of $ x $ milk, drink? Output the remainder after dividing by $ 1000000007 $.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq a \ leq 10 ^ {15} $
* $ 0 \ leq b \ lt a $
* $ 0 \ leq x \ leq 10 ^ {15} $
Input
The input is given in the following format.
$ a $ $ b $ $ x $
Three integers $ a $, $ b $, $ x $ are given, separated by spaces.
Output
Print the answer on one line.
Examples
Input
3 1 5
Output
7
Input
3 2 5
Output
11
Input
82 69 64
Output
64
Input
316250877917604 316250877917599 681260158257385
Output
62687552
|
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cctype>
#include<math.h>
#include<string>
#include<string.h>
#include<stack>
#include<queue>
#include<vector>
#include<utility>
#include<set>
#include<map>
#include<stdlib.h>
#include<iomanip>
using namespace std;
#define ll long long
#define ld long double
#define EPS 0.0000000001
#define INF 1e9
#define LINF (ll)INF*INF
#define MOD 1000000007
#define rep(i,n) for(int i=0;i<(n);i++)
#define loop(i,a,n) for(int i=a;i<(n);i++)
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
#define int ll //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int,int> pii;
typedef vector<pii> vp;
int gcd(int a, int b){
if(b==0) return a;
return gcd(b,a%b);
}
int lcm(int a, int b){
return a/gcd(a,b)*b;
}
signed main(void) {
int a,b,x;
cin >> a >> b >> x;
if(x < b){
cout << x%MOD << endl;
}else{
int n = (x-b)/(a-b);
n %= MOD;
b %= MOD;
x %= MOD;
cout << (x + b*n)%MOD << endl;
}
}
|
For given three points p1, p2, p, find the reflection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the reflection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 -1.0000000000
0.0000000000 -1.0000000000
1.0000000000 -1.0000000000
Input
0 0 3 4
3
2 5
1 4
0 3
Output
4.2400000000 3.3200000000
3.5600000000 2.0800000000
2.8800000000 0.8400000000
|
#include <iostream>
#include <complex>
#include <cstdio>
using namespace std;
#define REP(i,n) for(int i = 0; i < (int)(n); ++i)
#define FOR(i,a,b) for(int i = (a); i < (int)(b); ++i)
#define ALL(c) (c).begin(), (c).end()
#define SIZE(v) ((int)v.size())
typedef complex<double> P;
// ??????
double dot(const P& a, const P& b) {
return real(conj(a)*b);
}
// ???p2?????????p0, p1???????????´???????°???±?????????
P projection(const P& p0, const P& p1, const P& p2) {
// ???????????????????????´???
P vec1 = p1 - p0;
P vec2 = p2 - p0;
return p0 + vec1 * dot(vec1, vec2) / dot(vec1, vec1);
}
// ???p0, p1???????????´??????????§°?????¨????????????p2??¨????§°??????
P reflection(const P& p0, const P& p1, const P& p2) {
P proj = projection(p0, p1, p2);
return proj - (p2 - proj);
}
// // ????????¨???P??¨??????????????????????????¢
// double norm(const P& a, const P& b) {
// return dot(
// return real(conj(a)*b);
// }
int main(){
double x0, y0, x1, y1;
int Q;
cin >> x0 >> y0 >> x1 >> y1;
P p0(x0, y0);
P p1(x1, y1);
cin >> Q;
REP(q, Q) {
double x2, y2;
cin >> x2 >> y2;
P p2(x2, y2);
auto ret = reflection(p0, p1, p2);
printf("%.10lf %.10lf\n", ret.real(), ret.imag());
}
}
|
For $n$ lists $L_i$ $(i = 0, 1, ..., n-1)$, perform a sequence of the following operations.
* insert($t$, $x$): Insert an integer $x$ at the end of $L_t$.
* dump($t$): Print all elements in $L_t$.
* splice($s$, $t$): Transfer elements of $L_s$ to the end of $L_t$. $L_s$ becomes empty.
In the initial state, $L_i$ $(i = 0, 1, ..., n-1)$ are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 500,000$
* For a splice operation, $s \ne t$
* For a splice operation, $L_s$ is not empty
* The total number of elements printed by dump operations do not exceed 1,000,000
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $s$ $t$
where the first digits 0, 1 and 2 represent insert, dump and splice operations respectively.
Output
For each dump operation, print elements of the corresponding list in a line. Separete adjacency elements by a space character (do not print the space after the last element). Note that, if the list is empty, an empty line should be printed.
Example
Input
3 10
0 0 1
0 0 2
0 0 3
0 1 4
0 1 5
2 1 0
0 2 6
1 0
1 1
1 2
Output
1 2 3 4 5
6
|
#include<bits/stdc++.h>
#define ll long long int
using namespace std;
int main()
{
list<int>st[1000];
list<int>::iterator it;
int n,tc,q,t,s;
ll x;
cin>>n>>tc;
while(tc--)
{
cin>>q;
if(q==0)
{
cin>>t>>x;
st[t].push_back(x);
}
else if(q==1)
{
cin>>t;
for(it=st[t].begin();it!=st[t].end();it++)
{
if(it!=st[t].begin())cout<<" ";
cout<<*it;
}
cout<<endl;
}
else if(q==2)
{
cin>>s>>t;
st[t].splice(st[t].end(),st[s]);
}
}
}
|
N Soldiers are lined up for a memory test. They are numbered from 0 to N-1 from left to right.
In the test, there are M rounds. In each round, Captain selects one position. Soldier at that position will be numbered 0. All the soldiers to the right of selected position will be numbered one greater than the soldier to his left. All the soldiers to the left of selected position will be numbered one greater than the soldier to his right.
eg. if N = 6 and selected position is 3, then the numbering will be [3, 2, 1, 0, 1, 2].
After M rounds, Captain asked each soldier to shout out the greatest number he was assigned during the M rounds. In order to check the correctness, Captain asked you to produce the correct values for each soldier (That is the correct value each soldier should shout out).
Input
The first line of the input contains an integer T denoting the number of test cases.
First line of each test case contains two integers, N and M.
Second line of each test case contains M integers, the positions selected by Captain, in that order.
Output
For each test case, output one line with N space separated integers.
Constraints
1 ≤ T ≤ 10^4
1 ≤ N ≤ 10^5
1 ≤ M ≤ 10^5
1 ≤ Sum of N over all testcases ≤ 10^5
1 ≤ Sum of M over all testcases ≤ 10^5
0 ≤ Positions selected by captain ≤ N-1
Example
Input
2
4 1
1
6 2
2 3
Output
1 0 1 2
3 2 1 1 2 3
|
T = input()
for _ in range(T):
n,m = map(int,raw_input().split())
arr = map(int,raw_input().split())
s = min(arr)
l = max(arr)
for i in range(n):
if abs(i-s)>abs(i-l):
print abs(i-s),
else:
print abs(i-l),
|
Once upon a time chef decided to learn encodings. And, obviously, he started with the easiest one (well, actually the easiest after Caesar cypher) – substitution cypher.
But very soon Chef got bored with encoding/decoding, so he started thinking how to hack this cypher.
He already knows some algorithm, which is not always correct,
but it’s sufficient for now. Here is its description.
Imagine we know frequency sequence of English letters (this means, that letters are sorted by their frequency of appearing in English texts, in ascending order).
And let’s find frequency sequence of cyphered letters (if some of them appear equal number of times, then first in frequency sequence will be lower letter between them).
Now, using this two frequency sequences we can recover plain text. Just substitute cyphered letter with origin one, if they are at same positions in sequences.
Now, Chef has frequency sequence of English letters and cypher text. And he asks you to recover plain text. Please, help him.
Input
In first line number T is given - number of test cases. Then T test cases follow. Each test case consists of two lines - frequency sequence and encrypted text.
Output
For each test case you should output decrypted with the given frequency sequence text. Please note, that the case of letters should be preserved.
Constraints
1 ≤ T ≤ 1000;
Length of frequency sequence is always 26;
1 ≤ length of the text ≤ 150000;
1 ≤ sum lengths of all texts ≤ 150000.
Frequency sequence consists of all lowercase English letters. Text consists of any characters.
Example
Input:
3
qwrtyuipasdfgjkzxcvbnmheol
dummy!
bfgjklmopqrstuwxzhvnicdyea
abcd b efgd hbi!
qwrtyuipasdfgjkzxcvbnmheol
Dummy!
Output:
hello!
have a nice day!
Hello!
|
def cmp(tup):
return (tup[1], tup[0])
def get_decoder(text,freqseq):
mymap = {}
for ch in text:
if ch.isalpha():
if ch.lower() in mymap:
mymap[ch.lower()] += 1
else:
mymap[ch.lower()] = 1
v = []
for k in mymap:
v.append((k,mymap[k]))
v = sorted(v,key=cmp)
length = len(v)
lastcut = freqseq[-length:]
decoder = {}
for i in range(length):
decoder[v[i][0]] = lastcut[i]
return decoder
t = input()
while t:
freqseq = raw_input()
text = raw_input()
#decoder = {}
decoder = get_decoder(text,freqseq)
ans = list(text)
for i in range(len(ans)):
if ans[i].isalpha():
if ans[i].isupper():
ans[i] = decoder[ans[i].lower()].upper()
else:
ans[i] = decoder[ans[i]]
ans = ''.join(ans)
print ans
t = t-1
|
Did you know that Chwee kueh, a cuisine of Singapore, means water rice cake ? Its a variety of the most popular South Indian savory cake, only that we call it here idli :). The tastiest idlis are made in Chennai, by none other than our famous chef, Dexter Murugan. Being very popular, he is flown from Marina to Miami, to serve idlis in the opening ceremony of icpc world finals ( which is happening right now ! ).
There are N students and they are initially served with some idlis. Some of them are angry because they got less idlis than some other. Dexter decides to redistribute the idlis so they all get equal number of idlis finally. He recollects his father's code, "Son, if you ever want to redistribute idlis, follow this method. While there are two persons with unequal number of idlis, repeat the following step. Select two persons A and B, A having the maximum and B having the minimum number of idlis, currently. If there are multiple ways to select A (similarly B), select any one randomly. Let A and B have P and Q number of idlis respectively and R = ceil( ( P - Q ) / 2 ), Transfer R idlis from A to B."
Given the initial number of idlis served to each student, find the number of times Dexter has to repeat the above step. If he can not distribute idlis equally by following the above method, print -1.
Notes ceil(x) is the smallest integer that is not less than x.
Input
First line contains an integer T ( number of test cases, around 20 ). T cases follows. Each case starts with an integer N ( 1 <= N <= 3000 ). Next line contains an array A of N integers separated by spaces, the initial number of idlis served ( 0 <= A[i] <= N )
Output
For each case, output the number of times Dexter has to repeat the given step to distribute idlis equally or -1 if its not possible.
Example
Input:
3
4
1 2 2 3
2
1 2
7
1 2 3 4 5 6 7
Output:
1
-1
3
Explanation:
Case 1 : { 1, 2, 2, 3}. Maximum 3, Minimum 1. R = ceil((3-1)/2) = 1. Transfer 1 idli from person having 3 idlis to the person having 1 idli. Each of them has 2 idlis now, so just 1 step is enough.
Case 2 : {1,2} R = ceil((2-1)/2) = 1. {1,2} -> {2,1} -> {1,2} .... they can never get equal idlis :(
Case 3 : Sorted arrays, in the order encountered {1, 2, 3, 4, 5, 6, 7} -> {2, 3, 4, 4, 4, 5, 6} -> {3, 4, 4, 4, 4, 4, 5} -> {4, 4, 4, 4, 4, 4, 4}
NoteThere are multiple test sets, and the judge shows the sum of the time taken over all test sets of your submission, if Accepted. Time limit on each test set is 3 sec
|
# your code goes here
# your code goes here
import math
A=[]
t=int(raw_input())
for u in range(0,t):
size=int(raw_input())
A=map(int,raw_input().split())
idli=[0]*(size+1)
count=0
for k in A:
idli[k]+=1
count =count+k
if(count%size!=0):
print("-1")
else:
i=0
j=size
count=0
while i<j:
while idli[i]==0:
i += 1
while idli[j]==0:
j -= 1
if(i==j):
break
r=int(math.ceil((j-i)/2))
# r=(j-i)/2 + (j-i)%2
idli[j] -= 1
idli[i] -= 1
idli[j-r] += 1
idli[i+r] += 1
count += 1
print(count)
|
Clash of clans is a very popular game. Each player in the game is allocated a base with certain hit points the player can train a limited number of troops on the base. There are three types of troops: Barbarian, Archers and Giants. The Cost of training a Barbarian is 100, an Archer is 500, and a Giant is 1500. When attacking an opponent’s base, Barbarian can reduce 1 hit point per sec, Archer 2 hit points per sec and Giant 3 hit points per sec.
After training the troops, you attack a particular opponent’s base. The opponent’s base has certain hit points. To completely destroy the opponent base, your troop's total hit points should be equal or more than the opponent's base hit points keeping in mind that the opponent's base can heal itself N*15 (Where N is the size of the troops) hit points every min
Here, you will be given the size ’N’ of the army you can take, the hit points ’H’ of the opponent’s base, and the time ’T’ within which you need to destroy the opponents base.
Your task is to create a troop, which will destroy the opponent’s whole base within the given time limit with a MINIMUM COST.
Note: You need to consider all N troops for destroying the opponent base. Also the input will be such that it is possible to destroy the opponent's base using certain troops.
Input
The first line contains a single integer N which is the size of the army
The first line contains a single integer T which is the time limit
The first line contains a single integer H which is the hit point of opponent’s base
Output
A single line containing minimum cost of the army
Constraints
1 ≤ N ≤ 10^6
1 ≤ T ≤ 100
1 ≤ H ≤ 10^6
Example1:
Input:
9
2
1530
Output:
3300
Example2:
Input:
5
3
2475
Output:
7500
Example3:
Input:
3
1
60
Output:
300
Explanation
In Example 1: We have to take 9 troops, and we have got 2 mins to destroy i.e. 120 secs to destroy the whole base. And the hit points of the base are 1530. Including the healing effects (9*2*15 = 270) the hit points of the opponent’s base is 1800. So the minimum cost army can be 6 Archers and 3 Barbarians, which cost 6*500 +3*100 =3300 which can destroy the whole base in 2 mins.
In Example 2: We have to take 5troops, and we have got 3 mins to destroy i.e. 180 secs to destroy the whole base. And the hit points of the base are 2475. Including the healing effects (5*3*15 = 225) the hit points of the opponent’s base is 2700. So the minimum cost army can be all 5 Giants, which cost 5*1500=7500 which can destroy the whole base in 3 mins.
In Example 3: We have to take 3 troops, and we have got 1 mins to destroy i.e. 60 secs to destroy the whole base. And the hit points of the base are 60. Including the healing effects (3*1*15 = 45) the hit points of the opponent’s base is 105. So the minimum cost army can be all 3 Barbarians, which cost 3*100 =300 which can destroy the whole base in 1 mins.
|
# cook your code here
def hitpoint(a,n,t):
i=0
h=0
while(i<n):
if(a[i]==1):
h+=t*1
elif(a[i]==2):
h+=t*2
else:
h+=t*3
i+=1
return h
#input size of army
n=int(raw_input())
#input the time in mins
t=int(raw_input())
#convertion to sec
t=t*60
#hit points of the base to be destroyed
h=int(raw_input())
#adding the healing effect of the base, so total hit point is h
h=h+(t//60)*n*15
#print(h)
#creating a team with basic 1
i=0
team=[]
hit=0
while(i<n):
team.append(1)
i+=1
#checking which army is to be taken with min cost
hit=hitpoint(team,n,t)
if(hit<h):
flag=0
i=0
while(i<n):
team[i]=2
hit=hitpoint(team,n,t)
if(hit>=h):
flag=2
break
i+=1
if(flag!=2):
i=0
while(i<n):
team[i]=1
i+=1
i=0
while(i<n):
team[i]=3
j=i+1
while(j<=n):
hit=hitpoint(team,n,t)
if(hit>=h):
flag=2
break
else:
if(j!=n):
team[j]=2
j+=1
if(flag==2):
break
j=i+1
while(j<n):
team[j]=1
j+=1
i+=1
#printing the army which needs to be taken
#print(team)
#calculating the cost of the army
i=0
cost=0
while(i<n):
if(team[i]==1):
cost+=100
elif(team[i]==2):
cost+=500
else:
cost+=1500
i+=1
#printing the cost
print(cost)
|
You are given a weighted graph with N nodes and M edges. Some of the nodes are marked as special nodes. Your task is to find the shortest pairwise distance between any two different special nodes.
Input
The first line of the input contains three space-separated integers N, M and K denoting the number of nodes, the number of edges, and the number of special nodes.
The following line contains K space-separated distinct integers A1, A2, ..., AK , denoting the special nodes.
Each of the following M lines (say, the j^th) contains a triple Xj Yj Zj, denoting the edge connecting the nodes Xj and Yj, and having the weight of Zj.
Output
Output the shortest pairwise distance between any two different special nodes.
Constraints
2 ≤ K ≤ N
The given graph is connected.
The given graph doesn't contain self loops and multiple edges.
1 ≤ Ai ≤ N
1 ≤ Zj ≤ 10^4
1 ≤ Xj, Yj ≤ N
Example
Input:
5 5 3
1 3 5
1 2 3
2 3 4
3 4 1
4 5 8
1 5 19
Output:
7
Explanation
Nodes 1, 3 and 5 are special nodes. Shortest distance between nodes 1 and 3 is 7 and that between nodes 3 and 5 is 9. Shortest distance between nodes 1 and 5 is 16. Minimum of these distances is 7. Hence answer is 7.
|
INFINITY = 10**9+7
from heapq import *
def dijkstra(s):
global mini
q, seen = [(0, s)], set()
while q:
cost, v1 = heappop(q)
if v1 not in seen:
seen.add(v1)
if cost > mini:
break
if specials[v1] == 1:
if v1 != s:
mini = cost
break
for c, v2 in g[v1]:
if v2 not in seen:
heappush(q, (cost+c, v2))
N, M, K = map(int, raw_input().split())
A = map(int, raw_input().split())
specials = [-1 for _ in xrange(N+1)]
for a in A:
specials[a] = 1
g = [[] for _ in xrange(N+1)]
for m in xrange(M):
X, Y, Z = map(int, raw_input().split())
g[X].append((Z, Y))
g[Y].append((Z, X))
ds = []
mini = INFINITY
for i in xrange(1, K+1):
dijkstra(A[i-1])
print mini
|
Problem description:
There are students in a class fighting for a girl. As she came to know she decided that the boy will win who will help her find out specific characters present in a given string is present either "even" or "odd" number of times as asked by her. So help the boys win.
Input
Input description.
First input line consist of t number of test cases.
Next line consists of N, Q i.e. length of string and number of queries
Next input lines consists of string to be searched for
Next Q lines the queries as character to be searched, either "even" or "odd"
Output
Output description.
Each line consists of result "yes" or "no" for each query
Constraints
1 <= T <= 100
1<= N <= 100000
1<= Q <= 100
Example
Input:
1
5 2
aaabb
a even
b odd
Output:
no
no
|
testcase = input()
for i in range(0, testcase):
n, q = map(int, raw_input().split())
s = raw_input()
for j in range(0, q):
c, t = raw_input().split()
if(t == "even"):
if(s.count(c)%2 == 0):
print "yes"
else:
print "no"
else:
if(s.count(c)%2 == 1):
print "yes"
else:
print "no"
|
In this problem you will have to help Berland army with organizing their command delivery system.
There are n officers in Berland army. The first officer is the commander of the army, and he does not have any superiors. Every other officer has exactly one direct superior. If officer a is the direct superior of officer b, then we also can say that officer b is a direct subordinate of officer a.
Officer x is considered to be a subordinate (direct or indirect) of officer y if one of the following conditions holds:
* officer y is the direct superior of officer x;
* the direct superior of officer x is a subordinate of officer y.
For example, on the picture below the subordinates of the officer 3 are: 5, 6, 7, 8, 9.
The structure of Berland army is organized in such a way that every officer, except for the commander, is a subordinate of the commander of the army.
Formally, let's represent Berland army as a tree consisting of n vertices, in which vertex u corresponds to officer u. The parent of vertex u corresponds to the direct superior of officer u. The root (which has index 1) corresponds to the commander of the army.
Berland War Ministry has ordered you to give answers on q queries, the i-th query is given as (u_i, k_i), where u_i is some officer, and k_i is a positive integer.
To process the i-th query imagine how a command from u_i spreads to the subordinates of u_i. Typical DFS (depth first search) algorithm is used here.
Suppose the current officer is a and he spreads a command. Officer a chooses b — one of his direct subordinates (i.e. a child in the tree) who has not received this command yet. If there are many such direct subordinates, then a chooses the one having minimal index. Officer a gives a command to officer b. Afterwards, b uses exactly the same algorithm to spread the command to its subtree. After b finishes spreading the command, officer a chooses the next direct subordinate again (using the same strategy). When officer a cannot choose any direct subordinate who still hasn't received this command, officer a finishes spreading the command.
Let's look at the following example:
<image>
If officer 1 spreads a command, officers receive it in the following order: [1, 2, 3, 5 ,6, 8, 7, 9, 4].
If officer 3 spreads a command, officers receive it in the following order: [3, 5, 6, 8, 7, 9].
If officer 7 spreads a command, officers receive it in the following order: [7, 9].
If officer 9 spreads a command, officers receive it in the following order: [9].
To answer the i-th query (u_i, k_i), construct a sequence which describes the order in which officers will receive the command if the u_i-th officer spreads it. Return the k_i-th element of the constructed list or -1 if there are fewer than k_i elements in it.
You should process queries independently. A query doesn't affect the following queries.
Input
The first line of the input contains two integers n and q (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ q ≤ 2 ⋅ 10^5) — the number of officers in Berland army and the number of queries.
The second line of the input contains n - 1 integers p_2, p_3, ..., p_n (1 ≤ p_i < i), where p_i is the index of the direct superior of the officer having the index i. The commander has index 1 and doesn't have any superiors.
The next q lines describe the queries. The i-th query is given as a pair (u_i, k_i) (1 ≤ u_i, k_i ≤ n), where u_i is the index of the officer which starts spreading a command, and k_i is the index of the required officer in the command spreading sequence.
Output
Print q numbers, where the i-th number is the officer at the position k_i in the list which describes the order in which officers will receive the command if it starts spreading from officer u_i. Print "-1" if the number of officers which receive the command is less than k_i.
You should process queries independently. They do not affect each other.
Example
Input
9 6
1 1 1 3 5 3 5 7
3 1
1 5
3 4
7 3
1 8
1 9
Output
3
6
8
-1
9
4
|
#include <bits/stdc++.h>
using namespace std;
int ans = 1;
vector<int> son[200010];
int start[200010];
int eend[200010];
int place[200010];
void dfs(int num) {
place[ans] = num;
start[num] = ans++;
for (int i = 0; i < son[num].size(); i++) {
dfs(son[num][i]);
}
eend[num] = ans;
}
int main() {
int num_soldier, num_operation;
int i;
int temp;
int start_place, num_place;
while (scanf("%d %d", &num_soldier, &num_operation) != EOF) {
for (i = 2; i <= num_soldier; i++) {
scanf("%d", &temp);
son[temp].push_back(i);
}
dfs(1);
while (num_operation--) {
scanf("%d %d", &start_place, &num_place);
if (num_place <= eend[start_place] - start[start_place]) {
printf("%d\n", place[start[start_place] + num_place - 1]);
} else {
printf("-1\n");
}
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.