input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
Problem description.
Vipul is a hardworking super-hero who maintains the bracket ratio of all the strings in the world. Recently he indulged himself in saving the string population so much that he lost his ability for checking brackets (luckily, not permanently ).Being his super-hero friend help him in his time of hardship.
Input
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test case contains a single string S denoting the string to be checked.
Output
For each test case, output a single line printing "YES" or "NO" (without " " and in uppercase only) , denoting if the brackets in the given string is balanced or not .
Constraints
1 ≤ T ≤ 10
1 ≤ length of S ≤ 60
Example
Input:
3
((()))
(())()
()(()
Output:
YES
YES
NO
Explanation
Example is self-explanatory. | for _ in range(input()):
try:
eval(raw_input())
print 'YES'
except TypeError:
print 'YES'
except:
print 'NO' |
The Chef likes to stay in touch with his staff. So, the Chef, the head server, and the sous-chef all carry two-way transceivers so they can stay in constant contact. Of course, these transceivers have a limited range so if two are too far apart, they cannot communicate directly.
The Chef invested in top-of-the-line transceivers which have a few advanced features. One is that even if two people cannot talk directly because they are out of range, if there is another transceiver that is close enough to both, then the two transceivers can still communicate with each other using the third transceiver as an intermediate device.
There has been a minor emergency in the Chef's restaurant
and he needs to communicate with both the head server and the sous-chef right away. Help the Chef determine if it is possible for all three people to communicate with each other, even if two must communicate through the third because they are too far apart.
Input
The first line contains a single positive integer T ≤ 100 indicating the number of test cases to follow. The first line of each test case contains a positive integer R ≤ 1,000 indicating that two transceivers can communicate directly without an intermediate transceiver if they are at most R meters away from each other. The remaining three lines of the test case describe the current locations of the Chef, the head server, and the sous-chef, respectively. Each such line contains two integers X,Y (at most 10,000 in absolute value) indicating that the respective person is located at position X,Y.
Output
For each test case you are to output a single line containing a single string. If it is possible for all three to communicate then you should output "yes". Otherwise, you should output "no".
To be clear, we say that two transceivers are close enough to communicate directly if the length of the straight line connecting their X,Y coordinates is at most R.
Example
Input:
3
1
0 1
0 0
1 0
2
0 1
0 0
1 0
2
0 0
0 2
2 1
Output:
yes
yes
no | import math
no_of_testcases = int(input())
for each in range(no_of_testcases):
dist = int(input())
point_1 = map(int,raw_input().split())
point_2 = map(int,raw_input().split())
point_3 = map(int,raw_input().split())
point_12 =math.sqrt( math.pow((point_1[0] -point_2[0]),2) + math.pow((point_1[1] -point_2[1]),2))
point_23 =math.sqrt( math.pow((point_2[0] -point_3[0]),2) + math.pow((point_2[1] -point_3[1]),2))
point_31 =math.sqrt( math.pow((point_3[0] -point_1[0]),2) + math.pow((point_3[1] -point_1[1]),2))
count =0
if point_12 <= dist:
count =count+1
if point_23 <= dist:
count =count+1
if point_31 <= dist:
count =count+1
if count >=2:
print "yes"
else:
print "no" |
Frank explained its friend Felman the algorithm of Euclides to calculate the GCD
of two numbers. Then Felman implements it algorithm
int gcd(int a, int b)
{
if (b==0)
return a;
else
return gcd(b,a%b);
}
and it proposes to Frank that makes it
but with a little integer and another integer that has up to 250 digits.
Your task is to help Frank programming an efficient code for the challenge of Felman.
Input
The first line of the input file contains a number representing the number of lines to follow.
Each line consists of two number A and B (0 ≤ A ≤ 40000 and A ≤ B < 10^250).
Output
Print for each pair (A,B) in the input one integer representing the GCD of A and B.
Example
Input:
2
2 6
10 11
Output:
2
1 | def gcd(a,b):
while(b):
a,b=b,a%b
return a
t=input()
while(t):
a,b=map(int,raw_input().split())
print(gcd(a,b))
t=t-1; |
A Little Elephant from the Zoo of Lviv likes lucky strings, i.e., the strings that consist only of the lucky digits 4 and 7.
The Little Elephant calls some string T of the length M balanced if there exists at least one integer X (1 ≤ X ≤ M) such that the number of digits 4 in the substring T[1, X - 1] is equal to the number of digits 7 in the substring T[X, M]. For example, the string S = 7477447 is balanced since S[1, 4] = 7477 has 1 digit 4 and S[5, 7] = 447 has 1 digit 7. On the other hand, one can verify that the string S = 7 is not balanced.
The Little Elephant has the string S of the length N. He wants to know the number of such pairs of integers (L; R) that 1 ≤ L ≤ R ≤ N and the substring S[L, R] is balanced. Help him to find this number.
Notes.
Let S be some lucky string. Then
|S| denotes the length of the string S;
S[i] (1 ≤ i ≤ |S|) denotes the i^th character of S (the numeration of characters starts from 1);
S[L, R] (1 ≤ L ≤ R ≤ |S|) denotes the string with the following sequence of characters: S[L], S[L + 1], ..., S[R], and is called a substring of S. For L > R we mean by S[L, R] an empty string.
Input
The first line of the input file contains a single integer T, the number of test cases. Each of the following T lines contains one string, the string S for the corresponding test case. The input file does not contain any whitespaces.
Output
For each test case output a single line containing the answer for this test case.
Constraints
1 ≤ T ≤ 10
1 ≤ |S| ≤ 100000
S consists only of the lucky digits 4 and 7.
Example
Input:
4
47
74
477
4747477
Output:
2
2
3
23
Explanation
In the first test case balance substrings are S[1, 1] = 4 and S[1, 2] = 47.
In the second test case balance substrings are S[2, 2] = 4 and S[1, 2] = 74.
Unfortunately, we can't provide you with the explanations of the third and the fourth test cases. You should figure it out by yourself. Please, don't ask about this in comments. | n = input()
for i in range(n):
str = raw_input()
l = len(str)
megacounter = 0
counter = 0
i = 0
while(1):
while(i<l and str[i]=='7'):
i=i+1
counter=counter+1
if(i>=l):
break
megacounter = megacounter + (counter*(counter+1))/2
i=i+1
counter=0
megacounter = megacounter + (counter*(counter+1))/2
supercounter = (l*(l+1))/2 - megacounter
print supercounter |
Given a string s. Can you make it a palindrome by deleting exactly one character? Note that size of the string after deletion would be one less than it was before.
Input
First line of the input contains a single integer T denoting number of test cases.
For each test case, you are given a single line containing string s.
Output
For each test case, print YES or NO depending on the answer of the problem.
Constraints
Example
Input:
4
aaa
abc
abdbca
abba
Output:
YES
NO
YES
YES
Explanation
Example case 1. Delete any one 'a', resulting string is "aa" which is a palindrome.
Example case 2. It is not possible to delete exactly one character and having a palindrome.
Example case 3. Delete 'c', resulting string is "abdba" which is a palindrome.
Example case 4. Delete 'b', resulting string is "aba" which is a palindrome. | import math
import sys
def checkpal(s):
return s==s[::-1]
for a in range(input()):
s=raw_input()
l=len(s)
if(l==2):
print "YES"
else:
if checkpal(s):
print "YES"
else:
while s[0] == s[-1] and len(s)>2:
s=s[1:-1]
if checkpal(s[1:]) or checkpal(s[:-1]):
print "YES"
else:
print "NO" |
An established group of scientists are working on finding solution to NP hard problems. They claim Subset Sum as an NP-hard problem. The problem is to determine whether there exists a subset of a given set S whose sum is a given number K.
You are a computer engineer and you claim to solve this problem given that all numbers in the set are non-negative. Given a set S of size N of non-negative integers, find whether there exists a subset whose sum is K.
Input
First line of input contains T, the number of test cases. T test cases follow.
Each test case contains 2 lines. First line contains two integers N and K. Next line contains N space separated non-negative integers (each less than 100000).
0 < T < 1000
0 < N < 1000
0 < K < 1000
Output
Output T lines, one for each test case. Every line should be either 0 or 1 depending on whether such a subset exists or not.
Example
Input:
2
5 10
3 4 6 1 9
3 2
1 3 4
Output:
1
0 | import sys
for __ in range(input()) :
n , k = map(int,sys.stdin.readline().split())
lists = map(int,sys.stdin.readline().split())
dp = [0]*(k+1)
dp[0]=1
for i in lists :
for j in range(k-i,-1,-1) :
if dp[k] :
break
if dp[j] :
dp[j+i] = 1
print dp[k] |
You are given an array of n positive integers a_1, a_2, ..., a_n. You can perform the following operation any number of times: select several distinct indices i_1, i_2, ..., i_k (1 ≤ i_j ≤ n) and move the number standing at the position i_1 to the position i_2, the number at the position i_2 to the position i_3, ..., the number at the position i_k to the position i_1. In other words, the operation cyclically shifts elements: i_1 → i_2 → … i_k → i_1.
For example, if you have n=4, an array a_1=10, a_2=20, a_3=30, a_4=40, and you choose three indices i_1=2, i_2=1, i_3=4, then the resulting array would become a_1=20, a_2=40, a_3=30, a_4=10.
Your goal is to make the array sorted in non-decreasing order with the minimum number of operations. The additional constraint is that the sum of cycle lengths over all operations should be less than or equal to a number s. If it's impossible to sort the array while satisfying that constraint, your solution should report that as well.
Input
The first line of the input contains two integers n and s (1 ≤ n ≤ 200 000, 0 ≤ s ≤ 200 000)—the number of elements in the array and the upper bound on the sum of cycle lengths.
The next line contains n integers a_1, a_2, ..., a_n—elements of the array (1 ≤ a_i ≤ 10^9).
Output
If it's impossible to sort the array using cycles of total length not exceeding s, print a single number "-1" (quotes for clarity).
Otherwise, print a single number q— the minimum number of operations required to sort the array.
On the next 2 ⋅ q lines print descriptions of operations in the order they are applied to the array. The description of i-th operation begins with a single line containing one integer k (1 ≤ k ≤ n)—the length of the cycle (that is, the number of selected indices). The next line should contain k distinct integers i_1, i_2, ..., i_k (1 ≤ i_j ≤ n)—the indices of the cycle.
The sum of lengths of these cycles should be less than or equal to s, and the array should be sorted after applying these q operations.
If there are several possible answers with the optimal q, print any of them.
Examples
Input
5 5
3 2 3 1 1
Output
1
5
1 4 2 3 5
Input
4 3
2 1 4 3
Output
-1
Input
2 0
2 2
Output
0
Note
In the first example, it's also possible to sort the array with two operations of total length 5: first apply the cycle 1 → 4 → 1 (of length 2), then apply the cycle 2 → 3 → 5 → 2 (of length 3). However, it would be wrong answer as you're asked to use the minimal possible number of operations, which is 1 in that case.
In the second example, it's possible to the sort the array with two cycles of total length 4 (1 → 2 → 1 and 3 → 4 → 3). However, it's impossible to achieve the same using shorter cycles, which is required by s=3.
In the third example, the array is already sorted, so no operations are needed. Total length of empty set of cycles is considered to be zero. | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 300000;
map<int, int> mapa;
map<pair<int, int>, vector<int>> pos;
vector<int> g[MAXN];
int ptr[MAXN];
int used[MAXN];
void euler(int v, vector<int> &res) {
used[v] = true;
for (; ptr[v] < (int)(g[v]).size();) {
++ptr[v];
int u = g[v][ptr[v] - 1];
euler(u, res);
res.push_back(u);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, s;
cin >> n >> s;
int k = 0;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
vector<int> b = a;
sort((b).begin(), (b).end());
int m = 0;
for (int i = 0; i < n; ++i) {
if (a[i] == b[i]) {
continue;
}
++m;
if (!mapa.count(b[i])) {
mapa[b[i]] = k++;
}
}
if (m > s) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < n; ++i) {
if (a[i] == b[i]) {
continue;
}
a[i] = mapa[a[i]];
b[i] = mapa[b[i]];
g[b[i]].push_back(a[i]);
pos[{b[i], a[i]}].push_back(i);
}
vector<vector<int>> cycles;
for (int i = 0; i < k; ++i) {
if (!used[i]) {
vector<int> arr;
euler(i, arr);
reverse((arr).begin(), (arr).end());
cycles.push_back({});
for (int i = 0; i < (int)(arr).size(); ++i) {
int j = (i + 1) % (int)(arr).size();
cycles.back().push_back(pos[{arr[i], arr[j]}].back());
pos[{arr[i], arr[j]}].pop_back();
}
}
}
vector<vector<int>> res;
if (s - m > 1 && (int)(cycles).size() > 1) {
int len = min((int)(cycles).size(), s - m);
res.push_back({});
vector<int> newcycle;
for (int i = (int)(cycles).size() - len; i < (int)(cycles).size(); ++i) {
res.back().push_back(cycles[i].back());
for (int j : cycles[i]) {
newcycle.push_back(j);
}
}
reverse((res.back()).begin(), (res.back()).end());
for (int i = 0; i < len; ++i) {
cycles.pop_back();
}
cycles.push_back(newcycle);
}
for (int i = 0; i < (int)(cycles).size(); ++i) {
res.push_back(cycles[i]);
}
cout << (int)(res).size() << endl;
for (int i = 0; i < (int)(res).size(); ++i) {
cout << (int)(res[i]).size() << endl;
for (int j : res[i]) {
cout << j + 1 << " ";
}
cout << endl;
}
}
|
There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | #include <bits/stdc++.h>
using namespace std;
const int module = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
vector<set<int>> to(n, set<int>());
vector<pair<int, int>> edges(m);
vector<int> nbr(n);
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
nbr[a]++;
nbr[b]++;
to[a].insert(b);
to[b].insert(a);
edges[i] = {a, b};
}
vector<bool> vis(n);
int all = n;
for (int i = 0; i < n; ++i) {
if (!vis[i]) {
if (nbr[i] < k) {
queue<int> q;
q.push(i);
vis[i] = true;
all--;
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int t : to[cur]) {
nbr[t]--;
to[t].erase(cur);
if (nbr[t] < k && !vis[t]) {
q.push(t);
vis[t] = true;
all--;
}
}
}
}
}
}
queue<int> q;
vector<int> answer;
answer.push_back(all);
for (int i = m - 1; i > 0; i--) {
auto [a, b] = edges[i];
if (!vis[a] && !vis[b]) {
to[a].erase(b);
to[b].erase(a);
nbr[a]--;
nbr[b]--;
if (nbr[a] < k) {
q.push(a);
vis[a] = true;
all--;
}
if (nbr[b] < k) {
q.push(b);
vis[b] = true;
all--;
}
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int t : to[cur]) {
nbr[t]--;
to[t].erase(cur);
if (nbr[t] < k && !vis[t]) {
q.push(t);
vis[t] = true;
all--;
}
}
}
}
answer.push_back(all);
}
for (int i = answer.size() - 1; i >= 0; i--) {
cout << answer[i] << "\n";
}
}
|
Let's call a string a phone number if it has length 11 and fits the pattern "8xxxxxxxxxx", where each "x" is replaced by a digit.
For example, "80123456789" and "80000000000" are phone numbers, while "8012345678" and "79000000000" are not.
You have n cards with digits, and you want to use them to make as many phone numbers as possible. Each card must be used in at most one phone number, and you don't have to use all cards. The phone numbers do not necessarily have to be distinct.
Input
The first line contains an integer n — the number of cards with digits that you have (1 ≤ n ≤ 100).
The second line contains a string of n digits (characters "0", "1", ..., "9") s_1, s_2, …, s_n. The string will not contain any other characters, such as leading or trailing spaces.
Output
If at least one phone number can be made from these cards, output the maximum number of phone numbers that can be made. Otherwise, output 0.
Examples
Input
11
00000000008
Output
1
Input
22
0011223344556677889988
Output
2
Input
11
31415926535
Output
0
Note
In the first example, one phone number, "8000000000", can be made from these cards.
In the second example, you can make two phone numbers from the cards, for example, "80123456789" and "80123456789".
In the third example you can't make any phone number from the given cards. | n = int(input())
s = input()
k = s.count("8")
l = n - k
if k <= l//10: print(k)
else:
while k > l//10:
k -= 1
l += 1
print(min(k, l//10))
|
Chouti thought about his very first days in competitive programming. When he had just learned to write merge sort, he thought that the merge sort is too slow, so he restricted the maximum depth of recursion and modified the merge sort to the following:
<image>
Chouti found his idea dumb since obviously, this "merge sort" sometimes cannot sort the array correctly. However, Chouti is now starting to think of how good this "merge sort" is. Particularly, Chouti wants to know for a random permutation a of 1, 2, …, n the expected number of inversions after calling MergeSort(a, 1, n, k).
It can be proved that the expected number is rational. For the given prime q, suppose the answer can be denoted by u/d where gcd(u,d)=1, you need to output an integer r satisfying 0 ≤ r<q and rd ≡ u \pmod q. It can be proved that such r exists and is unique.
Input
The first and only line contains three integers n, k, q (1 ≤ n, k ≤ 10^5, 10^8 ≤ q ≤ 10^9, q is a prime).
Output
The first and only line contains an integer r.
Examples
Input
3 1 998244353
Output
499122178
Input
3 2 998244353
Output
665496236
Input
9 3 998244353
Output
449209967
Input
9 4 998244353
Output
665496237
Note
In the first example, all possible permutations are [1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1].
With k=1, MergeSort(a, 1, n, k) will only return the original permutation. Thus the answer is 9/6=3/2, and you should output 499122178 because 499122178 × 2 ≡ 3 \pmod {998244353}.
In the second example, all possible permutations are [1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1] and the corresponding outputs of MergeSort(a, 1, n, k) are [1,2,3],[1,2,3],[2,1,3],[1,2,3],[2,3,1],[1,3,2] respectively. Thus the answer is 4/6=2/3, and you should output 665496236 because 665496236 × 3 ≡ 2 \pmod {998244353}. | #include <bits/stdc++.h>
const int MAXN = 1e5 + 20;
int n, k, M;
int inv[MAXN], pre_inv[MAXN];
void math_pre() {
inv[1] = 1;
for (int i = 2; i <= ((n < 4) ? 4 : n); ++i)
inv[i] = 1ll * (M - M / i) * inv[M % i] % M;
for (int i = 1; i <= n; ++i) pre_inv[i] = (pre_inv[i - 1] + inv[i]) % M;
}
struct map {
static const int MAXMap = 2;
int tot;
struct pad {
int key, val;
pad() {}
pad(const int &KEY, const int &VAL) : key(KEY), val(VAL) {}
} node[MAXMap + 1];
map() { tot = 0; }
pad *find(const int &key) {
pad *ret = node;
while (ret - node < tot && ret->key != key) ++ret;
return ret;
}
void insert(const pad &new_element) { node[tot++] = new_element; }
pad *begin() { return &node[0]; }
pad *end() { return &node[tot]; }
} Map;
void solve(const int &l, const int &r, const int &h) {
if (l >= r || h <= 1) {
int len = r - l + 1;
map::pad *it = Map.find(len);
if (it == Map.end())
Map.insert(map::pad(len, 1));
else
++it->val;
return;
}
int mid = (l + r) >> 1;
solve(l, mid, h - 1), solve(mid + 1, r, h - 1);
}
int calc(const int &len1, const int &len2) {
int ret = 0;
for (int i = 1; i <= len1; ++i)
ret = ((ret + 1ll * inv[2] * len2 % M -
(pre_inv[i + len2] - pre_inv[i + 1 - 1])) %
M +
M) %
M;
return ret;
}
int main() {
scanf("%d%d%d", &n, &k, &M);
math_pre();
solve(1, n, k);
int ans = 0;
for (map::pad *it = Map.begin(); it != Map.end(); ++it) {
int len = it->key, cnt = it->val;
ans = (ans + 1ll * cnt * len % M * (len - 1) % M * inv[4] % M) % M;
}
for (map::pad *it1 = Map.begin(); it1 != Map.end(); ++it1)
for (map::pad *it2 = Map.begin(); it2 != Map.end(); ++it2) {
if (it1 == it2) {
int len = it1->key, cnt = 1ll * (0 + (it1->val - 1)) * it1->val / 2 % M;
ans = (ans + 1ll * cnt * calc(len, len) % M) % M;
} else if (it1->key < it2->key) {
int len1 = it1->key, len2 = it2->key,
cnt = 1ll * it1->val * it2->val % M;
ans = (ans + 1ll * cnt * calc(len1, len2) % M) % M;
}
}
printf("%d", ans);
}
|
You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first line contains one integer q (1 ≤ q ≤ 500) — the number of queries.
Then q lines follow, each containing a query given in the format l_i r_i d_i (1 ≤ l_i ≤ r_i ≤ 10^9, 1 ≤ d_i ≤ 10^9). l_i, r_i and d_i are integers.
Output
For each query print one integer: the answer to this query.
Example
Input
5
2 4 2
5 10 4
3 10 1
1 2 3
4 6 5
Output
6
4
1
3
10 | n = int(input())
A = []
for i in range(n):
A = A+[input().split()]
for a in A:
if int(a[2]) < int(a[0]) or int(a[2]) > int(a[1]):
print(a[2])
else:
print(int(a[2])*(int(a[1])//int(a[2])+1))
|
Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n and k (1 ≤ k ≤ n ≤ 10^5) — the number of elements in the array a and the restriction from the statement.
The following line contains n space-separated integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n) — elements of the array a.
Output
The first and only line contains the number of ways to divide an array a modulo 998 244 353.
Examples
Input
3 1
1 1 2
Output
3
Input
5 2
1 1 2 1 3
Output
14
Input
5 5
1 2 3 4 5
Output
16
Note
In the first sample, the three possible divisions are as follows.
* [[1], [1], [2]]
* [[1, 1], [2]]
* [[1, 1, 2]]
Division [[1], [1, 2]] is not possible because two distinct integers appear exactly once in the second segment [1, 2]. | #include <bits/stdc++.h>
int bb[1 + 100000], dp[1 + 100000], ss[((100000 + 500 - 1) / 500)],
dq[((100000 + 500 - 1) / 500)][500 + 1 + 500];
void update(int h) {
int *qq = dq[h];
int i, t, c;
t = 0;
memset(qq, 0, (500 + 1 + 500) * sizeof *qq);
for (i = (h + 1) * 500; i > h * 500; i--) {
t += bb[i];
qq[500 + t] = (qq[500 + t] + dp[i - 1]) % 998244353;
}
for (c = 1; c <= 500 + 500; c++) qq[c] = (qq[c] + qq[c - 1]) % 998244353;
}
int main() {
static int pp[1 + 100000], ii[1 + 100000];
int n, m, k, h, i, j;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
pp[i] = ii[a];
ii[a] = i;
}
dp[0] = 1;
for (j = 1; j <= n; j++) {
int p, x, t;
m = (j - 1) / 500;
ss[m] += 1 - bb[j];
bb[j] = 1;
if ((p = pp[j])) {
h = (p - 1) / 500;
ss[h] += -1 - bb[p];
bb[p] = -1;
if (p <= m * 500) update(h);
if ((p = pp[p])) {
h = (p - 1) / 500;
ss[h] += 0 - bb[p];
bb[p] = 0;
if (p <= m * 500) update(h);
}
}
x = 0;
t = 0;
for (i = j; i > m * 500; i--) {
t += bb[i];
if (t <= k) x = (x + dp[i - 1]) % 998244353;
}
for (h = m - 1; h >= 0; h--) {
if (k - t >= -500)
x = (x + dq[h][500 + (500 < k - t ? 500 : k - t)]) % 998244353;
t += ss[h];
}
dp[j] = x;
if (j % 500 == 0) update(m);
}
printf("%d\n", dp[n]);
return 0;
}
|
In Byteland, there are two political parties fighting for seats in the Parliament in the upcoming elections: Wrong Answer Party and Time Limit Exceeded Party. As they want to convince as many citizens as possible to cast their votes on them, they keep promising lower and lower taxes.
There are n cities in Byteland, connected by m one-way roads. Interestingly enough, the road network has no cycles — it's impossible to start in any city, follow a number of roads, and return to that city. Last year, citizens of the i-th city had to pay h_i bourles of tax.
Parties will now alternately hold the election conventions in various cities. If a party holds a convention in city v, the party needs to decrease the taxes in this city to a non-negative integer amount of bourles. However, at the same time they can arbitrarily modify the taxes in each of the cities that can be reached from v using a single road. The only condition that must be fulfilled that the tax in each city has to remain a non-negative integer amount of bourles.
The first party to hold the convention is Wrong Answer Party. It's predicted that the party to hold the last convention will win the election. Can Wrong Answer Party win regardless of Time Limit Exceeded Party's moves?
Input
The first line of the input contains two integers n, m (1 ≤ n ≤ 200 000, 0 ≤ m ≤ 200 000) — the number of cities and roads in Byteland.
The next line contains n space-separated integers h_1, h_2, ..., h_n (0 ≤ h_i ≤ 10^9); h_i denotes the amount of taxes paid in the i-th city.
Each of the following m lines contains two integers (1 ≤ u, v ≤ n, u ≠ v), and describes a one-way road leading from the city u to the city v. There will be no cycles in the road network. No two roads will connect the same pair of cities.
We can show that the conventions cannot be held indefinitely for any correct test case.
Output
If Wrong Answer Party can win the election, output WIN in the first line of your output. In this case, you're additionally asked to produce any convention allowing the party to win regardless of the opponent's actions. The second line should contain n non-negative integers h'_1, h'_2, ..., h'_n (0 ≤ h'_i ≤ 2 ⋅ 10^{18}) describing the amount of taxes paid in consecutive cities after the convention. If there are multiple answers, output any. We guarantee that if the party has any winning move, there exists a move after which no city has to pay more than 2 ⋅ 10^{18} bourles.
If the party cannot assure their victory, output LOSE in the first and only line of the output.
Examples
Input
4 2
2 1 1 5
1 2
3 4
Output
WIN
1 5 1 5
Input
4 2
1 5 1 5
1 2
3 4
Output
LOSE
Input
3 3
314 159 265
1 2
1 3
3 2
Output
WIN
0 0 0
Input
6 4
2 2 5 5 6 6
1 3
2 4
3 5
4 6
Output
LOSE
Note
In the first example, Wrong Answer Party should hold the convention in the city 1. The party will decrease the taxes in this city to 1 bourle. As the city 2 is directly reachable from 1, we can arbitrarily modify the taxes in this city. The party should change the tax to 5 bourles. It can be easily proved that Time Limit Exceeded cannot win the election after this move if Wrong Answer Party plays optimally.
The second example test presents the situation we created after a single move in the previous test; as it's Wrong Answer Party's move now, the party cannot win.
In the third test, we should hold the convention in the first city. This allows us to change the taxes in any city to any desired value; we can for instance decide to set all the taxes to zero, which allows the Wrong Answer Party to win the election immediately. | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
int n, m, h[N], lev[N], Xor[N], cnt[N], deg[N];
vector<int> nxt[N], rnxt[N], vec[N];
set<int> s;
queue<int> q;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> h[i];
for (int i = 1; i <= m; ++i) {
int x, y;
cin >> x >> y;
rnxt[y].push_back(x);
nxt[x].push_back(y);
++deg[x];
}
for (int i = 1; i <= n; ++i)
if (!deg[i]) q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto v : nxt[u]) ++cnt[lev[v]];
while (cnt[lev[u]]) ++lev[u];
Xor[lev[u]] ^= h[u];
for (auto v : nxt[u]) --cnt[lev[v]];
for (auto v : rnxt[u])
if (!--deg[v]) q.push(v);
}
for (int i = n; ~i; --i)
if (Xor[i]) {
puts("WIN");
for (int u = 1; u <= n; ++u)
if (lev[u] == i && h[u] > (h[u] ^ Xor[i])) {
h[u] ^= Xor[i];
for (auto v : nxt[u])
if (Xor[lev[v]]) h[v] ^= Xor[lev[v]], Xor[lev[v]] = 0;
break;
}
for (int j = 1; j <= n; ++j) cout << h[j] << " ";
puts("");
return 0;
}
puts("LOSE");
return 0;
}
|
Note that this is the first problem of the two similar problems. You can hack this problem only if you solve both problems.
You are given a tree with n nodes. In the beginning, 0 is written on all edges. In one operation, you can choose any 2 distinct leaves u, v and any real number x and add x to values written on all edges on the simple path between u and v.
For example, on the picture below you can see the result of applying two operations to the graph: adding 2 on the path from 7 to 6, and then adding -0.5 on the path from 4 to 5.
<image>
Is it true that for any configuration of real numbers written on edges, we can achieve it with a finite number of operations?
Leaf is a node of a tree of degree 1. Simple path is a path that doesn't contain any node twice.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of nodes.
Each of the next n-1 lines contains two integers u and v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v. It is guaranteed that these edges form a tree.
Output
If there is a configuration of real numbers written on edges of the tree that we can't achieve by performing the operations, output "NO".
Otherwise, output "YES".
You can print each letter in any case (upper or lower).
Examples
Input
2
1 2
Output
YES
Input
3
1 2
2 3
Output
NO
Input
5
1 2
1 3
1 4
2 5
Output
NO
Input
6
1 2
1 3
1 4
2 5
2 6
Output
YES
Note
In the first example, we can add any real x to the value written on the only edge (1, 2).
<image>
In the second example, one of configurations that we can't reach is 0 written on (1, 2) and 1 written on (2, 3).
<image>
Below you can see graphs from examples 3, 4:
<image> <image> | m = int(input())
l = [0 for _ in range(m + 1)]
for _ in range(m - 1):
a,b = map(int, input().split())
l[a] += 1
l[b] += 1
if 2 in l:
print("NO")
else:
print("YES")
|
An array of integers p_{1},p_{2}, …,p_{n} is called a permutation if it contains each number from 1 to n exactly once. For example, the following arrays are permutations: [3,1,2], [1], [1,2,3,4,5] and [4,3,1,2]. The following arrays are not permutations: [2], [1,1], [2,3,4].
There is a hidden permutation of length n.
For each index i, you are given s_{i}, which equals to the sum of all p_{j} such that j < i and p_{j} < p_{i}. In other words, s_i is the sum of elements before the i-th element that are smaller than the i-th element.
Your task is to restore the permutation.
Input
The first line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the size of the permutation.
The second line contains n integers s_{1}, s_{2}, …, s_{n} (0 ≤ s_{i} ≤ (n(n-1))/(2)).
It is guaranteed that the array s corresponds to a valid permutation of length n.
Output
Print n integers p_{1}, p_{2}, …, p_{n} — the elements of the restored permutation. We can show that the answer is always unique.
Examples
Input
3
0 0 0
Output
3 2 1
Input
2
0 1
Output
1 2
Input
5
0 1 1 1 10
Output
1 4 3 2 5
Note
In the first example for each i there is no index j satisfying both conditions, hence s_i are always 0.
In the second example for i = 2 it happens that j = 1 satisfies the conditions, so s_2 = p_1.
In the third example for i = 2, 3, 4 only j = 1 satisfies the conditions, so s_2 = s_3 = s_4 = 1. For i = 5 all j = 1, 2, 3, 4 are possible, so s_5 = p_1 + p_2 + p_3 + p_4 = 10. | #include <bits/stdc++.h>
using namespace std;
const long long maxN = 2 * 100224;
struct BIT {
long long data[maxN] = {0};
void update(long long idx, long long val) {
while (idx < maxN) {
data[idx] += val;
idx += idx & -idx;
}
}
void update(long long l, long long r, long long val) {
update(l, val);
update(r + 1, -val);
}
long long query(long long idx) {
long long res = 0;
while (idx > 0) {
res += data[idx];
idx -= idx & -idx;
}
return res;
}
long long query(long long l, long long r) { return query(r) - query(l); }
};
struct LazyBIT {
BIT bitAdd, bitSub;
void update(long long l, long long r, long long val) {
bitAdd.update(l, r, val);
bitSub.update(l, r, (l - 1) * val);
bitSub.update(r + 1, (-r + l - 1) * val);
}
long long query(long long idx) {
return idx * bitAdd.query(idx) - bitSub.query(idx);
}
long long query(long long l, long long r) { return query(r) - query(l - 1); }
};
long long parent[maxN];
long long rnk[maxN];
long long lfmost[maxN];
long long rtmost[maxN];
long long vis[maxN];
void make_set(long long v) {
parent[v] = v;
rnk[v] = 0;
lfmost[v] = v;
rtmost[v] = v;
}
long long find_set(long long v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(long long a, long long b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rnk[a] < rnk[b]) swap(a, b);
parent[b] = a;
lfmost[a] = min(lfmost[a], lfmost[b]);
rtmost[a] = max(rtmost[a], rtmost[b]);
if (rnk[a] == rnk[b]) rnk[a]++;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long n;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
long long sum = 0;
LazyBIT B;
for (long long i = 1; i <= n; i++) {
B.update(i, i, sum);
sum += i;
}
vector<long long> haha;
for (int i = n - 1; i >= 0; i--) {
long long lo = 1;
long long hi = n;
long long mid;
long long ans;
long long val;
long long temp;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (vis[mid] == 1) {
if (lfmost[find_set(mid)] - 1 >= lo)
mid = lfmost[find_set(mid)] - 1;
else if (rtmost[find_set(mid)] + 1 <= hi)
mid = rtmost[find_set(mid)] + 1;
else
break;
}
val = B.query(mid, mid);
if (val == v[i]) {
ans = mid;
hi = mid - 1;
} else if (v[i] > val) {
lo = mid + 1;
} else if (v[i] < val) {
hi = mid - 1;
}
}
B.update(ans, n, -ans);
vis[ans] = 1;
make_set(ans);
if (vis[ans] == 1 && vis[ans + 1] == 1) union_sets(ans, ans + 1);
if (vis[ans] == 1 && vis[ans - 1] == 1) union_sets(ans, ans - 1);
haha.push_back(ans);
}
reverse(haha.begin(), haha.end());
for (auto u : haha) {
cout << u << " ";
}
}
|
This is the easier version of the problem. In this version 1 ≤ n, m ≤ 100. You can hack this problem only if you solve and lock both problems.
You are given a sequence of integers a=[a_1,a_2,...,a_n] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:
* [11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
* [40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1 ≤ k ≤ n) is given, then the subsequence is called optimal if:
* it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
* and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b_1, b_2, ..., b_k] is lexicographically smaller than the sequence c=[c_1, c_2, ..., c_k] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1 ≤ t ≤ k) such that b_1=c_1, b_2=c_2, ..., b_{t-1}=c_{t-1} and at the same time b_t<c_t. For example:
* [10, 20, 20] lexicographically less than [10, 21, 1],
* [7, 99, 99] is lexicographically less than [10, 21, 1],
* [10, 21, 0] is lexicographically less than [10, 21, 1].
You are given a sequence of a=[a_1,a_2,...,a_n] and m requests, each consisting of two numbers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j). For each query, print the value that is in the index pos_j of the optimal subsequence of the given sequence a for k=k_j.
For example, if n=4, a=[10,20,30,20], k_j=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request k_j=2, pos_j=1 is the number 20, and the answer to the request k_j=2, pos_j=2 is the number 30.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the length of the sequence a.
The second line contains elements of the sequence a: integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The third line contains an integer m (1 ≤ m ≤ 100) — the number of requests.
The following m lines contain pairs of integers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j) — the requests.
Output
Print m integers r_1, r_2, ..., r_m (1 ≤ r_j ≤ 10^9) one per line: answers to the requests in the order they appear in the input. The value of r_j should be equal to the value contained in the position pos_j of the optimal subsequence for k=k_j.
Examples
Input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
20
10
20
10
20
10
Input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
Output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:
* for k=1: [20],
* for k=2: [10,20],
* for k=3: [10,20,10]. | # class SegmentTree(): # adapted from https://www.geeksforgeeks.org/segment-tree-efficient-implementation/
# def __init__(self,arr,func,initialRes=0):
# self.f=func
# self.N=len(arr)
# self.tree=[0 for _ in range(2*self.N)]
# self.initialRes=initialRes
# for i in range(self.N):
# self.tree[self.N+i]=arr[i]
# for i in range(self.N-1,0,-1):
# self.tree[i]=self.f(self.tree[i<<1],self.tree[i<<1|1])
# def updateTreeNode(self,idx,value): #update value at arr[idx]
# self.tree[idx+self.N]=value
# idx+=self.N
# i=idx
# while i>1:
# self.tree[i>>1]=self.f(self.tree[i],self.tree[i^1])
# i>>=1
# def query(self,l,r): #get sum (or whatever function) on interval [l,r] inclusive
# r+=1
# res=self.initialRes
# l+=self.N
# r+=self.N
# while l<r:
# if l&1:
# res=self.f(res,self.tree[l])
# l+=1
# if r&1:
# r-=1
# res=self.f(res,self.tree[r])
# l>>=1
# r>>=1
# return res
# def getMaxSegTree(arr):
# return SegmentTree(arr,lambda a,b:max(a,b),initialRes=-float('inf'))
# def getMinSegTree(arr):
# return SegmentTree(arr,lambda a,b:min(a,b),initialRes=float('inf'))
# def getSumSegTree(arr):
# return SegmentTree(arr,lambda a,b:a+b,initialRes=0)
from collections import Counter
def main():
# mlogn solution
n=int(input())
a=readIntArr()
b=sorted(a,reverse=True)
m=int(input())
allans=[]
for _ in range(m):
k,pos=readIntArr()
cnt=Counter(b[:k])
totalCnts=0
for x in a:
if cnt[x]>0:
cnt[x]-=1
totalCnts+=1
if totalCnts==pos:
allans.append(x)
break
multiLineArrayPrint(allans)
return
import sys
input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
# input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
# def readFloatArr():
# return [float(x) for x in input().split()]
def makeArr(defaultValFactory,dimensionArr): # eg. makeArr(lambda:0,[n,m])
dv=defaultValFactory;da=dimensionArr
if len(da)==1:return [dv() for _ in range(da[0])]
else:return [makeArr(dv,da[1:]) for _ in range(da[0])]
def queryInteractive(i,j):
print('? {} {}'.format(i,j))
sys.stdout.flush()
return int(input())
def answerInteractive(ans):
print('! {}'.format(' '.join([str(x) for x in ans])))
sys.stdout.flush()
inf=float('inf')
MOD=10**9+7
# MOD=998244353
for _abc in range(1):
main() |
You are given a permutation p_1, p_2, …, p_n.
In one move you can swap two adjacent values.
You want to perform a minimum number of moves, such that in the end there will exist a subsegment 1,2,…, k, in other words in the end there should be an integer i, 1 ≤ i ≤ n-k+1 such that p_i = 1, p_{i+1} = 2, …, p_{i+k-1}=k.
Let f(k) be the minimum number of moves that you need to make a subsegment with values 1,2,…,k appear in the permutation.
You need to find f(1), f(2), …, f(n).
Input
The first line of input contains one integer n (1 ≤ n ≤ 200 000): the number of elements in the permutation.
The next line of input contains n integers p_1, p_2, …, p_n: given permutation (1 ≤ p_i ≤ n).
Output
Print n integers, the minimum number of moves that you need to make a subsegment with values 1,2,…,k appear in the permutation, for k=1, 2, …, n.
Examples
Input
5
5 4 3 2 1
Output
0 1 3 6 10
Input
3
1 2 3
Output
0 0 0 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
int head[N];
int dis[N], ecnt;
int fa[N];
int cat[2005][2005];
long long gcd(long long a, long long b) {
return a % b == 0 ? b : gcd(b, a % b);
}
long long qpow(long long base, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans = (ans * base) % mod;
n >>= 1;
base = base * base % mod;
}
return ans;
}
struct Node {
long long x, y;
} nd[N];
long long m, n, x, k, y;
struct EDGE {
int u, v, nxt;
long long w;
} e[N];
bool cmp(EDGE a, EDGE b) { return a.w < b.w; }
void add_edge(int u, int v, long long w) {
e[ecnt].u = u;
e[ecnt].v = v;
e[ecnt].w = w;
e[ecnt].nxt = head[u];
head[u] = ecnt++;
}
int fd(int x) { return -1 == fa[x] ? x : fa[x] = fd(fa[x]); }
int c[N];
int lowbit(int x) { return x & (-x); }
void add(long long *c, int x, int y) {
while (x <= n) {
c[x] += y;
x += lowbit(x);
}
}
long long getsum(long long *c, int x) {
long long res = 0;
while (x > 0) {
res += c[x];
x -= lowbit(x);
}
return res;
}
int vis[N];
int p[N];
long long ans;
int C[55][55];
int dp[150][150];
long long posar[N], smar[N];
struct H {
int p, s;
friend bool operator<(H a, H b) { return a.p < b.p; }
} he[N];
bool cmp(int a, int b) { return a > b; }
priority_queue<int> q;
vector<int> v[30];
map<vector<int>, int> mp;
int ar[N];
int br[N];
vector<int> vv[10];
int main() {
{
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &ar[i]);
p[ar[i]] = i;
}
long long inv = 0;
for (int i = 1; i <= n; i++) {
inv += i - 1 - getsum(smar, p[i]);
add(smar, p[i], 1);
add(posar, p[i], p[i]);
int l = 1;
int r = n;
int mid;
while (l < r) {
mid = 1 + l + r >> 1;
if (getsum(smar, mid - 1) * 2 <= i)
l = mid;
else
r = mid - 1;
}
mid = l;
long long pre_cnt_sum = getsum(smar, mid),
pre_pos_sum = getsum(posar, mid);
long long mov =
pre_cnt_sum * mid - pre_pos_sum - pre_cnt_sum * (pre_cnt_sum - 1) / 2;
long long aft_cnt_sum = i - pre_cnt_sum;
mov += getsum(posar, n) - pre_pos_sum - aft_cnt_sum * mid -
aft_cnt_sum * (aft_cnt_sum + 1) / 2;
cout << inv + mov << " \n"[i == n];
}
}
return 0;
}
|
There are n lamps on a line, numbered from 1 to n. Each one has an initial state off (0) or on (1).
You're given k subsets A_1, …, A_k of \{1, 2, ..., n\}, such that the intersection of any three subsets is empty. In other words, for all 1 ≤ i_1 < i_2 < i_3 ≤ k, A_{i_1} ∩ A_{i_2} ∩ A_{i_3} = ∅.
In one operation, you can choose one of these k subsets and switch the state of all lamps in it. It is guaranteed that, with the given subsets, it's possible to make all lamps be simultaneously on using this type of operation.
Let m_i be the minimum number of operations you have to do in order to make the i first lamps be simultaneously on. Note that there is no condition upon the state of other lamps (between i+1 and n), they can be either off or on.
You have to compute m_i for all 1 ≤ i ≤ n.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 3 ⋅ 10^5).
The second line contains a binary string of length n, representing the initial state of each lamp (the lamp i is off if s_i = 0, on if s_i = 1).
The description of each one of the k subsets follows, in the following format:
The first line of the description contains a single integer c (1 ≤ c ≤ n) — the number of elements in the subset.
The second line of the description contains c distinct integers x_1, …, x_c (1 ≤ x_i ≤ n) — the elements of the subset.
It is guaranteed that:
* The intersection of any three subsets is empty;
* It's possible to make all lamps be simultaneously on using some operations.
Output
You must output n lines. The i-th line should contain a single integer m_i — the minimum number of operations required to make the lamps 1 to i be simultaneously on.
Examples
Input
7 3
0011100
3
1 4 6
3
3 4 7
2
2 3
Output
1
2
3
3
3
3
3
Input
8 6
00110011
3
1 3 8
5
1 2 5 6 7
2
6 8
2
3 5
2
4 7
1
2
Output
1
1
1
1
1
1
4
4
Input
5 3
00011
3
1 2 3
1
4
3
3 4 5
Output
1
1
1
1
1
Input
19 5
1001001001100000110
2
2 3
2
5 6
2
8 9
5
12 13 14 15 16
1
19
Output
0
1
1
1
2
2
2
3
3
3
3
4
4
4
4
4
4
4
5
Note
In the first example:
* For i = 1, we can just apply one operation on A_1, the final states will be 1010110;
* For i = 2, we can apply operations on A_1 and A_3, the final states will be 1100110;
* For i ≥ 3, we can apply operations on A_1, A_2 and A_3, the final states will be 1111111.
In the second example:
* For i ≤ 6, we can just apply one operation on A_2, the final states will be 11111101;
* For i ≥ 7, we can apply operations on A_1, A_3, A_4, A_6, the final states will be 11111111. | #include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int n, k;
char s[maxn];
int pre[maxn << 1], sz[maxn << 1];
vector<int> op[maxn];
int find(int x) { return x == pre[x] ? x : pre[x] = find(pre[x]); }
void merge(int x, int y) {
int fx = find(x), fy = find(y);
if (fy == 0) swap(fx, fy);
if (fx != fy) pre[fy] = fx, sz[fx] += sz[fy];
}
int cal(int x) {
int y = (x <= k) ? x + k : x - k;
int fx = find(x), fy = find(y);
if (fx == 0 || fy == 0) return sz[fx + fy];
return min(sz[fx], sz[fy]);
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
for (int i = 1; i <= k; i++) pre[i] = i, pre[i + k] = i + k, sz[i + k] = 1;
for (int i = 1, c, x; i <= k; i++) {
scanf("%d", &c);
while (c--) {
scanf("%d", &x);
op[x].push_back(i);
}
}
int res = 0;
for (int i = 1; i <= n; i++) {
if (op[i].size() == 1) {
int x = op[i][0];
res -= cal(x);
if (s[i] == '1')
pre[find(x + k)] = 0;
else
pre[find(x)] = 0;
res += cal(x);
} else if (op[i].size() == 2) {
int x = op[i][0], y = op[i][1];
if (s[i] == '1') {
if (find(x) != find(y)) {
res -= cal(x) + cal(y);
merge(x, y), merge(x + k, y + k);
res += cal(x);
}
} else {
if (find(x + k) != find(y)) {
res -= cal(x) + cal(y);
merge(x + k, y), merge(x, y + k);
res += cal(x);
}
}
}
printf("%d\n", res);
}
return 0;
}
|
There are n points on a coordinate axis OX. The i-th point is located at the integer point x_i and has a speed v_i. It is guaranteed that no two points occupy the same coordinate. All n points move with the constant speed, the coordinate of the i-th point at the moment t (t can be non-integer) is calculated as x_i + t ⋅ v_i.
Consider two points i and j. Let d(i, j) be the minimum possible distance between these two points over any possible moments of time (even non-integer). It means that if two points i and j coincide at some moment, the value d(i, j) will be 0.
Your task is to calculate the value ∑_{1 ≤ i < j ≤ n} d(i, j) (the sum of minimum distances over all pairs of points).
Input
The first line of the input contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of points.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^8), where x_i is the initial coordinate of the i-th point. It is guaranteed that all x_i are distinct.
The third line of the input contains n integers v_1, v_2, ..., v_n (-10^8 ≤ v_i ≤ 10^8), where v_i is the speed of the i-th point.
Output
Print one integer — the value ∑_{1 ≤ i < j ≤ n} d(i, j) (the sum of minimum distances over all pairs of points).
Examples
Input
3
1 3 2
-100 2 3
Output
3
Input
5
2 1 4 3 5
2 2 2 3 4
Output
19
Input
2
2 1
-3 0
Output
0 | import bisect
def getsum(tree , i):
s = 0
i += 1
while i>0:
s += tree[i]
i -= i & (-i)
return s
def updatebit(tree , n , i , v):
i+= 1
while i <= n:
tree[i] += v
i += i & (-i)
n = int(input())
x = list(map(int , input().split()))
v = list(map(int , input().split()))
p = [[x[i] , v[i]] for i in range(len(x))]
vs = sorted(list(set(v)))
p = sorted(p , key = lambda i : i[0])
l = len(vs)
cnt = [0]*(l+1)
xs = [0]*(l+1)
ans = 0
for pnt in p:
pos = bisect.bisect_left(vs , pnt[1])
ans += getsum(cnt , pos) * pnt[0] - getsum(xs , pos)
updatebit(cnt , l , pos , 1)
updatebit(xs , l , pos , pnt[0])
print(ans)
|
You are given a complete directed graph K_n with n vertices: each pair of vertices u ≠ v in K_n have both directed edges (u, v) and (v, u); there are no self-loops.
You should find such a cycle in K_n that visits every directed edge exactly once (allowing for revisiting vertices).
We can write such cycle as a list of n(n - 1) + 1 vertices v_1, v_2, v_3, ..., v_{n(n - 1) - 1}, v_{n(n - 1)}, v_{n(n - 1) + 1} = v_1 — a visiting order, where each (v_i, v_{i + 1}) occurs exactly once.
Find the lexicographically smallest such cycle. It's not hard to prove that the cycle always exists.
Since the answer can be too large print its [l, r] segment, in other words, v_l, v_{l + 1}, ..., v_r.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of test cases.
Next T lines contain test cases — one per line. The first and only line of each test case contains three integers n, l and r (2 ≤ n ≤ 10^5, 1 ≤ l ≤ r ≤ n(n - 1) + 1, r - l + 1 ≤ 10^5) — the number of vertices in K_n, and segment of the cycle to print.
It's guaranteed that the total sum of n doesn't exceed 10^5 and the total sum of r - l + 1 doesn't exceed 10^5.
Output
For each test case print the segment v_l, v_{l + 1}, ..., v_r of the lexicographically smallest cycle that visits every edge exactly once.
Example
Input
3
2 1 3
3 3 6
99995 9998900031 9998900031
Output
1 2 1
1 3 2 3
1
Note
In the second test case, the lexicographically minimum cycle looks like: 1, 2, 1, 3, 2, 3, 1.
In the third test case, it's quite obvious that the cycle should start and end in vertex 1. | #include <bits/stdc++.h>
using namespace std;
long long n;
int tc = 0;
int solve();
int main() {
ios_base::sync_with_stdio(0);
if (tc < 0) {
cout << "TC!\n";
cin.ignore(1e8);
} else if (!tc)
cin >> tc;
while (tc--) solve();
return 0;
}
int solve() {
long long l, r;
cin >> n >> l >> r;
l--;
r--;
long long a = 1;
while (1) {
if (l > 2 * (n - a)) {
l -= 2 * (n - a);
r -= 2 * (n - a);
a++;
} else
break;
}
vector<long long> ans;
int b = a + 1;
while (ans.size() <= r + 1) {
ans.push_back(a);
ans.push_back(b);
b++;
if (b == n + 1) {
a++;
if (a == n) {
ans.push_back(1);
break;
}
b = a + 1;
}
}
for (int i = l; i <= r; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
|
Polycarp plays a computer game. In this game, the players summon armies of magical minions, which then fight each other.
Polycarp can summon n different minions. The initial power level of the i-th minion is a_i, and when it is summoned, all previously summoned minions' power levels are increased by b_i. The minions can be summoned in any order.
Unfortunately, Polycarp cannot have more than k minions under his control. To get rid of unwanted minions after summoning them, he may destroy them. Each minion can be summoned (and destroyed) only once.
Polycarp's goal is to summon the strongest possible army. Formally, he wants to maximize the sum of power levels of all minions under his control (those which are summoned and not destroyed).
Help Polycarp to make up a plan of actions to summon the strongest possible army!
Input
The first line contains one integer T (1 ≤ T ≤ 75) — the number of test cases.
Each test case begins with a line containing two integers n and k (1 ≤ k ≤ n ≤ 75) — the number of minions availible for summoning, and the maximum number of minions that can be controlled by Polycarp, respectively.
Then n lines follow, the i-th line contains 2 integers a_i and b_i (1 ≤ a_i ≤ 10^5, 0 ≤ b_i ≤ 10^5) — the parameters of the i-th minion.
Output
For each test case print the optimal sequence of actions as follows:
Firstly, print m — the number of actions which Polycarp has to perform (0 ≤ m ≤ 2n). Then print m integers o_1, o_2, ..., o_m, where o_i denotes the i-th action as follows: if the i-th action is to summon the minion x, then o_i = x, and if the i-th action is to destroy the minion x, then o_i = -x. Each minion can be summoned at most once and cannot be destroyed before being summoned (and, obviously, cannot be destroyed more than once). The number of minions in Polycarp's army should be not greater than k after every action.
If there are multiple optimal sequences, print any of them.
Example
Input
3
5 2
5 3
7 0
5 0
4 0
10 0
2 1
10 100
50 10
5 5
1 5
2 4
3 3
4 2
5 1
Output
4
2 1 -1 5
1
2
5
5 4 3 2 1
Note
Consider the example test.
In the first test case, Polycarp can summon the minion 2 with power level 7, then summon the minion 1, which will increase the power level of the previous minion by 3, then destroy the minion 1, and finally, summon the minion 5. After this, Polycarp will have two minions with power levels of 10.
In the second test case, Polycarp can control only one minion, so he should choose the strongest of them and summon it.
In the third test case, Polycarp is able to summon and control all five minions. | #include <bits/stdc++.h>
using namespace std;
struct Edge {
long long to, dis, next, cost;
} edge[24050];
long long num = -1;
bool vis[10010];
long long mincost;
long long pre[10010], head[10010], cost[10010], last[10010], flow[10010], n, k,
a[110], b[110], s, t, maxflow;
long long to[110];
void add(long long f, long long t, long long dis, long long cost) {
edge[++num].to = t;
edge[num].dis = dis;
edge[num].next = head[f];
edge[num].cost = cost;
head[f] = num;
edge[++num].to = f;
edge[num].dis = 0;
edge[num].cost = -cost;
edge[num].next = head[t];
head[t] = num;
}
queue<long long> q;
bool spfa(long long s, long long t) {
memset(cost, 0x3f3f3f3f, sizeof cost);
memset(flow, 0x3f3f3f3f, sizeof flow);
memset(vis, 0, sizeof vis);
q.push(s);
vis[s] = 1;
cost[s] = 0;
pre[t] = -1;
while (!q.empty()) {
long long nowp = q.front();
q.pop();
vis[nowp] = 0;
for (long long i = head[nowp]; i != -1; i = edge[i].next) {
if (edge[i].dis > 0 && cost[edge[i].to] > cost[nowp] + edge[i].cost) {
cost[edge[i].to] = cost[nowp] + edge[i].cost;
pre[edge[i].to] = nowp;
last[edge[i].to] = i;
flow[edge[i].to] = min(flow[nowp], edge[i].dis);
if (!vis[edge[i].to]) {
vis[edge[i].to] = 1;
q.push(edge[i].to);
}
}
}
}
return pre[t] != -1;
}
void MCMF(long long s, long long t) {
while (spfa(s, t)) {
long long now = t;
maxflow += flow[t];
mincost += flow[t] * cost[t];
while (now != s) {
edge[last[now]].dis -= flow[t];
edge[last[now] ^ 1].dis += flow[t];
now = pre[now];
}
}
}
signed main() {
long long T;
cin >> T;
while (T--) {
num = -1;
memset(to, -1, sizeof to);
memset(head, -1, sizeof head);
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> a[i] >> b[i];
maxflow = mincost = 0;
s = 0;
t = 2 * n + 1;
for (long long i = 1; i <= n; i++) add(s, i, 1, 0), add(i + n, t, 1, 0);
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= n; j++) {
long long nc = 0;
if (j <= k - 1)
nc = a[i] + b[i] * (j - 1ll);
else if (j != n)
nc = b[i] * (k - 1ll);
else
nc = a[i] + b[i] * (k - 1ll);
nc = 0x3f3f3f3f - nc;
add(i, j + n, 1, nc);
}
}
MCMF(s, t);
long long nowi = -1;
for (long long i = n * 4; i <= num; i += 2) {
nowi++;
if (edge[i].dis == 0) to[1 + nowi % n] = 1 + nowi / n;
}
cout << 2 * n - k << endl;
for (long long i = 1; i <= k - 1; i++) cout << to[i] << " ";
for (long long i = k; i < n; i++) cout << to[i] << " " << -to[i] << " ";
cout << to[n];
cout << endl;
}
return 0;
}
|
Easy and hard versions are actually different problems, so read statements of both problems completely and carefully.
Summer vacation has started so Alice and Bob want to play and joy, but... Their mom doesn't think so. She says that they have to read some amount of books before all entertainments. Alice and Bob will read each book together to end this exercise faster.
There are n books in the family library. The i-th book is described by three integers: t_i — the amount of time Alice and Bob need to spend to read it, a_i (equals 1 if Alice likes the i-th book and 0 if not), and b_i (equals 1 if Bob likes the i-th book and 0 if not).
So they need to choose some books from the given n books in such a way that:
* Alice likes at least k books from the chosen set and Bob likes at least k books from the chosen set;
* the total reading time of these books is minimized (they are children and want to play and joy as soon a possible).
The set they choose is the same for both Alice an Bob (it's shared between them) and they read all books together, so the total reading time is the sum of t_i over all books that are in the chosen set.
Your task is to help them and find any suitable set of books or determine that it is impossible to find such a set.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2 ⋅ 10^5).
The next n lines contain descriptions of books, one description per line: the i-th line contains three integers t_i, a_i and b_i (1 ≤ t_i ≤ 10^4, 0 ≤ a_i, b_i ≤ 1), where:
* t_i — the amount of time required for reading the i-th book;
* a_i equals 1 if Alice likes the i-th book and 0 otherwise;
* b_i equals 1 if Bob likes the i-th book and 0 otherwise.
Output
If there is no solution, print only one integer -1. Otherwise print one integer T — the minimum total reading time of the suitable set of books.
Examples
Input
8 4
7 1 1
2 1 1
4 0 1
8 1 1
1 0 1
1 1 1
1 0 1
3 0 0
Output
18
Input
5 2
6 0 0
9 0 0
1 0 1
2 1 1
5 1 0
Output
8
Input
5 3
3 0 0
2 1 0
3 1 0
5 0 1
3 0 1
Output
-1 | #include <bits/stdc++.h>
using namespace std;
template <typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
int n, k, a, b;
long long t;
vector<long long> ve[2][2];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = (0); i < (n); i++) {
cin >> t >> a >> b;
ve[a][b].push_back(t);
}
sort((ve[0][1]).begin(), (ve[0][1]).end());
sort((ve[1][0]).begin(), (ve[1][0]).end());
vector<long long> sums;
for (long long x : ve[1][1]) sums.push_back(x);
for (int i = 0; i < min(((int)(ve[0][1]).size()), ((int)(ve[1][0]).size()));
i++) {
sums.push_back(ve[0][1][i] + ve[1][0][i]);
}
sort((sums).begin(), (sums).end());
if (((int)(sums).size()) < k) {
cout << "-1\n";
return 0;
}
cout << accumulate(sums.begin(), sums.begin() + k, 0LL) << '\n';
}
|
You are given an array a_1, a_2, ... , a_n, which is sorted in non-decreasing order (a_i ≤ a_{i + 1}).
Find three indices i, j, k such that 1 ≤ i < j < k ≤ n and it is impossible to construct a non-degenerate triangle (a triangle with nonzero area) having sides equal to a_i, a_j and a_k (for example it is possible to construct a non-degenerate triangle with sides 3, 4 and 5 but impossible with sides 3, 4 and 7). If it is impossible to find such triple, report it.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains one integer n (3 ≤ n ≤ 5 ⋅ 10^4) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9; a_{i - 1} ≤ a_i) — the array a.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case print the answer to it in one line.
If there is a triple of indices i, j, k (i < j < k) such that it is impossible to construct a non-degenerate triangle having sides equal to a_i, a_j and a_k, print that three indices in ascending order. If there are multiple answers, print any of them.
Otherwise, print -1.
Example
Input
3
7
4 6 11 11 15 18 20
4
10 10 10 11
3
1 1 1000000000
Output
2 3 6
-1
1 2 3
Note
In the first test case it is impossible with sides 6, 11 and 18. Note, that this is not the only correct answer.
In the second test case you always can construct a non-degenerate triangle. | import java.util.*;
public class BadTriangle {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int t = s.nextInt();
while (t-- > 0) {
int n = s.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; ++i) {
a[i] = s.nextInt();
}
if (a[n - 1] >= a[0] + a[1]) {
System.out.println("1 2 " + n);
} else {
System.out.println(-1);
}
}
}
} |
Pink Floyd are pulling a prank on Roger Waters. They know he doesn't like [walls](https://www.youtube.com/watch?v=YR5ApYxkU-U), he wants to be able to walk freely, so they are blocking him from exiting his room which can be seen as a grid.
Roger Waters has a square grid of size n× n and he wants to traverse his grid from the upper left (1,1) corner to the lower right corner (n,n). Waters can move from a square to any other square adjacent by a side, as long as he is still in the grid. Also except for the cells (1,1) and (n,n) every cell has a value 0 or 1 in it.
Before starting his traversal he will pick either a 0 or a 1 and will be able to only go to cells values in which are equal to the digit he chose. The starting and finishing cells (1,1) and (n,n) are exempt from this rule, he may go through them regardless of picked digit. Because of this the cell (1,1) takes value the letter 'S' and the cell (n,n) takes value the letter 'F'.
For example, in the first example test case, he can go from (1, 1) to (n, n) by using the zeroes on this path: (1, 1), (2, 1), (2, 2), (2, 3), (3, 3), (3, 4), (4, 4)
The rest of the band (Pink Floyd) wants Waters to not be able to do his traversal, so while he is not looking they will invert at most two cells in the grid (from 0 to 1 or vice versa). They are afraid they will not be quick enough and asked for your help in choosing the cells. Note that you cannot invert cells (1, 1) and (n, n).
We can show that there always exists a solution for the given constraints.
Also note that Waters will pick his digit of the traversal after the band has changed his grid, so he must not be able to reach (n,n) no matter what digit he picks.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 50). Description of the test cases follows.
The first line of each test case contains one integers n (3 ≤ n ≤ 200).
The following n lines of each test case contain the binary grid, square (1, 1) being colored in 'S' and square (n, n) being colored in 'F'.
The sum of values of n doesn't exceed 200.
Output
For each test case output on the first line an integer c (0 ≤ c ≤ 2) — the number of inverted cells.
In i-th of the following c lines, print the coordinates of the i-th cell you inverted. You may not invert the same cell twice. Note that you cannot invert cells (1, 1) and (n, n).
Example
Input
3
4
S010
0001
1000
111F
3
S10
101
01F
5
S0101
00000
01111
11111
0001F
Output
1
3 4
2
1 2
2 1
0
Note
For the first test case, after inverting the cell, we get the following grid:
S010
0001
1001
111F
| l=[]
for _ in range(int(input())):
n=int(input())
a=[]
for i in range(n):
a.append(list(input()))
if a[0][1]==a[1][0]:
if a[n-1][n-2]==a[n-2][n-1]:
if a[n-1][n-2]==a[0][1]:
l.append("2")
l.append("1 2")
l.append("2 1")
else:
l.append("0")
else:
if a[n-1][n-2]!=a[0][1]:
l.append("1")
l.append(str(n-1)+" "+str(n))
else:
l.append("1")
l.append(str(n)+" "+str(n-1))
else:
if a[n-1][n-2]==a[n-2][n-1]:
if a[n-1][n-2]!=a[0][1]:
l.append("1")
l.append("2 1")
else:
l.append("1")
l.append("1 2")
else:
if a[0][1]!=a[n-2][n-1]:
l.append("2")
l.append("1 2")
l.append(str(n-1)+" "+str(n))
else:
l.append("2")
l.append("2 1")
l.append(str(n - 1)+" "+ str(n))
for i in l:
print(i) |
Vasilisa the Wise from the Kingdom of Far Far Away got a magic box with a secret as a present from her friend Hellawisa the Wise from the Kingdom of A Little Closer. However, Vasilisa the Wise does not know what the box's secret is, since she cannot open it again. She hopes that you will help her one more time with that.
The box's lock looks as follows: it contains 4 identical deepenings for gems as a 2 × 2 square, and some integer numbers are written at the lock's edge near the deepenings. The example of a lock is given on the picture below.
<image>
The box is accompanied with 9 gems. Their shapes match the deepenings' shapes and each gem contains one number from 1 to 9 (each number is written on exactly one gem). The box will only open after it is decorated with gems correctly: that is, each deepening in the lock should be filled with exactly one gem. Also, the sums of numbers in the square's rows, columns and two diagonals of the square should match the numbers written at the lock's edge. For example, the above lock will open if we fill the deepenings with gems with numbers as is shown on the picture below.
<image>
Now Vasilisa the Wise wants to define, given the numbers on the box's lock, which gems she should put in the deepenings to open the box. Help Vasilisa to solve this challenging task.
Input
The input contains numbers written on the edges of the lock of the box. The first line contains space-separated integers r1 and r2 that define the required sums of numbers in the rows of the square. The second line contains space-separated integers c1 and c2 that define the required sums of numbers in the columns of the square. The third line contains space-separated integers d1 and d2 that define the required sums of numbers on the main and on the side diagonals of the square (1 ≤ r1, r2, c1, c2, d1, d2 ≤ 20). Correspondence between the above 6 variables and places where they are written is shown on the picture below. For more clarifications please look at the second sample test that demonstrates the example given in the problem statement.
<image>
Output
Print the scheme of decorating the box with stones: two lines containing two space-separated integers from 1 to 9. The numbers should be pairwise different. If there is no solution for the given lock, then print the single number "-1" (without the quotes).
If there are several solutions, output any.
Examples
Input
3 7
4 6
5 5
Output
1 2
3 4
Input
11 10
13 8
5 16
Output
4 7
9 1
Input
1 2
3 4
5 6
Output
-1
Input
10 10
10 10
10 10
Output
-1
Note
Pay attention to the last test from the statement: it is impossible to open the box because for that Vasilisa the Wise would need 4 identical gems containing number "5". However, Vasilisa only has one gem with each number from 1 to 9. | import java.util.Scanner;
public class HelpVasilisaTheWise {
public static void main (String [] args) {
Scanner in = new Scanner(System.in);
int r1 = in.nextInt();
int r2 = in.nextInt();
int c1 = in.nextInt();
int c2 = in.nextInt();
int d1 = in.nextInt();
int d2 = in.nextInt();
int a1=0, a2=0, a3=0, a4=0;
boolean sw = true;
for (int i=1; i<=9; i++) {
a1 = i;
a2 = r1 - a1;
a3 = c1 - a1;
a4 = d1 - a1;
if( r2 == a3 + a4 && c2 == a2 + a4 && d2 == a3 + a2 ) {
if( !(a2 < 1 || a3 < 1 || a4 < 1 || a2 > 9 || a3 > 9 || a4 > 9 || a1 == a2 || a1 == a3 || a1 == a4 || a2 == a3 || a2 == a4 || a3 == a4) ) {
System.out.println(a1 + " " + a2);
System.out.println(a3 + " " + a4);
sw = false;
break;
}
}
}
if (sw) {
System.out.println("-1");
}
}
} |
You may know that Euclid was a mathematician. Well, as it turns out, Morpheus knew it too. So when he wanted to play a mean trick on Euclid, he sent him an appropriate nightmare.
In his bad dream Euclid has a set S of n m-dimensional vectors over the Z_2 field and can perform vector addition on them. In other words he has vectors with m coordinates, each one equal either 0 or 1. Vector addition is defined as follows: let u+v = w, then w_i = (u_i + v_i) mod 2.
Euclid can sum any subset of S and archive another m-dimensional vector over Z_2. In particular, he can sum together an empty subset; in such a case, the resulting vector has all coordinates equal 0.
Let T be the set of all the vectors that can be written as a sum of some vectors from S. Now Euclid wonders the size of T and whether he can use only a subset S' of S to obtain all the vectors from T. As it is usually the case in such scenarios, he will not wake up until he figures this out. So far, things are looking rather grim for the philosopher. But there is hope, as he noticed that all vectors in S have at most 2 coordinates equal 1.
Help Euclid and calculate |T|, the number of m-dimensional vectors over Z_2 that can be written as a sum of some vectors from S. As it can be quite large, calculate it modulo 10^9+7. You should also find S', the smallest such subset of S, that all vectors in T can be written as a sum of vectors from S'. In case there are multiple such sets with a minimal number of elements, output the lexicographically smallest one with respect to the order in which their elements are given in the input.
Consider sets A and B such that |A| = |B|. Let a_1, a_2, ... a_{|A|} and b_1, b_2, ... b_{|B|} be increasing arrays of indices elements of A and B correspondingly. A is lexicographically smaller than B iff there exists such i that a_j = b_j for all j < i and a_i < b_i.
Input
In the first line of input, there are two integers n, m (1 ≤ n, m ≤ 5 ⋅ 10^5) denoting the number of vectors in S and the number of dimensions.
Next n lines contain the description of the vectors in S. In each of them there is an integer k (1 ≤ k ≤ 2) and then follow k distinct integers x_1, ... x_k (1 ≤ x_i ≤ m). This encodes an m-dimensional vector having 1s on coordinates x_1, ... x_k and 0s on the rest of them.
Among the n vectors, no two are the same.
Output
In the first line, output two integers: remainder modulo 10^9+7 of |T| and |S'|. In the second line, output |S'| numbers, indices of the elements of S' in ascending order. The elements of S are numbered from 1 in the order they are given in the input.
Examples
Input
3 2
1 1
1 2
2 2 1
Output
4 2
1 2
Input
2 3
2 1 3
2 1 2
Output
4 2
1 2
Input
3 5
2 1 2
1 3
1 4
Output
8 3
1 2 3
Note
In the first example we are given three vectors:
* 10
* 01
* 11
It turns out that we can represent all vectors from our 2-dimensional space using these vectors:
* 00 is a sum of the empty subset of above vectors;
* 01 = 11 + 10, is a sum of the first and third vector;
* 10 = 10, is just the first vector;
* 11 = 10 + 01, is a sum of the first and the second vector.
Hence, T = \{00, 01, 10, 11\}. We can choose any two of the three vectors from S and still be able to obtain all the vectors in T. In such a case, we choose the two vectors which appear first in the input. Since we cannot obtain all vectors in T using only a single vector from S, |S'| = 2 and S' = \{10, 01\} (indices 1 and 2), as set \{1, 2 \} is lexicographically the smallest. We can represent all vectors from T, using only vectors from S', as shown below:
* 00 is a sum of the empty subset;
* 01 = 01 is just the second vector;
* 10 = 10 is just the first vector;
* 11 = 10 + 01 is a sum of the first and the second vector. | #include <bits/stdc++.h>
#define fst first
#define snd second
#define fore(i,a,b) for(int i=a,ThxDem=b;i<ThxDem;++i)
#define pb push_back
#define ALL(s) s.begin(),s.end()
#define FIN ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define SZ(s) int(s.size())
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;
const int MAXN=5e5+10,MOD=1e9+7;
int add(int a, int b){a+=b;if(a>=MOD)a-=MOD;return a;}
int sub(int a, int b){a-=b;if(a<0)a+=MOD;return a;}
int mul(ll a, ll b){return a*b%MOD;}
int fpow(int a, ll b){
int r=1;
while(b){if(b&1)r=mul(r,a); b>>=1; a=mul(a,a);}
return r;
}
int p[MAXN],am[MAXN],did[MAXN];
int find(int x){return p[x]=p[x]==x?x:find(p[x]);}
bool join(int x, int y){
x=find(x); y=find(y);
if(x==y)return 0;
if(x!=y)p[x]=y,am[y]|=am[x];
return 1;
}
int main(){FIN;
int n,m,tot=0; cin>>n>>m;
fore(i,0,m) p[i]=i;
fore(i,0,n){
int k; cin>>k;
if(k==1){
int x; cin>>x; x--;
if(!am[find(x)]) am[find(x)]=1,did[i]=1,tot++;
}
if(k==2){
int x,y; cin>>x>>y; x--; y--;
int has=am[find(x)]&&am[find(y)];
if(join(x,y)&&!has)did[i]=1,tot++;
}
}
cout<<fpow(2,tot)<<" "<<tot<<"\n";
fore(i,0,n)if(did[i])cout<<i+1<<" ";cout<<"\n";
} |
Polycarp was dismantling his attic and found an old floppy drive on it. A round disc was inserted into the drive with n integers written on it.
Polycarp wrote the numbers from the disk into the a array. It turned out that the drive works according to the following algorithm:
* the drive takes one positive number x as input and puts a pointer to the first element of the a array;
* after that, the drive starts rotating the disk, every second moving the pointer to the next element, counting the sum of all the elements that have been under the pointer. Since the disk is round, in the a array, the last element is again followed by the first one;
* as soon as the sum is at least x, the drive will shut down.
Polycarp wants to learn more about the operation of the drive, but he has absolutely no free time. So he asked you m questions. To answer the i-th of them, you need to find how many seconds the drive will work if you give it x_i as input. Please note that in some cases the drive can work infinitely.
For example, if n=3, m=3, a=[1, -3, 4] and x=[1, 5, 2], then the answers to the questions are as follows:
* the answer to the first query is 0 because the drive initially points to the first item and the initial sum is 1.
* the answer to the second query is 6, the drive will spin the disk completely twice and the amount becomes 1+(-3)+4+1+(-3)+4+1=5.
* the answer to the third query is 2, the amount is 1+(-3)+4=2.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of two positive integers n, m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of numbers on the disk and the number of asked questions.
The second line of each test case contains n integers a_1, a_2, …, a_n (-10^9 ≤ a_i ≤ 10^9).
The third line of each test case contains m positive integers x_1, x_2, …, x_m (1 ≤ x ≤ 10^9).
It is guaranteed that the sums of n and m over all test cases do not exceed 2 ⋅ 10^5.
Output
Print m numbers on a separate line for each test case. The i-th number is:
* -1 if the drive will run infinitely;
* the number of seconds the drive will run, otherwise.
Example
Input
3
3 3
1 -3 4
1 5 2
2 2
-2 0
1 2
2 2
0 1
1 2
Output
0 6 2
-1 -1
1 3 |
def findIndexGE(prefixSumsMax,startSum,query):
n=len(prefixSumsMax)
b=n
i=-1
while b>0:
while i+b<n and startSum+prefixSumsMax[i+b]<query:
i+=b
b//=2
i+=1
return i
def main():
t=int(input())
allans=[]
for _ in range(t):
n,m=readIntArr()
arr=readIntArr() #numbers of disk
queries=readIntArr()
prefixSums=arr.copy()
for i in range(1,n):
prefixSums[i]+=prefixSums[i-1]
maxP=max(prefixSums)
prefixSumsMax=prefixSums.copy()
for i in range(1,n):
prefixSumsMax[i]=max(prefixSumsMax[i-1],prefixSums[i])
ans=[]
for q in queries:
if prefixSums[n-1]<=0:
if q>maxP: #drive will run indefinitely
ans.append(-1)
else:
ans.append(findIndexGE(prefixSumsMax,0,q))
else:
#find number of cycles
nCycles=-1
b=10**9
while b>0:
while prefixSums[n-1]*(nCycles+b)+maxP<q:
nCycles+=b
b//=2
nCycles+=1
startSum=prefixSums[n-1]*nCycles
lastCycleIdx=findIndexGE(prefixSumsMax,startSum,q)
ans.append(nCycles*n+lastCycleIdx)
allans.append(ans)
multiLineArrayOfArraysPrint(allans)
return
#import sys
#input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
import sys
input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
inf=float('inf')
MOD=10**9+7
main() |
You are given an integer n. You have to apply m operations to it.
In a single operation, you must replace every digit d of the number with the decimal representation of integer d + 1. For example, 1912 becomes 21023 after applying the operation once.
You have to find the length of n after applying m operations. Since the answer can be very large, print it modulo 10^9+7.
Input
The first line contains a single integer t (1 ≤ t ≤ 2 ⋅ 10^5) — the number of test cases.
The only line of each test case contains two integers n (1 ≤ n ≤ 10^9) and m (1 ≤ m ≤ 2 ⋅ 10^5) — the initial number and the number of operations.
Output
For each test case output the length of the resulting number modulo 10^9+7.
Example
Input
5
1912 1
5 6
999 1
88 2
12 100
Output
5
2
6
4
2115
Note
For the first test, 1912 becomes 21023 after 1 operation which is of length 5.
For the second test, 5 becomes 21 after 6 operations which is of length 2.
For the third test, 999 becomes 101010 after 1 operation which is of length 6.
For the fourth test, 88 becomes 1010 after 2 operations which is of length 4. | from os import path
import sys,time
from math import ceil, floor,gcd,log,log2 ,factorial
from collections import defaultdict ,Counter , OrderedDict , deque
from heapq import heapify , heappush , heappop
from bisect import *
# from functools import reduce
from operator import mul
from itertools import permutations
maxx, mod = float('inf') , int(1e9 + 7)
localsys ,start_time = 0 , time.time()
if (path.exists('input.txt')):
localsys = 1;sys.stdin=open('input.txt','r');sys.stdout=open('output.txt','w');
#left shift --- num*(2**k) --(k - shift)
input = sys.stdin.readline
N = int(2e5 + 10)
dp =[1]*N
for i in range(10 , N):
dp[i] = (dp[i-9] + dp[i-10])%mod
for _ in range(int(input())):
n , m = map(int , input().split()) ; ans =0
while n :
i = n%10 ; n//=10
ans = (ans + dp[i + m])%mod
print(ans)
if localsys:
print("\n\n\nTime Elased :",time.time() - start_time,"seconds") |
This is the easy version of the problem. The only difference is that in this version q = 1. You can make hacks only if both versions of the problem are solved.
There is a process that takes place on arrays a and b of length n and length n-1 respectively.
The process is an infinite sequence of operations. Each operation is as follows:
* First, choose a random integer i (1 ≤ i ≤ n-1).
* Then, simultaneously set a_i = min\left(a_i, \frac{a_i+a_{i+1}-b_i}{2}\right) and a_{i+1} = max\left(a_{i+1}, \frac{a_i+a_{i+1}+b_i}{2}\right) without any rounding (so values may become non-integer).
See notes for an example of an operation.
It can be proven that array a converges, i. e. for each i there exists a limit a_i converges to. Let function F(a, b) return the value a_1 converges to after a process on a and b.
You are given array b, but not array a. However, you are given a third array c. Array a is good if it contains only integers and satisfies 0 ≤ a_i ≤ c_i for 1 ≤ i ≤ n.
Your task is to count the number of good arrays a where F(a, b) ≥ x for q values of x. Since the number of arrays can be very large, print it modulo 10^9+7.
Input
The first line contains a single integer n (2 ≤ n ≤ 100).
The second line contains n integers c_1, c_2 …, c_n (0 ≤ c_i ≤ 100).
The third line contains n-1 integers b_1, b_2, …, b_{n-1} (0 ≤ b_i ≤ 100).
The fourth line contains a single integer q (q=1).
The fifth line contains q space separated integers x_1, x_2, …, x_q (-10^5 ≤ x_i ≤ 10^5).
Output
Output q integers, where the i-th integer is the answer to the i-th query, i. e. the number of good arrays a where F(a, b) ≥ x_i modulo 10^9+7.
Example
Input
3
2 3 4
2 1
1
-1
Output
56
Note
The following explanation assumes b = [2, 1] and c=[2, 3, 4] (as in the sample).
Examples of arrays a that are not good:
* a = [3, 2, 3] is not good because a_1 > c_1;
* a = [0, -1, 3] is not good because a_2 < 0.
One possible good array a is [0, 2, 4]. We can show that no operation has any effect on this array, so F(a, b) = a_1 = 0.
Another possible good array a is [0, 1, 4]. In a single operation with i = 1, we set a_1 = min((0+1-2)/(2), 0) and a_2 = max((0+1+2)/(2), 1). So, after a single operation with i = 1, a becomes equal to [-1/2, 3/2, 4]. We can show that no operation has any effect on this array, so F(a, b) = -1/2. | #include<bits/stdc++.h>
#define pii pair<int,int>
#define fi first
#define sc second
#define pb push_back
#define ll long long
#define trav(v,x) for(auto v:x)
#define all(x) (x).begin(), (x).end()
#define VI vector<int>
#define VLL vector<ll>
using namespace std;
const int N = 1e6 + 100;
const ll mod = 1e9 + 7;
signed main()
{
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
VI mx(n + 1);
for(int i = 1; i <= n; i++)
cin >> mx[i];
VI b(n + 1);
for(int i = 1; i < n; i++)
cin >> b[i], b[i] += b[i - 1];
for(int i = 1; i < n; i++)
b[i] += b[i - 1];
vector<VLL> dp(n + 1, VLL(10010, 0));
// VLL ans(300);
ll ans = 0;
int x;
cin >> x;
cin >> x;
// for(int x = -101; x <= 101; x++)
{
dp[0][0] = 1;
int suma = 0;
for(int i = 1; i <= n; i++)
{
fill(all(dp[i]), 0);
for(int val = 0; val <= mx[i]; val++)
{
int mn = b[i - 1] + x * i - val;
mn = max(mn, 0);
for(int bf = mn; bf <= suma; bf++)
{
dp[i][val + bf] += dp[i - 1][bf];
if(dp[i][val + bf] >= mod)dp[i][val + bf] -= mod;
}
}
suma += mx[i];
}
// ans[x + 110] = 0;
// for(int i = 0; i <= suma; i++)
// {
// ans[x + 110] += dp[n][i];
// if(ans[x + 110] >= mod)ans[x + 110] -= mod;
// }
ans = 0;
for(int i = 0; i <= suma; i++)
{
ans+= dp[n][i];
if(ans >= mod)ans -= mod;
}
cout << ans << '\n';
}
// int tt;
// cin >> tt;
// while(tt --)
// {
// int x;
// cin >> x;
// x = max(x, -101);
// x = min(x, 101);
// cout << ans[x + 110] << '\n';
// }
}
|
Some country is populated by wizards. They want to organize a demonstration.
There are n people living in the city, x of them are the wizards who will surely go to the demonstration. Other city people (n - x people) do not support the wizards and aren't going to go to the demonstration. We know that the city administration will react only to the demonstration involving at least y percent of the city people. Having considered the matter, the wizards decided to create clone puppets which can substitute the city people on the demonstration.
So all in all, the demonstration will involve only the wizards and their puppets. The city administration cannot tell the difference between a puppet and a person, so, as they calculate the percentage, the administration will consider the city to be consisting of only n people and not containing any clone puppets.
Help the wizards and find the minimum number of clones to create to that the demonstration had no less than y percent of the city people.
Input
The first line contains three space-separated integers, n, x, y (1 ≤ n, x, y ≤ 104, x ≤ n) — the number of citizens in the city, the number of wizards and the percentage the administration needs, correspondingly.
Please note that y can exceed 100 percent, that is, the administration wants to see on a demonstration more people that actually live in the city ( > n).
Output
Print a single integer — the answer to the problem, the minimum number of clones to create, so that the demonstration involved no less than y percent of n (the real total city population).
Examples
Input
10 1 14
Output
1
Input
20 10 50
Output
0
Input
1000 352 146
Output
1108
Note
In the first sample it is necessary that at least 14% of 10 people came to the demonstration. As the number of people should be integer, then at least two people should come. There is only one wizard living in the city and he is going to come. That isn't enough, so he needs to create one clone.
In the second sample 10 people should come to the demonstration. The city has 10 wizards. They will all come to the demonstration, so nobody has to create any clones. | #include <bits/stdc++.h>
using namespace std;
int main() {
double n, x, y, p, q, r;
int a;
cin >> n >> x >> y;
p = y / 100;
q = n * p;
r = q - x;
a = r;
if (r > a) {
cout << a + 1;
} else if (a < 0) {
cout << "0";
} else {
cout << a;
}
}
|
You are given an equation:
Ax2 + Bx + C = 0.
Your task is to find the number of distinct roots of the equation and print all of them in ascending order.
Input
The first line contains three integer numbers A, B and C ( - 105 ≤ A, B, C ≤ 105). Any coefficient may be equal to 0.
Output
In case of infinite root count print the only integer -1. In case of no roots print the only integer 0. In other cases print the number of root on the first line and the roots on the following lines in the ascending order. Print roots with at least 5 digits after the decimal point.
Examples
Input
1 -5 6
Output
2
2.0000000000
3.0000000000 | #include <bits/stdc++.h>
using namespace std;
int main() {
double A, B, C;
double D;
cin >> A >> B >> C;
double x1, x2;
if (!A) {
if (!B) {
if (!C) {
printf("-1");
return 0;
} else {
printf("0");
return 0;
}
} else {
printf("1\n");
printf("%lf", -C / B);
}
} else {
D = pow(B, 2) - (4 * A * C);
if (D < 0) {
printf("0");
return 0;
} else {
D = sqrt(D);
}
x1 = (-B + D) / (2 * A);
x2 = (-B - D) / (2 * A);
if (x1 == x2) {
cout << "1" << endl;
printf("%lf", x1);
} else {
(x1 > x2) ? printf("2\n%lf\n%lf", x2, x1) : printf("2\n%lf\n%lf", x1, x2);
}
}
}
|
In computer science, there is a method called "Divide And Conquer By Node" to solve some hard problems about paths on a tree. Let's desribe how this method works by function:
solve(t) (t is a tree):
1. Chose a node x (it's common to chose weight-center) in tree t. Let's call this step "Line A".
2. Deal with all paths that pass x.
3. Then delete x from tree t.
4. After that t becomes some subtrees.
5. Apply solve on each subtree.
This ends when t has only one node because after deleting it, there's nothing.
Now, WJMZBMR has mistakenly believed that it's ok to chose any node in "Line A". So he'll chose a node at random. To make the situation worse, he thinks a "tree" should have the same number of edges and nodes! So this procedure becomes like that.
Let's define the variable totalCost. Initially the value of totalCost equal to 0. So, solve(t) (now t is a graph):
1. totalCost = totalCost + (size of t). The operation "=" means assignment. (Size of t) means the number of nodes in t.
2. Choose a node x in graph t at random (uniformly among all nodes of t).
3. Then delete x from graph t.
4. After that t becomes some connected components.
5. Apply solve on each component.
He'll apply solve on a connected graph with n nodes and n edges. He thinks it will work quickly, but it's very slow. So he wants to know the expectation of totalCost of this procedure. Can you help him?
Input
The first line contains an integer n (3 ≤ n ≤ 3000) — the number of nodes and edges in the graph. Each of the next n lines contains two space-separated integers ai, bi (0 ≤ ai, bi ≤ n - 1) indicating an edge between nodes ai and bi.
Consider that the graph nodes are numbered from 0 to (n - 1). It's guaranteed that there are no self-loops, no multiple edges in that graph. It's guaranteed that the graph is connected.
Output
Print a single real number — the expectation of totalCost. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Examples
Input
5
3 4
2 3
2 4
0 4
1 2
Output
13.166666666666666
Input
3
0 1
1 2
0 2
Output
6.000000000000000
Input
5
0 1
1 2
2 0
3 0
4 1
Output
13.166666666666666
Note
Consider the second example. No matter what we choose first, the totalCost will always be 3 + 2 + 1 = 6. | #include <bits/stdc++.h>
struct edge {
int to;
edge* next;
} E[6010], *ne = E, *first[3010];
void link(int a, int b) {
*ne = (edge){b, first[a]};
first[a] = ne++;
}
int C[3010], cnt;
bool tag[3010];
int dfs1(int i, int f) {
int t;
tag[i] = 1;
for (edge* e = first[i]; e; e = e->next)
if (e->to != f) {
if (tag[e->to])
return C[cnt++] = i, e->to;
else if ((t = dfs1(e->to, i)) > -1)
return (C[cnt++] = i) == t ? -1 : t;
else if (t == -1)
return tag[i] = 0, -1;
}
tag[i] = 0;
return -2;
}
double dfs2(int i, int f, int d, int l, int r) {
double s = 1.0 / (d + l) + 1.0 / (d + r) - 1.0 / (d + l + r);
for (edge* e = first[i]; e; e = e->next)
e->to != f && (!tag[i] || !tag[e->to]) ? s += dfs2(e->to, i, d + 1, l, r)
: 1;
if (tag[i] && (f == -1 || !tag[f])) {
int k = 0;
while (C[k] != i) k++;
r = cnt - 2;
for (int j = (k + 1) % cnt; j != k; j = (j + 1) % cnt, l++, r--)
s += dfs2(C[j], i, d + 1, l, r);
}
return s;
}
int main() {
int n, a, b;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d", &a, &b), link(a, b), link(b, a);
dfs1(0, -1);
double ans = 0;
for (int i = 0; i < n; i++) ans += dfs2(i, -1, 1, 0, 0);
printf("%.12lf\n", ans);
}
|
A recently found Ancient Prophesy is believed to contain the exact Apocalypse date. The prophesy is a string that only consists of digits and characters "-".
We'll say that some date is mentioned in the Prophesy if there is a substring in the Prophesy that is the date's record in the format "dd-mm-yyyy". We'll say that the number of the date's occurrences is the number of such substrings in the Prophesy. For example, the Prophesy "0012-10-2012-10-2012" mentions date 12-10-2012 twice (first time as "0012-10-2012-10-2012", second time as "0012-10-2012-10-2012").
The date of the Apocalypse is such correct date that the number of times it is mentioned in the Prophesy is strictly larger than that of any other correct date.
A date is correct if the year lies in the range from 2013 to 2015, the month is from 1 to 12, and the number of the day is strictly more than a zero and doesn't exceed the number of days in the current month. Note that a date is written in the format "dd-mm-yyyy", that means that leading zeroes may be added to the numbers of the months or days if needed. In other words, date "1-1-2013" isn't recorded in the format "dd-mm-yyyy", and date "01-01-2013" is recorded in it.
Notice, that any year between 2013 and 2015 is not a leap year.
Input
The first line contains the Prophesy: a non-empty string that only consists of digits and characters "-". The length of the Prophesy doesn't exceed 105 characters.
Output
In a single line print the date of the Apocalypse. It is guaranteed that such date exists and is unique.
Examples
Input
777-444---21-12-2013-12-2013-12-2013---444-777
Output
13-12-2013 | #include <bits/stdc++.h>
using namespace std;
char s[100005];
int day[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
map<string, int> my;
void check(char* s) {
if (((s[0]) >= '0' && (s[0]) <= '9') && ((s[1]) >= '0' && (s[1]) <= '9') &&
((s[3]) >= '0' && (s[3]) <= '9') && ((s[4]) >= '0' && (s[4]) <= '9') &&
((s[6]) >= '0' && (s[6]) <= '9') && ((s[7]) >= '0' && (s[7]) <= '9') &&
((s[8]) >= '0' && (s[8]) <= '9') && ((s[9]) >= '0' && (s[9]) <= '9') &&
s[2] == '-' && s[5] == '-') {
int d = atoi(s);
int m = atoi(s + 3);
int y = atoi(string(s + 6, s + 10).c_str());
if (m <= 12 && d > 0 && d <= day[m - 1] && y >= 2013 && y <= 2015) {
++my[string(s, s + 10)];
}
}
}
int main() {
gets(s);
int n = strlen(s);
for (int i = 0; i + 10 <= n; ++i) check(s + i);
string res("");
int max = -1;
for (typeof((my).begin()) it = (my).begin(), _e = (my).end(); it != _e; ++it)
if (it->second > max) {
max = it->second;
res = it->first;
}
cout << res << endl;
return 0;
}
|
There are n cows playing poker at a table. For the current betting phase, each player's status is either "ALLIN", "IN", or "FOLDED", and does not change throughout the phase. To increase the suspense, a player whose current status is not "FOLDED" may show his/her hand to the table. However, so as not to affect any betting decisions, he/she may only do so if all other players have a status of either "ALLIN" or "FOLDED". The player's own status may be either "ALLIN" or "IN".
Find the number of cows that can currently show their hands without affecting any betting decisions.
Input
The first line contains a single integer, n (2 ≤ n ≤ 2·105). The second line contains n characters, each either "A", "I", or "F". The i-th character is "A" if the i-th player's status is "ALLIN", "I" if the i-th player's status is "IN", or "F" if the i-th player's status is "FOLDED".
Output
The first line should contain a single integer denoting the number of players that can currently show their hands.
Examples
Input
6
AFFAAA
Output
4
Input
3
AFI
Output
1
Note
In the first sample, cows 1, 4, 5, and 6 can show their hands. In the second sample, only cow 3 can show her hand. | #!/bin/python
# -*- coding: utf-8 -*-
n = int(input())
s = input()
print(int(s.count('I') == 1) if 'I' in s else s.count('A'))
|
Advertising has become part of our routine. And now, in the era of progressive technologies, we need your ideas to make advertising better!
In this problem we'll look at a simplified version of context advertising. You've got a text, consisting of exactly n words. A standard advertising banner has exactly r lines, each line can contain at most c characters. The potential customer always likes it when they can see lots of advertising, so you should determine which maximum number of consecutive words from the text can be written on the banner. Single words in one line of the banner should be separated by spaces. You are allowed to insert more than one space at once. Note that you are not allowed to break the words, that is, each word in the text must occupy exactly one line in the banner. Besides, you cannot change the word order, that is, if you read the banner text consecutively, from top to bottom and from left to right, you should get some consecutive part of the advertisement text.
More formally, the statement can be written like that. Let's say that all words are indexed from 1 to n in the order in which they occur in the advertisement text. Then you have to choose all words, starting from some i-th one and ending with some j-th one (1 ≤ i ≤ j ≤ n), so that all of them could be written on the banner. There must be as many words as possible. See the samples for clarifications.
Input
The first input line contains three integers n, r, c (1 ≤ n, r, c ≤ 106; r × c ≤ 106). The next line contains a text, consisting of n words. The words consist only of lowercase English letters and are not empty. The words in the lines are separated by single spaces. The total number of characters in all words doesn't exceed 5·106.
Output
Print at most r lines, in each line print at most c characters — the optimal advertisement banner. If there are multiple advertisement banners, print any of them.
Note that some lines of the banner can be empty. You are allowed not to print such lines.
Examples
Input
9 4 12
this is a sample text for croc final round
Output
this is a
sample text
for croc
final round
Input
9 1 9
this is a sample text for croc final round
Output
this is a
Input
6 2 3
croc a a a croc a
Output
a a
a
Input
2 2 5
first second
Output
first | #include <bits/stdc++.h>
using namespace std;
const int N = 1000100, L = 5000500, BufL = 220;
char ch[N + L] = {}, buf[BufL] = {};
int n, r, c, l, a[N] = {}, p[N] = {}, f[N] = {}, g[N] = {};
int main() {
gets(buf + 1);
sscanf(buf + 1, "%d%d%d", &n, &r, &c);
gets(ch + 1);
l = strlen(ch + 1);
for (int i = 1, tot = 0; i <= l; ++i)
if (isalpha(ch[i])) {
p[++tot] = i;
while (i <= l && isalpha(ch[i])) ++a[tot], ++i;
}
for (int i = 1; i <= n + 1; ++i) g[i] = i;
for (int i = 1, t = 0, s = -1; i <= n; s -= a[i++] + 1) {
while (t <= n && s <= c) s += a[++t] + 1;
f[i] = t;
}
f[n + 1] = n + 1;
for (; r; r >>= 1) {
if (r & 1)
for (int i = 1; i <= n; ++i) g[i] = f[g[i]];
for (int i = 1; i <= n; ++i) f[i] = f[f[i]];
}
int ans = 0;
for (int i = 1; i <= n; ++i)
if (g[i] - i > g[ans] - ans) ans = i;
for (int i = ans, s = c; i < g[ans]; ++i) {
if (s + a[i] + 1 <= c) {
s += a[i] + 1;
putchar(' ');
} else {
if (i > ans) puts("");
s = a[i];
}
for (int j = p[i]; j < p[i] + a[i]; ++j) putchar(ch[j]);
}
return 0;
}
|
Everybody knows that we have been living in the Matrix for a long time. And in the new seventh Matrix the world is ruled by beavers.
So let's take beaver Neo. Neo has so-called "deja vu" outbursts when he gets visions of events in some places he's been at or is going to be at. Let's examine the phenomenon in more detail.
We can say that Neo's city is represented by a directed graph, consisting of n shops and m streets that connect the shops. No two streets connect the same pair of shops (besides, there can't be one street from A to B and one street from B to A). No street connects a shop with itself. As Neo passes some streets, he gets visions. No matter how many times he passes street k, every time he will get the same visions in the same order. A vision is a sequence of shops.
We know that Neo is going to get really shocked if he passes the way from some shop a to some shop b, possible coinciding with a, such that the list of visited shops in the real life and in the visions coincide.
Suggest beaver Neo such path of non-zero length. Or maybe you can even count the number of such paths modulo 1000000007 (109 + 7)?..
Input
The first line contains integers n and m — the number of shops and the number of streets, correspondingly, 1 ≤ n ≤ 50, <image>. Next m lines contain the descriptions of the streets in the following format: xi yi ki v1 v2 ... vk, where xi and yi (1 ≤ xi, yi ≤ n, xi ≠ yi) are numbers of shops connected by a street, ki (0 ≤ ki ≤ n) is the number of visions on the way from xi to yi; v1, v2, ..., vk (1 ≤ vi ≤ n) describe the visions: the numbers of the shops Neo saw. Note that the order of the visions matters.
It is guaranteed that the total number of visions on all streets doesn't exceed 105.
* to get 50 points, you need to find any (not necessarily simple) path of length at most 2·n, that meets the attributes described above (subproblem E1);
* to get 50 more points, you need to count for each length from 1 to 2·n the number of paths that have the attribute described above (subproblem E2).
Output
Subproblem E1. In the first line print an integer k (1 ≤ k ≤ 2·n) — the numbers of shops on Neo's path. In the next line print k integers — the number of shops in the order Neo passes them. If the graph doesn't have such paths or the length of the shortest path includes more than 2·n shops, print on a single line 0.
Subproblem E2. Print 2·n lines. The i-th line must contain a single integer — the number of required paths of length i modulo 1000000007 (109 + 7).
Examples
Input
6 6
1 2 2 1 2
2 3 1 3
3 4 2 4 5
4 5 0
5 3 1 3
6 1 1 6
Output
4
6 1 2 3
Input
6 6
1 2 2 1 2
2 3 1 3
3 4 2 4 5
4 5 0
5 3 1 3
6 1 1 6
Output
1
2
1
1
2
1
1
2
1
1
2
1
Note
The input in both samples are the same. The first sample contains the answer to the first subproblem, the second sample contains the answer to the second subproblem. | #include <bits/stdc++.h>
using namespace std;
const int MAX = 100 + 10;
const int Mod = (int)1e9 + 7;
int n, m;
int g[MAX][MAX], can[MAX][MAX];
vector<int> p[MAX][MAX];
int get(vector<int> &before, int kind, int could, int have) {
int j;
int now = 0, cc = have;
for (; now < (int)before.size(); now++) {
if (now + 1 == (int)before.size()) break;
int a = before[now];
int b = before[now + 1];
if (g[a][b] != kind || (!could && can[a][b])) return 0;
vector<int> &nL = p[a][b];
for ((j) = (0); (j) != ((int)nL.size()); ++(j)) {
if (cc < (int)before.size()) {
if (nL[j] == before[cc])
cc++;
else
return 0;
} else {
while (j < (int)nL.size()) {
before.push_back(nL[j++]);
if ((int)before.size() > 2 * n + 1) return 0;
}
cc = before.size();
break;
}
}
}
return cc == (int)before.size();
}
int isCan(int a, int b) {
int i;
vector<int> &L = p[a][b];
int len = L.size();
for ((i) = (0); (i) <= (len - 2); ++(i))
if (L[i] == a && L[i + 1] == b) return 1;
return 0;
}
int f_Before[MAX][MAX][MAX], f_After[MAX][MAX][MAX], tmp[MAX][MAX][MAX];
int Before[MAX][MAX], After[MAX][MAX];
int ans[MAX];
void work(int u, int kind, int f[MAX][MAX][MAX]) {
int v;
for ((v) = (1); (v) <= (n); ++(v))
if (g[u][v] == kind && !can[v][u]) {
vector<int> after;
after.push_back(u);
after.push_back(v);
if (!get(after, kind, kind != 2, 1)) continue;
int Len = after.size();
f[u][after[Len - 1]][Len - 1]++;
}
}
void add(int &a, int b) {
a += b;
if (a >= Mod) a -= Mod;
}
void work2(int a, int b) {
int i, j;
vector<int> &L = p[a][b];
int len = L.size();
for ((i) = (0); (i) <= (len - 2); ++(i))
if (L[i] == a && L[i + 1] == b) {
vector<int> before, after;
for (j = i; j >= 0; --j) before.push_back(L[j]);
for (j = i + 1; j < len; ++j) after.push_back(L[j]);
if (get(before, 2, 0, before.size()) && get(after, 1, 1, after.size())) {
reverse(before.begin(), before.end());
int A = before[0];
int B = after[after.size() - 1];
int Len = before.size() + after.size() - 1;
int k, l, o;
for ((l) = (1); (l) <= (n); ++(l))
for ((o) = (0); (o) <= (2 * n); ++(o))
if (tmp[A][l][o])
for ((k) = (1); (k) <= (n); ++(k))
if (g[k][l] == 1 && p[k][l].size() == 0 && Len + 1 + o <= 2 * n)
add(f_After[k][B][Len + 1 + o], tmp[A][l][o]);
} else
return;
}
return;
}
int tot = 0, First;
void Dp1(int f[MAX][MAX][MAX], int after[MAX][MAX]) {
int i, j, k, l, o;
memset(tmp, 0, sizeof tmp);
for ((i) = (1); (i) <= (n); ++(i)) tmp[i][i][0] = 1;
int up = 2 * n;
for ((l) = (1); (l) <= (up); ++(l))
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
for ((o) = (0); (o) <= (l); ++(o))
if (f[i][j][o])
for ((k) = (1); (k) <= (n); ++(k))
if (tmp[j][k][l - o])
add(tmp[i][k][l],
(long long)f[i][j][o] * tmp[j][k][l - o] % Mod);
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
for ((l) = (0); (l) <= (2 * n); ++(l)) add(after[i][l], tmp[i][j][l]);
}
void Dp2(int f[MAX][MAX][MAX], int after[MAX][MAX]) {
int i, j, k, l;
for ((i) = (1); (i) <= (n); ++(i)) after[i][0] = 1;
int up = 2 * n;
for ((l) = (1); (l) <= (up); ++(l))
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
for ((k) = (0); (k) != (l); ++(k))
add(After[i][l], (long long)f[i][j][l - k] * After[j][k] % Mod);
}
void check(int a, int b) {
int i, j;
vector<int> &L = p[a][b];
int len = L.size();
for ((i) = (0); (i) <= (len - 2); ++(i))
if (L[i] == a && L[i + 1] == b) {
vector<int> before, after;
for (j = i; j >= 0; --j) before.push_back(L[j]);
for (j = i + 1; j < len; ++j) after.push_back(L[j]);
if (get(before, 2, 0, before.size()) && get(after, 1, 1, after.size())) {
reverse(before.begin(), before.end());
int A = before[0];
int B = after[after.size() - 1];
int Len = before.size() + after.size() - 1;
int l1, l2;
for ((l1) = (0); (l1) <= (2 * n); ++(l1))
for ((l2) = (0); (l2) <= (2 * n); ++(l2))
if (l1 + l2 + Len <= 2 * n)
add(ans[l1 + l2 + Len],
(long long)Before[A][l1] * After[B][l2] % Mod);
} else
return;
}
return;
}
int main() {
int i, j;
scanf("%d%d", &n, &m);
for ((i) = (1); (i) <= (m); ++(i)) {
int a, b;
scanf("%d%d", &a, &b);
if (!First) First = a;
g[a][b] = 1;
g[b][a] = 2;
int k, first;
scanf("%d", &k);
while (k--) {
scanf("%d", &first);
p[a][b].push_back(first);
}
p[b][a] = p[a][b];
reverse(p[b][a].begin(), p[b][a].end());
}
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
if (g[i][j] == 1 && isCan(i, j)) can[j][i] = can[i][j] = 1;
for ((i) = (1); (i) <= (n); ++(i)) work(i, 1, f_After);
for ((i) = (1); (i) <= (n); ++(i)) work(i, 2, f_Before);
Dp1(f_Before, Before);
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
if (g[i][j] == 1 && can[i][j] == 1) work2(i, j);
Dp2(f_After, After);
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
if (g[i][j] == 1 && can[i][j] == 1) check(i, j);
for ((i) = (1); (i) <= (2 * n); ++(i)) cout << ans[i] << endl;
return 0;
}
|
We know that lucky digits are digits 4 and 7, however Vasya's got another favorite digit 0 and he assumes it also is lucky! Lucky numbers are such non-negative integers whose decimal record only contains lucky digits. For example, numbers 0, 47, 7074 are lucky, but 1, 7377, 895, -7 are not.
Vasya has t important positive integers he needs to remember. Vasya is quite superstitious and he wants to remember lucky numbers only, so he is asking you for each important number to represent it as a sum of exactly six lucky numbers (Vasya just can't remember more numbers). Then Vasya can just remember these six numbers and calculate the important number at any moment.
For each of t important integers represent it as the sum of six lucky numbers or state that this is impossible.
Input
The first line contains a single integer t (1 ≤ t ≤ 5000).
Next t lines contain a single positive integer ni (1 ≤ ni ≤ 1018) — the list of important numbers.
Please, do not use the %lld to read or write 64-bit integers С++. It is preferred to read the cin, cout streams or the %I64d specifier.
Output
Print t lines. The i-th line must contain the answer for the i-th important number: if the solution exists, the line must contain exactly six lucky numbers the sum of which equals ni, if the solution doesn't exist the string must contain a single integer -1.
If there are multiple answers print any of them.
Examples
Input
5
42
17
444
7
51
Output
7 7 7 7 7 7
-1
400 0 40 0 4 0
7 0 0 0 0 0
47 4 0 0 0 0 | #include <bits/stdc++.h>
using namespace std;
set<long long> kharab = {1, 2, 3, 5, 6, 9, 10, 13, 17, 31, 34,
37, 38, 41, 43, 45, 46, 49, 50, 53, 57, 71,
83, 111, 123, 391, 403, 437, 457, 471, 483, 511, 523};
long long a[6];
vector<long long> D[43];
void f(long long n) {
if (kharab.find(n) != kharab.end()) {
fill(a, a + 6, -1);
return;
}
if (n < 8) {
a[0] = n;
return;
}
for (long long i = 0; i <= 42; i++) {
if ((!D[i].size() || ~D[i].back()) && i % 10 == n % 10 &&
kharab.find((n - i) / 10) == kharab.end()) {
f((n - i) / 10);
for (long long j = 0; j < 6; j++) a[j] *= 10;
for (long long j = 0; j < D[i].size(); j++) a[j] += D[i][j];
return;
}
}
}
int32_t main() {
long long t;
cin >> t;
D[4].push_back(4);
D[7].push_back(7);
for (long long i = 1; i <= 42; i++) {
if (i == 4 || i == 7) continue;
if (kharab.find(i) != kharab.end() || i == 40) {
D[i].push_back(-1);
continue;
}
if (D[i - 4].size() < 6 && (!D[i - 4].size() || ~D[i - 4].back())) {
D[i] = D[i - 4];
D[i].push_back(4);
} else {
D[i] = D[i - 7];
D[i].push_back(7);
}
}
while (t--) {
long long n;
cin >> n;
fill(a, a + 6, 0);
f(n);
if (~a[0])
for (long long i = 0; i < 6; i++) cout << a[i] << ' ';
else
cout << -1;
cout << '\n';
}
}
|
Vasily the Programmer loves romance, so this year he decided to illuminate his room with candles.
Vasily has a candles.When Vasily lights up a new candle, it first burns for an hour and then it goes out. Vasily is smart, so he can make b went out candles into a new candle. As a result, this new candle can be used like any other new candle.
Now Vasily wonders: for how many hours can his candles light up the room if he acts optimally well? Help him find this number.
Input
The single line contains two integers, a and b (1 ≤ a ≤ 1000; 2 ≤ b ≤ 1000).
Output
Print a single integer — the number of hours Vasily can light up the room for.
Examples
Input
4 2
Output
7
Input
6 3
Output
8
Note
Consider the first sample. For the first four hours Vasily lights up new candles, then he uses four burned out candles to make two new ones and lights them up. When these candles go out (stop burning), Vasily can make another candle. Overall, Vasily can light up the room for 7 hours. | a, b = map(int, input().split())
c, s = a, 0
while a >= b:
s += a // b
a = (a // b) + (a % b)
print(s + c)
|
Petya studies positional notations. He has already learned to add and subtract numbers in the systems of notations with different radices and has moved on to a more complicated action — multiplication. To multiply large numbers one has to learn the multiplication table. Unfortunately, in the second grade students learn only the multiplication table of decimals (and some students even learn it in the first grade). Help Petya make a multiplication table for numbers in the system of notations with the radix k.
Input
The first line contains a single integer k (2 ≤ k ≤ 10) — the radix of the system.
Output
Output the multiplication table for the system of notations with the radix k. The table must contain k - 1 rows and k - 1 columns. The element on the crossing of the i-th row and the j-th column is equal to the product of i and j in the system of notations with the radix k. Each line may have any number of spaces between the numbers (the extra spaces in the samples are put for clarity).
Examples
Input
10
Output
1 2 3 4 5 6 7 8 9
2 4 6 8 10 12 14 16 18
3 6 9 12 15 18 21 24 27
4 8 12 16 20 24 28 32 36
5 10 15 20 25 30 35 40 45
6 12 18 24 30 36 42 48 54
7 14 21 28 35 42 49 56 63
8 16 24 32 40 48 56 64 72
9 18 27 36 45 54 63 72 81
Input
3
Output
1 2
2 11 | #include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int inline in() {
int x = 0, c;
for (; (unsigned)((c = getchar()) - '0') >= 10;) {
if (c == '-') return -in();
if (!~c) throw ~0;
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned)((c = getchar()) - '0') < 10);
return x;
}
int k;
int main() {
cin >> k;
for (int i = 0; i < (k - 1); i++) {
for (int j = 0; j < (k - 1); j++) {
int pro = (i + 1) * (j + 1);
if (pro >= k) {
int tmp = pro / k;
pro %= k;
pro += tmp * 10;
}
cout << pro << ' ';
}
cout << endl;
}
return 0;
}
|
Sereja has painted n distinct points on the plane. The coordinates of each point are integers. Now he is wondering: how many squares are there with sides parallel to the coordinate axes and with points painted in all its four vertexes? Help him, calculate this number.
Input
The first line contains integer n (1 ≤ n ≤ 105). Each of the next n lines contains two integers xi, yi (0 ≤ xi, yi ≤ 105), the integers represent the coordinates of the i-th point. It is guaranteed that all the given points are distinct.
Output
In a single line print the required number of squares.
Examples
Input
5
0 0
0 2
2 0
2 2
1 1
Output
1
Input
9
0 0
1 1
2 2
0 1
1 0
0 2
2 0
1 2
2 1
Output
5 | #include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-12;
const int maxn = 100000 + 1912;
const int MX = 1e6;
int n;
pair<int, int> a[maxn];
vector<int> p[MX * 2 + 3];
long long res = 0;
void ReadData() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].first, &a[i].second);
a[i].first += MX;
a[i].second += MX;
p[a[i].first].push_back(a[i].second);
}
for (int i = 0; i <= MX * 2; i++)
if (((int)p[i].size())) sort(p[i].begin(), p[i].end());
}
bool Found(int x, int y) {
if (x < 0 || x > MX * 2) return false;
vector<int>::iterator it = lower_bound(p[x].begin(), p[x].end(), y);
if (it != p[x].end() && (*it) == y) return true;
return false;
}
void Process() {
for (int i = 0; i <= MX * 2; i++)
if (((int)p[i].size())) {
if (((int)p[i].size()) <= 520) {
for (int fi = 0; fi < ((int)p[i].size()); fi++)
for (int se = 0; se < fi; se++) {
int len = p[i][fi] - p[i][se];
if (i >= len && Found(i - len, p[i][se]) &&
Found(i - len, p[i][fi]))
res++;
}
} else {
for (int j = 0; j <= i - 1; j++) {
int len = i - j;
for (int k = 0; k < ((int)p[j].size()); k++) {
if (Found(i, p[j][k]) && Found(j, p[j][k] + len) &&
Found(i, p[j][k] + len))
res++;
}
}
}
}
cout << res << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ReadData();
Process();
}
|
To celebrate the opening of the Winter Computer School the organizers decided to buy in n liters of cola. However, an unexpected difficulty occurred in the shop: it turned out that cola is sold in bottles 0.5, 1 and 2 liters in volume. At that, there are exactly a bottles 0.5 in volume, b one-liter bottles and c of two-liter ones. The organizers have enough money to buy any amount of cola. What did cause the heated arguments was how many bottles of every kind to buy, as this question is pivotal for the distribution of cola among the participants (and organizers as well).
Thus, while the organizers are having the argument, discussing different variants of buying cola, the Winter School can't start. Your task is to count the number of all the possible ways to buy exactly n liters of cola and persuade the organizers that this number is too large, and if they keep on arguing, then the Winter Computer School will have to be organized in summer.
All the bottles of cola are considered indistinguishable, i.e. two variants of buying are different from each other only if they differ in the number of bottles of at least one kind.
Input
The first line contains four integers — n, a, b, c (1 ≤ n ≤ 10000, 0 ≤ a, b, c ≤ 5000).
Output
Print the unique number — the solution to the problem. If it is impossible to buy exactly n liters of cola, print 0.
Examples
Input
10 5 5 5
Output
9
Input
3 0 0 2
Output
0 | import org.omg.PortableInterceptor.SYSTEM_EXCEPTION;
import java.io.*;
import java.util.*;
import java.util.regex.Matcher;
public class Main {
public static void main(String[] args) throws IOException {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = /*new InputReader(new FileReader("input.txt"));*/ new InputReader(inputStream);
PrintWriter out = /*new PrintWriter("output.txt"); */ new PrintWriter(outputStream);
TaskB solver = new TaskB();
solver.solve(in, out);
out.close();
}
private static class TaskB {
static final long max = 1000000000000000000L;
static final double eps = 0.000000001;
static final long mod = 1000000007;
void solve(InputReader in, PrintWriter out) throws IOException {
int N = in.nextInt();
int A = in.nextInt();
int B = in.nextInt();
int C = in.nextInt();
int count = 0;
for (int i = 0; i <= B; i++)
for (int j = 0; j <= C; j++) {
int sum = i + j * 2;
if (sum == N) {
count++;
} else if (sum < N) {
int rem = N - sum;
if (rem * 2 <= A) count++;
}
}
out.println(count);
}
}
private static class InputReader {
StringTokenizer st;
BufferedReader br;
public InputReader(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public InputReader(FileReader s) throws FileNotFoundException {
br = new BufferedReader(s);
}
public String next() {
while (st == null || !st.hasMoreTokens())
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public String nextLine() {
try {
return br.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public double nextDouble() {
return Double.parseDouble(next());
}
public boolean ready() {
try {
return br.ready();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
} |
Ali is Hamed's little brother and tomorrow is his birthday. Hamed wants his brother to earn his gift so he gave him a hard programming problem and told him if he can successfully solve it, he'll get him a brand new laptop. Ali is not yet a very talented programmer like Hamed and although he usually doesn't cheat but this time is an exception. It's about a brand new laptop. So he decided to secretly seek help from you. Please solve this problem for Ali.
An n-vertex weighted rooted tree is given. Vertex number 1 is a root of the tree. We define d(u, v) as the sum of edges weights on the shortest path between vertices u and v. Specifically we define d(u, u) = 0. Also let's define S(v) for each vertex v as a set containing all vertices u such that d(1, u) = d(1, v) + d(v, u). Function f(u, v) is then defined using the following formula:
<image>
The goal is to calculate f(u, v) for each of the q given pair of vertices. As the answer can be rather large it's enough to print it modulo 109 + 7.
Input
In the first line of input an integer n (1 ≤ n ≤ 105), number of vertices of the tree is given.
In each of the next n - 1 lines three space-separated integers ai, bi, ci (1 ≤ ai, bi ≤ n, 1 ≤ ci ≤ 109) are given indicating an edge between ai and bi with weight equal to ci.
In the next line an integer q (1 ≤ q ≤ 105), number of vertex pairs, is given.
In each of the next q lines two space-separated integers ui, vi (1 ≤ ui, vi ≤ n) are given meaning that you must calculate f(ui, vi).
It is guaranteed that the given edges form a tree.
Output
Output q lines. In the i-th line print the value of f(ui, vi) modulo 109 + 7.
Examples
Input
5
1 2 1
4 3 1
3 5 1
1 3 1
5
1 1
1 5
2 4
2 1
3 5
Output
10
1000000005
1000000002
23
1000000002
Input
8
1 2 100
1 3 20
2 4 2
2 5 1
3 6 1
3 7 2
6 8 5
6
1 8
2 3
5 8
2 6
4 7
6 1
Output
999968753
49796
999961271
999991235
999958569
45130 | #include <bits/stdc++.h>
using namespace std;
inline int read() {
static int r, sign;
static char c;
r = 0, sign = 1;
do c = getchar();
while (c != '-' && (c < '0' || c > '9'));
if (c == '-') sign = -1, c = getchar();
while (c >= '0' && c <= '9') r = r * 10 + (int)(c - '0'), c = getchar();
return sign * r;
}
template <typename T>
inline void print(T *a, int n) {
for (int i = 1; i < n; ++i) cout << a[i] << " ";
cout << a[n] << endl;
}
const int mod = (int)1e9 + 7;
struct hashInt {
int x;
hashInt() {}
hashInt(int _x) : x(_x) {}
inline hashInt operator+(const hashInt &y) const {
int z = x + y.x;
if (z >= mod) z -= mod;
if (z < 0) z += mod;
return hashInt(z);
}
inline hashInt operator-(const hashInt &y) const {
int z = x - y.x;
if (z >= mod) z -= mod;
if (z < 0) z += mod;
return hashInt(z);
}
inline hashInt operator*(const hashInt &y) const {
return hashInt((long long)x * y.x % mod);
}
};
struct edge {
int next, node;
hashInt w;
} e[100100 << 1 | 1];
int head[100100 + 1], tot = 0;
inline void addedge(int a, int b, int w) {
e[++tot].next = head[a];
head[a] = tot, e[tot].node = b, e[tot].w = w;
}
struct DP {
hashInt sum, sqr;
DP() {}
DP(int _s, int _q) : sum(_s), sqr(_q) {}
DP(hashInt _s, hashInt _q) : sum(_s), sqr(_q) {}
} up[100100 + 1], down[100100 + 1], downex[100100 + 1];
int n, size[100100 + 1];
inline hashInt delta(const DP &x, int n, hashInt b) {
return x.sqr + b * b * n + b * 2 * x.sum;
}
void preUp(int x, int f) {
size[x] = 1, up[x].sum = up[x].sqr = 0;
for (int i = head[x]; i; i = e[i].next) {
int node = e[i].node;
if (node == f) continue;
preUp(node, x);
size[x] += size[node];
up[x].sum = up[x].sum + up[node].sum + e[i].w * size[node];
up[x].sqr = up[x].sqr + delta(up[node], size[node], e[i].w);
}
}
void preDown(int x, int f) {
for (int i = head[x]; i; i = e[i].next) {
int node = e[i].node;
if (node == f) continue;
DP cur;
cur.sum = down[x].sum + up[x].sum - up[node].sum - e[i].w * size[node];
cur.sqr = down[x].sqr + up[x].sqr - delta(up[node], size[node], e[i].w);
downex[node] = cur;
down[node].sum = cur.sum + e[i].w * (n - size[node]);
down[node].sqr = delta(cur, n - size[node], e[i].w);
preDown(node, x);
}
}
int p[18 + 1][100100 + 1], logn, dep[100100 + 1];
hashInt dis[100100 + 1], dissum[100100 + 1], dissqr[100100 + 1];
void preDA(int x, int f) {
p[0][x] = f;
for (int i = head[x]; i; i = e[i].next) {
int node = e[i].node;
if (node == f) continue;
dep[node] = dep[x] + 1;
dis[node] = dis[x] + e[i].w;
dissum[node] = dissum[x] + dis[node];
dissqr[node] = dissqr[x] + dis[node] * dis[node];
preDA(node, x);
}
}
inline int LCA(int x, int y) {
if (dep[x] > dep[y]) swap(x, y);
for (int i = logn; i >= 0; --i)
if (dep[x] <= dep[p[i][y]]) y = p[i][y];
if (x == y) return x;
for (int i = logn; i >= 0; --i)
if (p[i][x] != p[i][y]) x = p[i][x], y = p[i][y];
return p[0][x];
}
inline int LCA2(int x, int y) {
for (int i = logn; i >= 0; --i)
if (dep[x] < dep[p[i][y]]) y = p[i][y];
return y;
}
vector<pair<int, int> > Q[100100 + 1];
int q, ans[100100 + 1], seq[100100 + 1], cnt = 0;
DP pre[100100 + 1], suf[100100 + 1];
struct BIT {
hashInt a[100100 + 1];
inline void modify(int x, hashInt w) {
for (; x <= n; x += x & -x) a[x] = a[x] + w;
}
inline hashInt query(int x) {
hashInt r = 0;
for (; x > 0; x -= x & -x) r = r + a[x];
return r;
}
} sufsum, sufsqr;
void dfs(int x, int f) {
for (int i = 0; i < Q[x].size(); ++i) {
int node = Q[x][i].first, id = Q[x][i].second;
int p = LCA(x, node);
hashInt b = dis[node] - dis[p];
b = b * b;
}
for (int i = head[x]; i; i = e[i].next) {
int node = e[i].node;
if (node == f) continue;
seq[++cnt] = x;
pre[cnt].sum = pre[cnt - 1].sum + e[i].w * (cnt - 1);
pre[cnt].sqr = delta(pre[cnt - 1], cnt - 1, e[i].w);
dfs(node, x);
--cnt;
}
}
int main(int argc, char *argv[]) {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int x, y, w;
scanf("%d%d%d", &x, &y, &w);
addedge(x, y, w), addedge(y, x, w);
}
preUp(1, 0);
preDown(1, 0);
dep[1] = 1, preDA(1, 0);
logn = (int)(log((double)n) / log(2.0));
for (int i = 1; i <= logn; ++i)
for (int j = 1; j <= n; ++j) p[i][j] = p[i - 1][p[i - 1][j]];
scanf("%d", &q);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int p = LCA(x, y);
hashInt d = dis[x] + dis[y] - dis[p] * 2;
hashInt ans = 0;
if (p == y) {
ans = delta(down[y], n - size[y], d);
ans = up[x].sqr + down[x].sqr - ans * 2;
} else {
ans = delta(up[y], size[y], d);
ans = ans * 2 - up[x].sqr - down[x].sqr;
}
printf("%d\n", ans.x);
}
fclose(stdin);
fclose(stdout);
return 0;
}
|
A and B are preparing themselves for programming contests.
B loves to debug his code. But before he runs the solution and starts debugging, he has to first compile the code.
Initially, the compiler displayed n compilation errors, each of them is represented as a positive integer. After some effort, B managed to fix some mistake and then another one mistake.
However, despite the fact that B is sure that he corrected the two errors, he can not understand exactly what compilation errors disappeared — the compiler of the language which B uses shows errors in the new order every time! B is sure that unlike many other programming languages, compilation errors for his programming language do not depend on each other, that is, if you correct one error, the set of other error does not change.
Can you help B find out exactly what two errors he corrected?
Input
The first line of the input contains integer n (3 ≤ n ≤ 105) — the initial number of compilation errors.
The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the errors the compiler displayed for the first time.
The third line contains n - 1 space-separated integers b1, b2, ..., bn - 1 — the errors displayed at the second compilation. It is guaranteed that the sequence in the third line contains all numbers of the second string except for exactly one.
The fourth line contains n - 2 space-separated integers с1, с2, ..., сn - 2 — the errors displayed at the third compilation. It is guaranteed that the sequence in the fourth line contains all numbers of the third line except for exactly one.
Output
Print two numbers on a single line: the numbers of the compilation errors that disappeared after B made the first and the second correction, respectively.
Examples
Input
5
1 5 8 123 7
123 7 5 1
5 1 7
Output
8
123
Input
6
1 4 3 3 5 7
3 7 5 4 3
4 3 7 5
Output
1
3
Note
In the first test sample B first corrects the error number 8, then the error number 123.
In the second test sample B first corrects the error number 1, then the error number 3. Note that if there are multiple errors with the same number, B can correct only one of them in one step. | n = int(input())
a_sum = sum(map(int, input().split()))
b_sum = sum(map(int, input().split()))
c_sum = sum(map(int, input().split()))
print(a_sum - b_sum)
print(b_sum - c_sum) |
Little Susie listens to fairy tales before bed every day. Today's fairy tale was about wood cutters and the little girl immediately started imagining the choppers cutting wood. She imagined the situation that is described below.
There are n trees located along the road at points with coordinates x1, x2, ..., xn. Each tree has its height hi. Woodcutters can cut down a tree and fell it to the left or to the right. After that it occupies one of the segments [xi - hi, xi] or [xi;xi + hi]. The tree that is not cut down occupies a single point with coordinate xi. Woodcutters can fell a tree if the segment to be occupied by the fallen tree doesn't contain any occupied point. The woodcutters want to process as many trees as possible, so Susie wonders, what is the maximum number of trees to fell.
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of trees.
Next n lines contain pairs of integers xi, hi (1 ≤ xi, hi ≤ 109) — the coordinate and the height of the і-th tree.
The pairs are given in the order of ascending xi. No two trees are located at the point with the same coordinate.
Output
Print a single number — the maximum number of trees that you can cut down by the given rules.
Examples
Input
5
1 2
2 1
5 10
10 9
19 1
Output
3
Input
5
1 2
2 1
5 10
10 9
20 1
Output
4
Note
In the first sample you can fell the trees like that:
* fell the 1-st tree to the left — now it occupies segment [ - 1;1]
* fell the 2-nd tree to the right — now it occupies segment [2;3]
* leave the 3-rd tree — it occupies point 5
* leave the 4-th tree — it occupies point 10
* fell the 5-th tree to the right — now it occupies segment [19;20]
In the second sample you can also fell 4-th tree to the right, after that it will occupy segment [10;19]. | ll=lambda:map(int,input().split())
t=lambda:int(input())
ss=lambda:input()
#from math import log10 ,log2,ceil,factorial as f,gcd
#from itertools import combinations_with_replacement as cs
#from functools import reduce
#from bisect import bisect_right as br
#from collections import Counter
n=t()
x,h=[],[]
for _ in range(n):
a,b=ll()
x.append(a)
h.append(b)
if n>=2:
c=2
tx=x[0]
for i in range(1,n-1):
if x[i]-tx>h[i]:
tx=x[i]
c+=1
elif x[i+1]-x[i]>h[i]:
tx=x[i]+h[i]
c+=1
else:
tx=x[i]
print(c)
else:
print(1) |
Geometric progression with the first element a and common ratio b is a sequence of numbers a, ab, ab2, ab3, ....
You are given n integer geometric progressions. Your task is to find the smallest integer x, that is the element of all the given progressions, or else state that such integer does not exist.
Input
The first line contains integer (1 ≤ n ≤ 100) — the number of geometric progressions.
Next n lines contain pairs of integers a, b (1 ≤ a, b ≤ 109), that are the first element and the common ratio of the corresponding geometric progression.
Output
If the intersection of all progressions is empty, then print - 1, otherwise print the remainder of the minimal positive integer number belonging to all progressions modulo 1000000007 (109 + 7).
Examples
Input
2
2 2
4 1
Output
4
Input
2
2 2
3 3
Output
-1
Note
In the second sample test one of the progressions contains only powers of two, the other one contains only powers of three. | #include <bits/stdc++.h>
using std::sort;
using std::swap;
using std::unique;
namespace fastIO {
static char buf[(1 << 19)], *p1 = buf + (1 << 19), *pend = buf + (1 << 19);
inline char nc() {
if (p1 == pend) {
p1 = buf;
pend = buf + fread(buf, 1, (1 << 19), stdin);
}
return *p1++;
}
inline long long read() {
long long x = 0, f = 1;
register char s = nc();
for (; !isdigit(s); s = nc())
if (s == '-') f = -1;
for (; isdigit(s); s = nc()) x = (x << 1) + (x << 3) + s - '0';
return x * f;
}
} // namespace fastIO
using namespace fastIO;
inline long long mabs(long long x) { return x > 0 ? x : -x; }
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
struct IT {
long long p;
long long k;
IT(long long p = 0, long long k = 0) : p(p), k(k) {}
};
struct rec {
IT p[1001];
long long num;
void init(long long x) {
for (long long i = 2; i * i <= x; ++i) {
if (x % i == 0) {
long long c = 0;
while (x % i == 0) x /= i, c++;
p[num++] = IT(i, c);
}
}
if (x > 1) p[num++] = IT(x, 1);
}
IT query(long long x) {
for (long long i = 0; i < num; ++i)
if (p[i].p == x) return p[i];
return IT(x, 0);
}
} A[200], B[200];
long long n;
IT A1[3507], B1[3507], A2[3507], B2[3507];
long long pri[3507], num;
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
long long g = exgcd(b, a % b, y, x);
y -= a / b * x;
return g;
}
void inter(long long A, long long B, long long C, long long a, long long b,
long long c, long long &x1, long long &x2) {
while (a) {
long long t = A / a;
A -= t * a, B -= t * b, C -= t * c;
swap(A, a);
swap(B, b);
swap(C, c);
}
if (c % b) puts("-1"), exit(0);
x2 = -c / b;
if ((C + B * x2) % A) puts("-1"), exit(0);
x1 = (-C - B * x2) / A;
}
inline void UN(rec &a1, rec &b1, rec &a2, rec &b2) {
num = 0;
for (long long i = 0; i < a1.num; ++i) pri[num++] = a1.p[i].p;
for (long long i = 0; i < a2.num; ++i) pri[num++] = a2.p[i].p;
for (long long i = 0; i < b1.num; ++i) pri[num++] = b1.p[i].p;
for (long long i = 0; i < b2.num; ++i) pri[num++] = b2.p[i].p;
sort(pri, pri + num);
num = unique(pri, pri + num) - pri;
for (long long i = 0; i < num; ++i) A1[i] = a1.query(pri[i]);
for (long long i = 0; i < num; ++i) A2[i] = a2.query(pri[i]);
for (long long i = 0; i < num; ++i) B1[i] = b1.query(pri[i]);
for (long long i = 0; i < num; ++i) B2[i] = b2.query(pri[i]);
long long A = 0, B = 0, C = 0;
long long flg1 = 0;
long long x1, x2;
for (long long i = 0; i < num; ++i) {
long long a = B1[i].k, b = -B2[i].k, c = A1[i].k - A2[i].k;
if (a == 0 && b == 0) {
if (c) puts("-1"), exit(0);
continue;
}
long long g = gcd(a, gcd(-b, mabs(c)));
a /= g, b /= g, c /= g;
if (!b) {
if (c % a) puts("-1"), exit(0);
if (-c / a < 0) puts("-1"), exit(0);
}
if (!A && !B) {
A = a, B = b, C = c;
continue;
}
if (!B) {
if (b) {
inter(A, B, C, a, b, c, x1, x2);
flg1 = 1;
break;
}
if (C / A != c / a) puts("-1"), exit(0);
continue;
}
if (A * b == a * B) {
if (c * A == C * a) continue;
puts("-1"), exit(0);
}
inter(A, B, C, a, b, c, x1, x2), flg1 = 1;
break;
}
if (flg1) {
for (long long i = 0; i < num; ++i) {
long long a = B1[i].k, b = -B2[i].k, c = A1[i].k - A2[i].k;
if (a * x1 + b * x2 + c) puts("-1"), exit(0);
}
for (long long i = 0; i < num; ++i) {
A1[i].k = A1[i].k + B1[i].k * x1;
B1[i].k = 0;
}
for (long long i = 0; i < num; ++i) {
a1.p[i] = A1[i], b1.p[i] = B1[i];
}
a1.num = b1.num = num;
return;
}
long long g = exgcd(A, B, x1, x2);
if (C % g) puts("-1"), exit(0);
x1 *= -C / g, x2 *= -C / g;
long long tx = mabs(-B / g), ty = mabs(A / g);
if (C > 0 || !ty) {
x1 = (x1 % tx + tx) % tx;
if (B)
x2 = -(A * x1 + C) / B;
else
x2 = 0;
} else {
x2 = (x2 % ty + ty) % ty;
if (A)
x1 = (-B * x2 - C) / A;
else
x1 = 0;
}
for (long long i = 0; i < num; ++i) {
A1[i].k = A1[i].k + B1[i].k * x1;
B1[i].k = tx * B1[i].k;
}
for (long long i = 0; i < num; ++i) {
a1.p[i] = A1[i], b1.p[i] = B1[i];
}
a1.num = b1.num = num;
}
const long long P = 1e9 + 7;
inline long long ksm(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) ans = ans * x % P;
x = x * x % P;
y >>= 1;
}
return ans;
}
signed main() {
n = read();
for (long long i = 1, a, b; i <= n; ++i) {
a = read();
b = read();
A[i].init(a);
B[i].init(b);
}
for (long long i = 2; i <= n; ++i) {
UN(A[1], B[1], A[i], B[i]);
}
long long ans = 1;
for (long long i = 0; i < A[1].num; ++i) {
ans = ans * 1ll * ksm(A[1].p[i].p, A[1].p[i].k) % P;
}
printf("%lld\n", ans);
return 0;
}
|
Every day Ruslan tried to count sheep to fall asleep, but this didn't help. Now he has found a more interesting thing to do. First, he thinks of some set of circles on a plane, and then tries to choose a beautiful set of points, such that there is at least one point from the set inside or on the border of each of the imagined circles.
Yesterday Ruslan tried to solve this problem for the case when the set of points is considered beautiful if it is given as (xt = f(t), yt = g(t)), where argument t takes all integer values from 0 to 50. Moreover, f(t) and g(t) should be correct functions.
Assume that w(t) and h(t) are some correct functions, and c is an integer ranging from 0 to 50. The function s(t) is correct if it's obtained by one of the following rules:
1. s(t) = abs(w(t)), where abs(x) means taking the absolute value of a number x, i.e. |x|;
2. s(t) = (w(t) + h(t));
3. s(t) = (w(t) - h(t));
4. s(t) = (w(t) * h(t)), where * means multiplication, i.e. (w(t)·h(t));
5. s(t) = c;
6. s(t) = t;
Yesterday Ruslan thought on and on, but he could not cope with the task. Now he asks you to write a program that computes the appropriate f(t) and g(t) for any set of at most 50 circles.
In each of the functions f(t) and g(t) you are allowed to use no more than 50 multiplications. The length of any function should not exceed 100·n characters. The function should not contain spaces.
Ruslan can't keep big numbers in his memory, so you should choose f(t) and g(t), such that for all integer t from 0 to 50 value of f(t) and g(t) and all the intermediate calculations won't exceed 109 by their absolute value.
Input
The first line of the input contains number n (1 ≤ n ≤ 50) — the number of circles Ruslan thinks of. Next follow n lines, each of them containing three integers xi, yi and ri (0 ≤ xi, yi ≤ 50, 2 ≤ ri ≤ 50) — the coordinates of the center and the raduis of the i-th circle.
Output
In the first line print a correct function f(t). In the second line print a correct function g(t). The set of the points (xt = f(t), yt = g(t)) (0 ≤ t ≤ 50) must satisfy the condition, that there is at least one point inside or on the border of each of the circles, Ruslan thinks of at the beginning.
Examples
Input
3
0 10 4
10 0 4
20 10 4
Output
t
abs((t-10))
Note
Correct functions:
1. 10
2. (1+2)
3. ((t-3)+(t*4))
4. abs((t-10))
5. (abs((((23-t)*(t*t))+((45+12)*(t*t))))*((5*t)+((12*t)-13)))
6. abs((t-(abs((t*31))+14))))
Incorrect functions:
1. 3+5+7 (not enough brackets, it should be ((3+5)+7) or (3+(5+7)))
2. abs(t-3) (not enough brackets, it should be abs((t-3))
3. 2+(2-3 (one bracket too many)
4. 1(t+5) (no arithmetic operation between 1 and the bracket)
5. 5000*5000 (the number exceeds the maximum)
<image> The picture shows one of the possible solutions | def f(x):
if x == n:
return "0"
if x == 0:
return "(" + str(X[0]) + "+" + f(1) + ")"
ss = "(abs((t-" + str(x-1) + "))-abs((t-" + str(x) + ")))"
tmp = (X[x] - X[x - 1]) // 2
re = (X[x] - X[x - 1]) - 2 * tmp
X[x] -= re
if tmp < 0:
tmp = "(0" +str(tmp)+")"
ss = "((" + str(tmp) + "*" + ss + ")" + "+" + str(tmp) + ")"
return "(" + ss + "+" + f(x + 1) + ")"
n = int(input())
#c = [(int(_) for _ in input().split()) for i in range(n)]
c = [[int(x) for x in input().split()] for i in range(n)]
#print(n, c)
X = [c[i][0] for i in range(n)]
Y = [c[i][1] for i in range(n)]
#print(X)
#print(Y)
print(f(0))
#print(X)
X = Y
print(f(0))
# Made By Mostafa_Khaled |
Vasya wants to turn on Christmas lights consisting of m bulbs. Initially, all bulbs are turned off. There are n buttons, each of them is connected to some set of bulbs. Vasya can press any of these buttons. When the button is pressed, it turns on all the bulbs it's connected to. Can Vasya light up all the bulbs?
If Vasya presses the button such that some bulbs connected to it are already turned on, they do not change their state, i.e. remain turned on.
Input
The first line of the input contains integers n and m (1 ≤ n, m ≤ 100) — the number of buttons and the number of bulbs respectively.
Each of the next n lines contains xi (0 ≤ xi ≤ m) — the number of bulbs that are turned on by the i-th button, and then xi numbers yij (1 ≤ yij ≤ m) — the numbers of these bulbs.
Output
If it's possible to turn on all m bulbs print "YES", otherwise print "NO".
Examples
Input
3 4
2 1 4
3 1 3 1
1 2
Output
YES
Input
3 3
1 1
1 2
1 1
Output
NO
Note
In the first sample you can press each button once and turn on all the bulbs. In the 2 sample it is impossible to turn on the 3-rd lamp. | import math
nm = input().split()
n = int(nm[0])
m = int(nm[1])
lis = [ 0 for i in range(m+1)]
for _ in range(n) :
inp = list(map(int, input().split()))
inp.pop(0)
for i in inp:
lis[i]=1
prev = i
if sum(lis)==m:
print("YES")
else:
print("NO") |
A factory produces thimbles in bulk. Typically, it can produce up to a thimbles a day. However, some of the machinery is defective, so it can currently only produce b thimbles each day. The factory intends to choose a k-day period to do maintenance and construction; it cannot produce any thimbles during this time, but will be restored to its full production of a thimbles per day after the k days are complete.
Initially, no orders are pending. The factory receives updates of the form di, ai, indicating that ai new orders have been placed for the di-th day. Each order requires a single thimble to be produced on precisely the specified day. The factory may opt to fill as many or as few of the orders in a single batch as it likes.
As orders come in, the factory owner would like to know the maximum number of orders he will be able to fill if he starts repairs on a given day pi. Help the owner answer his questions.
Input
The first line contains five integers n, k, a, b, and q (1 ≤ k ≤ n ≤ 200 000, 1 ≤ b < a ≤ 10 000, 1 ≤ q ≤ 200 000) — the number of days, the length of the repair time, the production rates of the factory, and the number of updates, respectively.
The next q lines contain the descriptions of the queries. Each query is of one of the following two forms:
* 1 di ai (1 ≤ di ≤ n, 1 ≤ ai ≤ 10 000), representing an update of ai orders on day di, or
* 2 pi (1 ≤ pi ≤ n - k + 1), representing a question: at the moment, how many orders could be filled if the factory decided to commence repairs on day pi?
It's guaranteed that the input will contain at least one query of the second type.
Output
For each query of the second type, print a line containing a single integer — the maximum number of orders that the factory can fill over all n days.
Examples
Input
5 2 2 1 8
1 1 2
1 5 3
1 2 1
2 2
1 4 2
1 3 2
2 1
2 3
Output
3
6
4
Input
5 4 10 1 6
1 1 5
1 5 5
1 3 2
1 5 2
2 1
2 2
Output
7
1
Note
Consider the first sample.
We produce up to 1 thimble a day currently and will produce up to 2 thimbles a day after repairs. Repairs take 2 days.
For the first question, we are able to fill 1 order on day 1, no orders on days 2 and 3 since we are repairing, no orders on day 4 since no thimbles have been ordered for that day, and 2 orders for day 5 since we are limited to our production capacity, for a total of 3 orders filled.
For the third question, we are able to fill 1 order on day 1, 1 order on day 2, and 2 orders on day 5, for a total of 4 orders. | #include <bits/stdc++.h>
using namespace std;
long long tree[1000000][2];
long long ar[1000000];
int a, b;
long long query(int x, int l, int r, int s, int e, bool k) {
if (l > e || r < s || s > e) return 0;
if (l >= s && r <= e)
return tree[x][k];
else {
return query(x * 2, l, (l + r) / 2, s, e, k) +
query(x * 2 + 1, (l + r) / 2 + 1, r, s, e, k);
}
}
void upd(int x, int l, int r, int v) {
if (v > r || v < l) return;
if (l == r && v == l) {
tree[x][0] = min(ar[v], b + 0LL);
tree[x][1] = min(ar[v], a + 0LL);
} else {
upd(x * 2, l, (l + r) / 2, v);
upd(x * 2 + 1, (l + r) / 2 + 1, r, v);
tree[x][0] = tree[x * 2][0] + tree[x * 2 + 1][0];
tree[x][1] = tree[x * 2][1] + tree[x * 2 + 1][1];
}
}
int main() {
int n, k, q;
cin >> n >> k >> a >> b >> q;
while (q--) {
int typ;
scanf("%d", &typ);
if (typ == 1) {
int d, x;
scanf("%d%d", &d, &x);
ar[d] += x;
upd(1, 1, n, d);
} else {
int p;
scanf("%d", &p);
printf("%I64d\n",
query(1, 1, n, 1, p - 1, 0) + query(1, 1, n, p + k, n, 1));
}
}
}
|
You are given a rebus of form ? + ? - ? + ? = n, consisting of only question marks, separated by arithmetic operation '+' and '-', equality and positive integer n. The goal is to replace each question mark with some positive integer from 1 to n, such that equality holds.
Input
The only line of the input contains a rebus. It's guaranteed that it contains no more than 100 question marks, integer n is positive and doesn't exceed 1 000 000, all letters and integers are separated by spaces, arithmetic operations are located only between question marks.
Output
The first line of the output should contain "Possible" (without quotes) if rebus has a solution and "Impossible" (without quotes) otherwise.
If the answer exists, the second line should contain any valid rebus with question marks replaced by integers from 1 to n. Follow the format given in the samples.
Examples
Input
? + ? - ? + ? + ? = 42
Output
Possible
9 + 13 - 39 + 28 + 31 = 42
Input
? - ? = 1
Output
Impossible
Input
? = 1000000
Output
Possible
1000000 = 1000000 | import java.io.*;
import java.util.*;
import java.util.Map.Entry;
public class Task_Rnd664_B {
final static String input_file_name = "input/Rnd664_B.txt";
public static void main(String[] args)
{
//!!!!!!!!!!111
reader.init(true); //to server
//reader.init(false);
run();
wr.flush();
}
public static void run()
{
String s = reader.readln();
int xx = 0;
int kk = 0;
int nn = 0;
boolean plus = true;
for (int ii = 0; ii < s.length(); ii++)
{
char cc = s.charAt(ii);
if (cc == '+')
plus = true;
if (cc == '-')
plus = false;
if (cc == '?')
{
if (plus)
xx++;
else
kk++;
}
if (cc == '=')
{
String s2 = s.substring(ii+1, s.length());
s2 = s2.trim();
nn = Integer.valueOf(s2);
break;
}
}
if (xx*nn - kk * 1 < nn || xx * 1 - kk * nn > nn)
{
wr.print("Impossible");
wr2.endl();
return;
}
int vv = xx * nn - kk * 1;
int ll = vv - nn;
int aa1[] = new int[xx];
int aa2[] = new int[kk+1];
for (int ii = 0; ii < xx; ii++)
aa1[ii] = nn;
for (int ii = 0; ii < kk; ii++)
aa2[ii] = 1;
int ii = 0;
while (ll > 0 && ii < xx)
{
int bb = aa1[ii]-1;
if (bb > ll)
bb = ll;
aa1[ii] -= bb;
ll -= bb;
ii++;
}
ii = 0;
while (ll > 0 && ii < kk)
{
int bb = nn-aa2[ii];
if (bb > ll)
bb = ll;
aa2[ii] += bb;
ll -= bb;
ii++;
}
if (ll > 0)
{
wr.print("Impossible");
wr2.endl();
return;
}
wr.print("Possible");
wr2.endl();
int ind1 = 0;
int ind2 = 0;
plus = true;
for (int jj = 0; jj < s.length(); jj++)
{
char cc = s.charAt(jj);
if (cc == '+')
{
plus = true;
wr.print("+ ");
}
if (cc == '-')
{
plus = false;
wr.print("- ");
}
if (cc == '?')
{
if (plus)
{
wr.print(aa1[ind1++]);
wr.print(" ");
}
else
{
wr.print(aa2[ind2++]);
wr.print(" ");
}
}
if (cc == '=')
{
String s2 = s.substring(jj, s.length());
wr.print(s2);
break;
}
}
wr2.endl();
}
static public PrintWriter wr;
static OutputWriter wr2=new OutputWriter(System.out);
static class reader{
static BufferedReader br; static StringTokenizer tkn;
static String readln() { try { return br.readLine(); } catch (Exception e) { return ""; } }
static void init(boolean console) {
if (console) { br=new BufferedReader(new InputStreamReader(System.in)); }
else { try { br=new BufferedReader(new InputStreamReader(new FileInputStream(input_file_name))); }
catch (Exception e) { System.exit(551); } }
tkn=new StringTokenizer("");
}
static String next() { while (!tkn.hasMoreTokens()){ tkn=new StringTokenizer(readln()); } return tkn.nextToken(); }
static int nextInt(){ while (!tkn.hasMoreTokens()){ tkn=new StringTokenizer(readln()); } return Integer.parseInt(tkn.nextToken()); }
static long nextLong(){ while (!tkn.hasMoreTokens()){ tkn=new StringTokenizer(readln()); } return Long.parseLong(tkn.nextToken()); }
static double nextDouble(){ while (!tkn.hasMoreTokens()){ tkn=new StringTokenizer(readln()); } return Double.parseDouble(tkn.nextToken()); }
}
static class OutputWriter {
OutputWriter(OutputStream stream) { wr = new PrintWriter(stream); }
public void printf(String format, Object... args) { wr.print(String.format(Locale.ENGLISH, format, args)); }
public void endl() { wr.print("\n"); }
}
}
|
Long time ago, there was a great kingdom and it was being ruled by The Great Arya and Pari The Great. These two had some problems about the numbers they like, so they decided to divide the great kingdom between themselves.
The great kingdom consisted of n cities numbered from 1 to n and m bidirectional roads between these cities, numbered from 1 to m. The i-th road had length equal to wi. The Great Arya and Pari The Great were discussing about destructing some prefix (all road with numbers less than some x) and suffix (all roads with numbers greater than some x) of the roads so there will remain only the roads with numbers l, l + 1, ..., r - 1 and r.
After that they will divide the great kingdom into two pieces (with each city belonging to exactly one piece) such that the hardness of the division is minimized. The hardness of a division is the maximum length of a road such that its both endpoints are in the same piece of the kingdom. In case there is no such road, the hardness of the division is considered to be equal to - 1.
Historians found the map of the great kingdom, and they have q guesses about the l and r chosen by those great rulers. Given these data, for each guess li and ri print the minimum possible hardness of the division of the kingdom.
Input
The first line of the input contains three integers n, m and q (1 ≤ n, q ≤ 1000, <image>) — the number of cities and roads in the great kingdom, and the number of guesses, respectively.
The i-th line of the following m lines contains three integers ui, vi and wi (1 ≤ ui, vi ≤ n, 0 ≤ wi ≤ 109), denoting the road number i connects cities ui and vi and its length is equal wi. It's guaranteed that no road connects the city to itself and no pair of cities is connected by more than one road.
Each of the next q lines contains a pair of integers li and ri (1 ≤ li ≤ ri ≤ m) — a guess from the historians about the remaining roads in the kingdom.
Output
For each guess print the minimum possible hardness of the division in described scenario.
Example
Input
5 6 5
5 4 86
5 1 0
1 3 38
2 1 33
2 4 28
2 3 40
3 5
2 6
1 3
2 3
1 6
Output
-1
33
-1
-1
33 | #include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 1000, M = N * (N - 1) / 2;
int dsu[N * 2];
int find(int i) { return dsu[i] < 0 ? i : (dsu[i] = find(dsu[i])); }
bool join(int i, int j) {
i = find(i);
j = find(j);
if (i == j) return false;
if (dsu[i] > dsu[j])
dsu[i] = j;
else {
if (dsu[i] == dsu[j]) dsu[i]--;
dsu[j] = i;
}
return true;
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
static int ii[M], jj[M], ww[M], hh[M];
for (int h = 0; h < m; h++) {
int i, j, w;
scanf("%d%d%d", &i, &j, &w), i--, j--;
ii[h] = i;
jj[h] = j;
ww[h] = w;
hh[h] = h;
}
sort(hh, hh + m, [](int a, int b) { return ww[a] > ww[b]; });
while (q-- > 0) {
int l, r;
scanf("%d%d", &l, &r), l--, r--;
fill_n(dsu, n * 2, -1);
int w = -1;
for (int h = 0; h < m; h++) {
int h_ = hh[h];
if (l <= h_ && h_ <= r) {
int i = ii[h_];
int j = jj[h_];
int i0 = i << 1, i1 = i0 | 1;
int j0 = j << 1, j1 = j0 | 1;
if (join(i0, j1) && !join(i1, j0)) {
w = ww[h_];
break;
}
}
}
printf("%d\n", w);
}
}
|
In Walrusland public transport tickets are characterized by two integers: by the number of the series and by the number of the ticket in the series. Let the series number be represented by a and the ticket number — by b, then a ticket is described by the ordered pair of numbers (a, b).
The walruses believe that a ticket is lucky if a * b = rev(a) * rev(b). The function rev(x) reverses a number written in the decimal system, at that the leading zeroes disappear. For example, rev(12343) = 34321, rev(1200) = 21.
The Public Transport Management Committee wants to release x series, each containing y tickets, so that at least w lucky tickets were released and the total number of released tickets (x * y) were minimum. The series are numbered from 1 to x inclusive. The tickets in each series are numbered from 1 to y inclusive. The Transport Committee cannot release more than maxx series and more than maxy tickets in one series.
Input
The first line contains three integers maxx, maxy, w (1 ≤ maxx, maxy ≤ 105, 1 ≤ w ≤ 107).
Output
Print on a single line two space-separated numbers, the x and the y. If there are several possible variants, print any of them. If such x and y do not exist, print a single number - 1.
Examples
Input
2 2 1
Output
1 1
Input
132 10 35
Output
7 5
Input
5 18 1000
Output
-1
Input
48 132 235
Output
22 111 | #include <bits/stdc++.h>
using namespace std;
int in() {
int a;
scanf("%d", &a);
return a;
}
int gcm(int a, int b) {
if (b > a) return gcm(b, a);
if (a % b == 0)
return b;
else
return gcm(b, a % b);
}
int calc_rev(int x) {
int ret = 0;
while (x) {
int a = x % 10;
ret = ret * 10 + a;
x /= 10;
}
return ret;
}
int rev[100010];
map<pair<int, int>, vector<int> > lucky;
pair<int, int> a_reva(int a) {
int g = gcm(a, rev[a]);
int b = a / g;
int c = rev[a] / g;
return make_pair(b, c);
}
pair<int, int> invert_pint(pair<int, int> t) {
return make_pair(t.second, t.first);
}
int main() {
for (int i = (1); i <= (100000); i++) {
rev[i] = calc_rev(i);
}
for (int i = (1); i <= (100000); i++) {
lucky[a_reva(i)].push_back(i);
}
pair<int, int> ans = make_pair(-1, -1);
long long ans_fact = ((long long)(1001001001) * (1001001001));
int maxx = in();
int maxy = in();
int w = in();
int bar = maxy;
int ltickets = 0;
for (int x = (1); x <= (maxx); x++) {
vector<int> hoge = lucky[invert_pint(a_reva(x))];
int ind =
distance(hoge.begin(), upper_bound(hoge.begin(), hoge.end(), bar));
ltickets += ind;
while (ltickets >= w) {
if ((long long)x * bar < ans_fact) {
ans = make_pair(x, bar);
ans_fact = (long long)x * bar;
}
vector<int> fuga = lucky[invert_pint(a_reva(bar))];
int ind2 =
distance(fuga.begin(), upper_bound(fuga.begin(), fuga.end(), x));
ltickets -= ind2;
bar--;
}
}
if (ans.first == -1) {
puts("-1");
} else {
printf("%d %d\n", ans.first, ans.second);
}
return 0;
}
|
Nick has n bottles of soda left after his birthday. Each bottle is described by two values: remaining amount of soda ai and bottle volume bi (ai ≤ bi).
Nick has decided to pour all remaining soda into minimal number of bottles, moreover he has to do it as soon as possible. Nick spends x seconds to pour x units of soda from one bottle to another.
Nick asks you to help him to determine k — the minimal number of bottles to store all remaining soda and t — the minimal time to pour soda into k bottles. A bottle can't store more soda than its volume. All remaining soda should be saved.
Input
The first line contains positive integer n (1 ≤ n ≤ 100) — the number of bottles.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 100), where ai is the amount of soda remaining in the i-th bottle.
The third line contains n positive integers b1, b2, ..., bn (1 ≤ bi ≤ 100), where bi is the volume of the i-th bottle.
It is guaranteed that ai ≤ bi for any i.
Output
The only line should contain two integers k and t, where k is the minimal number of bottles that can store all the soda and t is the minimal time to pour the soda into k bottles.
Examples
Input
4
3 3 4 3
4 7 6 5
Output
2 6
Input
2
1 1
100 100
Output
1 1
Input
5
10 30 5 6 24
10 41 7 8 24
Output
3 11
Note
In the first example Nick can pour soda from the first bottle to the second bottle. It will take 3 seconds. After it the second bottle will contain 3 + 3 = 6 units of soda. Then he can pour soda from the fourth bottle to the second bottle and to the third bottle: one unit to the second and two units to the third. It will take 1 + 2 = 3 seconds. So, all the soda will be in two bottles and he will spend 3 + 3 = 6 seconds to do it. | #include <bits/stdc++.h>
using namespace std;
pair<int, int> dp[10005];
int a[105], b[105];
int main() {
int n;
scanf("%d", &n);
int cap = 0, mx = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
cap += a[i];
}
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
mx += b[i];
}
for (int i = 1; i <= mx; i++) dp[i] = make_pair(-1, -1);
for (int i = 0; i < n; i++) {
for (int j = mx; j >= 0; j--) {
if (dp[j].first == -1) continue;
int nxt = j + b[i];
if (dp[nxt].first == -1)
dp[nxt] = make_pair(dp[j].first + 1, dp[j].second + a[i]);
else if (dp[nxt].first > dp[j].first + 1)
dp[nxt] = make_pair(dp[j].first + 1, dp[j].second + a[i]);
else if (dp[nxt].first == dp[j].first + 1)
dp[nxt].second = max(dp[nxt].second, dp[j].second + a[i]);
}
}
pair<int, int> mn = make_pair((int)1e9, 0);
for (int i = cap; i <= mx; i++) {
if (dp[i].first == -1) continue;
if (dp[i].first < mn.first)
mn = dp[i];
else if (dp[i].first == mn.first)
mn.second = max(mn.second, dp[i].second);
}
printf("%d %d\n", mn.first, cap - mn.second);
return 0;
}
|
Dasha is fond of challenging puzzles: Rubik's Cube 3 × 3 × 3, 4 × 4 × 4, 5 × 5 × 5 and so on. This time she has a cyclic table of size n × m, and each cell of the table contains a lowercase English letter. Each cell has coordinates (i, j) (0 ≤ i < n, 0 ≤ j < m). The table is cyclic means that to the right of cell (i, j) there is the cell <image>, and to the down there is the cell <image>.
Dasha has a pattern as well. A pattern is a non-cyclic table of size r × c. Each cell is either a lowercase English letter or a question mark. Each cell has coordinates (i, j) (0 ≤ i < r, 0 ≤ j < c).
The goal of the puzzle is to find all the appearance positions of the pattern in the cyclic table.
We say that the cell (i, j) of cyclic table is an appearance position, if for every pair (x, y) such that 0 ≤ x < r and 0 ≤ y < c one of the following conditions holds:
* There is a question mark in the cell (x, y) of the pattern, or
* The cell <image> of the cyclic table equals to the cell (x, y) of the pattern.
Dasha solved this puzzle in no time, as well as all the others she ever tried. Can you solve it?.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 400) — the cyclic table sizes.
Each of the next n lines contains a string of m lowercase English characters — the description of the cyclic table.
The next line contains two integers r and c (1 ≤ r, c ≤ 400) — the sizes of the pattern.
Each of the next r lines contains a string of c lowercase English letter and/or characters '?' — the description of the pattern.
Output
Print n lines. Each of the n lines should contain m characters. Each of the characters should equal '0' or '1'.
The j-th character of the i-th (0-indexed) line should be equal to '1', in case the cell (i, j) is an appearance position, otherwise it should be equal to '0'.
Examples
Input
5 7
qcezchs
hhedywq
wikywqy
qckrqzt
bqexcxz
3 2
??
yw
?q
Output
0000100
0001001
0000000
0000000
0000000
Input
10 10
fwtoayylhw
yyaryyjawr
ywrdzwhscy
hnsyyxiphn
bnjwzyyjvo
kkjgseenwn
gvmiflpcsy
lxvkwrobwu
wyybbcocyy
yysijsvqry
2 2
??
yy
Output
1000100000
0000000001
0001000000
0000010000
0000000000
0000000000
0000000000
0100000010
1000000001
0000010000
Input
8 6
ibrgxl
xqdcsg
okbcgi
tvpetc
xgxxig
igghzo
lmlaza
gpswzv
1 4
gx??
Output
000100
000001
000000
000000
010001
000000
000000
000000 | #include <bits/stdc++.h>
using namespace std;
static const int INF = 0x3f3f3f3f;
static const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
template <typename T, typename U>
static void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static void amax(T &x, U y) {
if (x < y) x = y;
}
struct FFTCoeffTable {
static const int logn = 10, n = 1 << logn;
complex<double> coeffs[n];
FFTCoeffTable() {
const double PI = 3.141592653589793238462643383279L;
for (int i = 0; i < n; ++i) {
double theta = 2 * PI * i / n;
coeffs[i] = complex<double>(cos(theta), sin(theta));
}
}
} fftCoeffTable;
void fft_core(complex<double> *x, int logn, int sign) {
int n = 1 << logn;
for (int i = 1, j = 0; i < n; ++i) {
int h = n >> 1;
while (((j ^= h) & h) == 0) h >>= 1;
if (i < j) swap(x[i], x[j]);
}
for (int logm = 1; logm <= logn; ++logm) {
int winc = (1 << (fftCoeffTable.logn - logm)) * sign;
if (winc < 0) winc += fftCoeffTable.n;
int h = 1 << (logm - 1);
for (int i = 0; i < n; i += 1 << logm) {
int wk = 0;
for (int j = i; j < i + h; ++j) {
const complex<double> &w = fftCoeffTable.coeffs[wk];
int k = j + h;
double lr = x[k].real() * w.real() - x[k].imag() * w.imag();
double li = x[k].real() * w.imag() + x[k].imag() * w.real();
x[k] = complex<double>(x[j].real() - lr, x[j].imag() - li);
x[j] = complex<double>(x[j].real() + lr, x[j].imag() + li);
if ((wk += winc) >= fftCoeffTable.n) wk -= fftCoeffTable.n;
}
}
}
}
void fft(int logn, complex<double> a[]) { fft_core(a, logn, +1); }
void inverse_fft(int logn, complex<double> a[]) {
fft_core(a, logn, -1);
complex<double> inv = double(1) / (1 << logn);
for (int(i) = 0; (i) < (int)(1 << logn); ++(i)) a[i] *= inv;
}
using Ring = complex<double>;
void FFT2D(int logh, int H, int logw, int W, vector<vector<Ring>> &A) {
assert(A.size() == 1 << logh);
for (int(i) = 0; (i) < (int)(H); ++(i)) {
assert(A[i].size() == 1 << logw);
fft(logw, A[i].data());
}
vector<Ring> tmp(1 << logh);
for (int(j) = 0; (j) < (int)(1 << logw); ++(j)) {
for (int(i) = 0; (i) < (int)(1 << logh); ++(i)) tmp[i] = A[i][j];
fft(logh, tmp.data());
for (int(i) = 0; (i) < (int)(1 << logh); ++(i)) A[i][j] = tmp[i];
}
}
void FFT2Dinv(int logh, int H, int logw, int W, vector<vector<Ring>> &A) {
vector<Ring> tmp(1 << logh);
for (int(j) = 0; (j) < (int)(1 << logw); ++(j)) {
for (int(i) = 0; (i) < (int)(1 << logh); ++(i)) tmp[i] = A[i][j];
inverse_fft(logh, tmp.data());
for (int(i) = 0; (i) < (int)(1 << logh); ++(i)) A[i][j] = tmp[i];
}
for (int(i) = 0; (i) < (int)(H); ++(i)) inverse_fft(logw, A[i].data());
}
int main() {
int tH;
int tW;
while (~scanf("%d%d", &tH, &tW)) {
vector<string> table(tH);
for (int(i) = 0; (i) < (int)(tH); ++(i)) {
char buf[401];
scanf("%s", buf);
table[i] = buf;
}
int pH;
int pW;
scanf("%d%d", &pH, &pW);
vector<string> pattern(pH);
for (int(i) = 0; (i) < (int)(pH); ++(i)) {
char buf[401];
scanf("%s", buf);
pattern[i] = buf;
}
int H = tH + pH, W = tW + pW;
int logh = 1, logw = 1;
while (1 << logh < H) ++logh;
while (1 << logw < W) ++logw;
vector<vector<int>> matches(tH, vector<int>(tW, 0));
for (int a = 0; a < 26; a += 2) {
vector<vector<Ring>> A(1 << logh, vector<Ring>(1 << logw)), B = A;
for (int(i) = 0; (i) < (int)(tH + pH); ++(i))
for (int(j) = 0; (j) < (int)(tW + pW); ++(j)) {
char c = table[i % tH][j % tW];
int x = c == 'a' + a, y = c == 'a' + (a + 1);
A[tH + pH - 1 - i][tW + pW - 1 - j] = complex<double>(x, y);
}
for (int(i) = 0; (i) < (int)(pH); ++(i))
for (int(j) = 0; (j) < (int)(pW); ++(j)) {
char c = pattern[i][j];
int x = c == 'a' + a, y = c == 'a' + (a + 1);
B[i][j] = complex<double>(x, -y);
}
FFT2D(logh, H, logw, W, A);
FFT2D(logh, H, logw, W, B);
for (int(i) = 0; (i) < (int)(1 << logh); ++(i))
for (int(j) = 0; (j) < (int)(1 << logw); ++(j)) A[i][j] *= B[i][j];
FFT2Dinv(logh, H, logw, W, A);
for (int(i) = 0; (i) < (int)(tH); ++(i))
for (int(j) = 0; (j) < (int)(tW); ++(j)) {
Ring r = A[tH + pH - 1 - i][tW + pW - 1 - j];
matches[i][j] += (int)round(r.real());
}
}
int qs = 0;
for (int(i) = 0; (i) < (int)(pH); ++(i))
for (int(j) = 0; (j) < (int)(pW); ++(j)) qs += pattern[i][j] == '?';
for (int(i) = 0; (i) < (int)(tH); ++(i))
for (int(j) = 0; (j) < (int)(tW); ++(j)) matches[i][j] += qs;
vector<string> ans(tH, string(tW, '?'));
for (int(i) = 0; (i) < (int)(tH); ++(i))
for (int(j) = 0; (j) < (int)(tW); ++(j))
ans[i][j] = matches[i][j] == pH * pW ? '1' : '0';
for (int(i) = 0; (i) < (int)(tH); ++(i)) puts(ans[i].c_str());
}
return 0;
}
|
Our beloved detective, Sherlock is currently trying to catch a serial killer who kills a person each day. Using his powers of deduction, he came to know that the killer has a strategy for selecting his next victim.
The killer starts with two potential victims on his first day, selects one of these two, kills selected victim and replaces him with a new person. He repeats this procedure each day. This way, each day he has two potential victims to choose from. Sherlock knows the initial two potential victims. Also, he knows the murder that happened on a particular day and the new person who replaced this victim.
You need to help him get all the pairs of potential victims at each day so that Sherlock can observe some pattern.
Input
First line of input contains two names (length of each of them doesn't exceed 10), the two initials potential victims. Next line contains integer n (1 ≤ n ≤ 1000), the number of days.
Next n lines contains two names (length of each of them doesn't exceed 10), first being the person murdered on this day and the second being the one who replaced that person.
The input format is consistent, that is, a person murdered is guaranteed to be from the two potential victims at that time. Also, all the names are guaranteed to be distinct and consists of lowercase English letters.
Output
Output n + 1 lines, the i-th line should contain the two persons from which the killer selects for the i-th murder. The (n + 1)-th line should contain the two persons from which the next victim is selected. In each line, the two names can be printed in any order.
Examples
Input
ross rachel
4
ross joey
rachel phoebe
phoebe monica
monica chandler
Output
ross rachel
joey rachel
joey phoebe
joey monica
joey chandler
Input
icm codeforces
1
codeforces technex
Output
icm codeforces
icm technex
Note
In first example, the killer starts with ross and rachel.
* After day 1, ross is killed and joey appears.
* After day 2, rachel is killed and phoebe appears.
* After day 3, phoebe is killed and monica appears.
* After day 4, monica is killed and chandler appears. | import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
import java.lang.*;
public class A {
static long mod = 1000000007;
public static void main(String[] args) throws Exception {
InputReader in = new InputReader(System.in);
PrintWriter pw = new PrintWriter(System.out);
//int t=in.readInt();
//while(t-->0)
//{
String x=in.readString();
String y=in.readString();
pw.println(x+" "+y);
int n=in.readInt();
for(int i=0;i<n;i++)
{
String a=in.readString();
String b=in.readString();
if(a.compareTo(x)==0)
{
pw.println(b+" "+y);
x=b;
}
else if(a.compareTo(y)==0)
{
pw.println(x+" "+b);
y=b;
}
}
//long n=in.readLong();
/*int a[]=new int[n];
for(int i=0;i<n;i++)
{
a[i]=in.readInt();
}*/
//String a=in.readString();
//pw.println("");
//}
pw.close();
}
public static long gcd(long x, long y) {
if (x % y == 0)
return y;
else
return gcd(y, x % y);
}
public static int gcd(int x, int y) {
if (x % y == 0)
return y;
else
return gcd(y, x % y);
}
public static int abs(int a, int b) {
return (int) Math.abs(a - b);
}
public static long abs(long a, long b) {
return (long) Math.abs(a - b);
}
public static int max(int a, int b) {
if (a > b)
return a;
else
return b;
}
public static int min(int a, int b) {
if (a > b)
return b;
else
return a;
}
public static long max(long a, long b) {
if (a > b)
return a;
else
return b;
}
public static long min(long a, long b) {
if (a > b)
return b;
else
return a;
}
public static long pow(long n, long p, long m) {
long result = 1;
if (p == 0)
return 1;
if (p == 1)
return n;
while (p != 0) {
if (p % 2 == 1)
result *= n;
if (result >= m)
result %= m;
p >>= 1;
n *= n;
if (n >= m)
n %= m;
}
return result;
}
public static long pow(long n, long p) {
long result = 1;
if (p == 0)
return 1;
if (p == 1)
return n;
while (p != 0) {
if (p % 2 == 1)
result *= n;
p >>= 1;
n *= n;
}
return result;
}
static class Pair implements Comparable<Pair> {
int a, b;
Pair(int a, int b) {
this.a = a;
this.b = b;
}
public int compareTo(Pair o) {
// TODO Auto-generated method stub
if (this.a != o.a)
return Integer.compare(this.a, o.a);
else
return Integer.compare(this.b, o.b);
//return 0;
}
public boolean equals(Object o) {
if (o instanceof Pair) {
Pair p = (Pair) o;
return p.a == a && p.b == b;
}
return false;
}
public int hashCode() {
return new Integer(a).hashCode() * 31 + new Integer(b).hashCode();
}
public String toString() {
return a + " " + b;
}
}
static long sort(int a[]) {
int n = a.length;
int b[] = new int[n];
return mergeSort(a, b, 0, n - 1);
}
static long mergeSort(int a[], int b[], long left, long right) {
long c = 0;
if (left < right) {
long mid = left + (right - left) / 2;
c = mergeSort(a, b, left, mid);
c += mergeSort(a, b, mid + 1, right);
c += merge(a, b, left, mid + 1, right);
}
return c;
}
static long merge(int a[], int b[], long left, long mid, long right) {
long c = 0;
int i = (int) left;
int j = (int) mid;
int k = (int) left;
while (i <= (int) mid - 1 && j <= (int) right) {
if (a[i] <= a[j]) {
b[k++] = a[i++];
} else {
b[k++] = a[j++];
c += mid - i;
}
}
while (i <= (int) mid - 1)
b[k++] = a[i++];
while (j <= (int) right)
b[k++] = a[j++];
for (i = (int) left; i <= (int) right; i++)
a[i] = b[i];
return c;
}
public static int[] radixSort(int[] f) {
int[] to = new int[f.length];
{
int[] b = new int[65537];
for (int i = 0; i < f.length; i++)
b[1 + (f[i] & 0xffff)]++;
for (int i = 1; i <= 65536; i++)
b[i] += b[i - 1];
for (int i = 0; i < f.length; i++)
to[b[f[i] & 0xffff]++] = f[i];
int[] d = f;
f = to;
to = d;
}
{
int[] b = new int[65537];
for (int i = 0; i < f.length; i++)
b[1 + (f[i] >>> 16)]++;
for (int i = 1; i <= 65536; i++)
b[i] += b[i - 1];
for (int i = 0; i < f.length; i++)
to[b[f[i] >>> 16]++] = f[i];
int[] d = f;
f = to;
to = d;
}
return f;
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public int readInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String readString() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public String readLine() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isEndOfLine(c));
return res.toString();
}
public double readDouble() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
double res = 0;
while (!isSpaceChar(c) && c != '.') {
if (c == 'e' || c == 'E')
return res * Math.pow(10, readInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
if (c == '.') {
c = read();
double m = 1;
while (!isSpaceChar(c)) {
if (c == 'e' || c == 'E')
return res * Math.pow(10, readInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
public long readLong() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public String next() {
return readString();
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
public boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
}
//BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//StringBuilder sb=new StringBuilder("");
//InputReader in = new InputReader(System.in);
//PrintWriter pw=new PrintWriter(System.out);
//String line=br.readLine().trim();
//int t=Integer.parseInt(br.readLine());
// while(t-->0)
//{
//int n=Integer.parseInt(br.readLine());
//long n=Long.parseLong(br.readLine());
//String l[]=br.readLine().split(" ");
//int m=Integer.parseInt(l[0]);
//int k=Integer.parseInt(l[1]);
//String l[]=br.readLine().split(" ");
//l=br.readLine().split(" ");
/*int a[]=new int[n];
for(int i=0;i<n;i++)
{
a[i]=Integer.parseInt(l[i]);
}*/
//System.out.println(" ");
//}
}
|
There is little time left before the release of the first national operating system BerlOS. Some of its components are not finished yet — the memory manager is among them. According to the developers' plan, in the first release the memory manager will be very simple and rectilinear. It will support three operations:
* alloc n — to allocate n bytes of the memory and return the allocated block's identifier x;
* erase x — to erase the block with the identifier x;
* defragment — to defragment the free memory, bringing all the blocks as close to the beginning of the memory as possible and preserving their respective order;
The memory model in this case is very simple. It is a sequence of m bytes, numbered for convenience from the first to the m-th.
The first operation alloc n takes as the only parameter the size of the memory block that is to be allocated. While processing this operation, a free block of n successive bytes is being allocated in the memory. If the amount of such blocks is more than one, the block closest to the beginning of the memory (i.e. to the first byte) is prefered. All these bytes are marked as not free, and the memory manager returns a 32-bit integer numerical token that is the identifier of this block. If it is impossible to allocate a free block of this size, the function returns NULL.
The second operation erase x takes as its parameter the identifier of some block. This operation frees the system memory, marking the bytes of this block as free for further use. In the case when this identifier does not point to the previously allocated block, which has not been erased yet, the function returns ILLEGAL_ERASE_ARGUMENT.
The last operation defragment does not have any arguments and simply brings the occupied memory sections closer to the beginning of the memory without changing their respective order.
In the current implementation you are to use successive integers, starting with 1, as identifiers. Each successful alloc operation procession should return following number. Unsuccessful alloc operations do not affect numeration.
You are to write the implementation of the memory manager. You should output the returned value for each alloc command. You should also output ILLEGAL_ERASE_ARGUMENT for all the failed erase commands.
Input
The first line of the input data contains two positive integers t and m (1 ≤ t ≤ 100;1 ≤ m ≤ 100), where t — the amount of operations given to the memory manager for processing, and m — the available memory size in bytes. Then there follow t lines where the operations themselves are given. The first operation is alloc n (1 ≤ n ≤ 100), where n is an integer. The second one is erase x, where x is an arbitrary 32-bit integer numerical token. The third operation is defragment.
Output
Output the sequence of lines. Each line should contain either the result of alloc operation procession , or ILLEGAL_ERASE_ARGUMENT as a result of failed erase operation procession. Output lines should go in the same order in which the operations are processed. Successful procession of alloc operation should return integers, starting with 1, as the identifiers of the allocated blocks.
Examples
Input
6 10
alloc 5
alloc 3
erase 1
alloc 6
defragment
alloc 6
Output
1
2
NULL
3 | #include <bits/stdc++.h>
using namespace std;
int main() {
int t, m, num = 1;
string com;
int arg;
vector<pair<pair<int, int>, int> > d;
cin >> t >> m;
for (int _n((t)-1), q(0); q <= _n; q++) {
sort((d).begin(), (d).end());
cin >> com;
if (com == "defragment") {
if (d.size() > 0) {
d[0].first.second -= d[0].first.first;
d[0].first.first = 0;
for (int _n((d.size() - 1)), i(1); i <= _n; i++) {
int delta = d[i].first.first - d[i - 1].first.second;
d[i].first.first -= delta;
d[i].first.second -= delta;
}
}
continue;
}
cin >> arg;
if (com == "alloc") {
int res = -1;
if (d.size() > 0)
if (d[0].first.first >= arg) {
d.push_back(make_pair(make_pair(0, arg), num++));
res = 1;
}
if (res == -1)
for (int _n((d.size() - 1)), i(1); i <= _n; i++)
if (d[i].first.first - d[i - 1].first.second >= arg) {
d.push_back(make_pair(
make_pair(d[i - 1].first.second, d[i - 1].first.second + arg),
num++));
res = 1;
break;
}
if (res == -1)
if (d.size() > 0)
if (m - d[d.size() - 1].first.second >= arg) {
d.push_back(make_pair(make_pair(d[d.size() - 1].first.second,
d[d.size() - 1].first.second + arg),
num++));
res = 1;
}
if (res == -1)
if (d.size() == 0)
if (m >= arg) {
d.push_back(make_pair(make_pair(0, arg), num++));
res = 1;
}
if (res == -1)
cout << "NULL" << endl;
else
cout << num - 1 << endl;
continue;
}
if (com == "erase") {
bool res = false;
for (int i = 0; i < d.size(); i++)
if (d[i].second == arg) {
swap(d[i], d[d.size() - 1]);
d.pop_back();
res = true;
break;
}
if (!res) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
continue;
}
}
return 0;
}
|
Some time ago Mister B detected a strange signal from the space, which he started to study.
After some transformation the signal turned out to be a permutation p of length n or its cyclic shift. For the further investigation Mister B need some basis, that's why he decided to choose cyclic shift of this permutation which has the minimum possible deviation.
Let's define the deviation of a permutation p as <image>.
Find a cyclic shift of permutation p with minimum possible deviation. If there are multiple solutions, print any of them.
Let's denote id k (0 ≤ k < n) of a cyclic shift of permutation p as the number of right shifts needed to reach this shift, for example:
* k = 0: shift p1, p2, ... pn,
* k = 1: shift pn, p1, ... pn - 1,
* ...,
* k = n - 1: shift p2, p3, ... pn, p1.
Input
First line contains single integer n (2 ≤ n ≤ 106) — the length of the permutation.
The second line contains n space-separated integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the elements of the permutation. It is guaranteed that all elements are distinct.
Output
Print two integers: the minimum deviation of cyclic shifts of permutation p and the id of such shift. If there are multiple solutions, print any of them.
Examples
Input
3
1 2 3
Output
0 0
Input
3
2 3 1
Output
0 1
Input
3
3 2 1
Output
2 1
Note
In the first sample test the given permutation p is the identity permutation, that's why its deviation equals to 0, the shift id equals to 0 as well.
In the second sample test the deviation of p equals to 4, the deviation of the 1-st cyclic shift (1, 2, 3) equals to 0, the deviation of the 2-nd cyclic shift (3, 1, 2) equals to 4, the optimal is the 1-st cyclic shift.
In the third sample test the deviation of p equals to 4, the deviation of the 1-st cyclic shift (1, 3, 2) equals to 2, the deviation of the 2-nd cyclic shift (2, 1, 3) also equals to 2, so the optimal are both 1-st and 2-nd cyclic shifts. | import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
public class D421 {
InputStream is;
PrintWriter out;
int n;
long a[];
private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
void solve() {
int n = ni();
int p[] = new int[n + 1];
for (int i = 1; i <= n; i++) {
p[i] = ni();
}
int a[] = new int[n + 1];
long s1 = 0;
long s2 = 0;
int count = 0;
for (int i = 1; i <= n; i++) {
if (p[i] > i) {
a[p[i] - i]++;
s1 += p[i] - i;
count++;
} else {
s2 += i - p[i];
}
}
int shift = 1;
int ind = 0;
long min = s1 + s2;
for (int i = n; i > 1; i--) {
s1 -= count;
s2 += n - count - 1;
s2 -= n - p[i];
s1 += p[i] - 1;
if (shift + p[i] - 1 <= n) {
a[shift + p[i] - 1]++;
}
count = count - a[shift];
count++;
if (s1 + s2 < min) {
min = s1 + s2;
ind = shift;
}
shift++;
}
out.println(min + " " + ind);
}
void run() throws Exception {
String INPUT = "C:\\Users\\Admin\\Desktop\\input.txt";
is = oj ? System.in : new FileInputStream(INPUT);
out = new PrintWriter(System.out);
long s = System.currentTimeMillis();
solve();
out.flush();
tr(System.currentTimeMillis() - s + "ms");
}
public static void main(String[] args) throws Exception {
new Thread(null, new Runnable() {
public void run() {
try {
new D421().run();
} catch (Exception e) {
e.printStackTrace();
}
}
}, "1", 1 << 26).start();
}
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 (!oj)
System.out.println(Arrays.deepToString(o));
}
}
|
Igor is a post-graduate student of chemistry faculty in Berland State University (BerSU). He needs to conduct a complicated experiment to write his thesis, but laboratory of BerSU doesn't contain all the materials required for this experiment.
Fortunately, chemical laws allow material transformations (yes, chemistry in Berland differs from ours). But the rules of transformation are a bit strange.
Berland chemists are aware of n materials, numbered in the order they were discovered. Each material can be transformed into some other material (or vice versa). Formally, for each i (2 ≤ i ≤ n) there exist two numbers xi and ki that denote a possible transformation: ki kilograms of material xi can be transformed into 1 kilogram of material i, and 1 kilogram of material i can be transformed into 1 kilogram of material xi. Chemical processing equipment in BerSU allows only such transformation that the amount of resulting material is always an integer number of kilograms.
For each i (1 ≤ i ≤ n) Igor knows that the experiment requires ai kilograms of material i, and the laboratory contains bi kilograms of this material. Is it possible to conduct an experiment after transforming some materials (or none)?
Input
The first line contains one integer number n (1 ≤ n ≤ 105) — the number of materials discovered by Berland chemists.
The second line contains n integer numbers b1, b2... bn (1 ≤ bi ≤ 1012) — supplies of BerSU laboratory.
The third line contains n integer numbers a1, a2... an (1 ≤ ai ≤ 1012) — the amounts required for the experiment.
Then n - 1 lines follow. j-th of them contains two numbers xj + 1 and kj + 1 that denote transformation of (j + 1)-th material (1 ≤ xj + 1 ≤ j, 1 ≤ kj + 1 ≤ 109).
Output
Print YES if it is possible to conduct an experiment. Otherwise print NO.
Examples
Input
3
1 2 3
3 2 1
1 1
1 1
Output
YES
Input
3
3 2 1
1 2 3
1 1
1 2
Output
NO | #include <bits/stdc++.h>
const double Pi = acos(-1.0);
using namespace std;
const int maxN = 100005;
const long long inf = (long long)1e15;
int n;
long long b[maxN];
long long k[maxN];
long long req[maxN];
vector<int> G[maxN];
void dfs(int cur) {
for (int i = 0; i < (int)G[cur].size(); i++) {
int nxt = G[cur][i];
dfs(nxt);
if (req[nxt] < 0) {
if (inf / k[nxt] < (-req[nxt])) {
puts("NO");
exit(0);
}
req[cur] += k[nxt] * req[nxt];
} else
req[cur] += req[nxt];
}
}
int main(int argc, char** argv) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &b[i]);
long long a;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a);
req[i] = b[i] - a;
}
int x;
for (int i = 2; i <= n; i++) {
scanf("%d %lld", &x, &k[i]);
G[x].push_back(i);
}
dfs(1);
puts((req[1] < 0) ? "NO" : "YES");
return 0;
}
|
As technologies develop, manufacturers are making the process of unlocking a phone as user-friendly as possible. To unlock its new phone, Arkady's pet dog Mu-mu has to bark the password once. The phone represents a password as a string of two lowercase English letters.
Mu-mu's enemy Kashtanka wants to unlock Mu-mu's phone to steal some sensible information, but it can only bark n distinct words, each of which can be represented as a string of two lowercase English letters. Kashtanka wants to bark several words (not necessarily distinct) one after another to pronounce a string containing the password as a substring. Tell if it's possible to unlock the phone in this way, or not.
Input
The first line contains two lowercase English letters — the password on the phone.
The second line contains single integer n (1 ≤ n ≤ 100) — the number of words Kashtanka knows.
The next n lines contain two lowercase English letters each, representing the words Kashtanka knows. The words are guaranteed to be distinct.
Output
Print "YES" if Kashtanka can bark several words in a line forming a string containing the password, and "NO" otherwise.
You can print each letter in arbitrary case (upper or lower).
Examples
Input
ya
4
ah
oy
to
ha
Output
YES
Input
hp
2
ht
tp
Output
NO
Input
ah
1
ha
Output
YES
Note
In the first example the password is "ya", and Kashtanka can bark "oy" and then "ah", and then "ha" to form the string "oyahha" which contains the password. So, the answer is "YES".
In the second example Kashtanka can't produce a string containing password as a substring. Note that it can bark "ht" and then "tp" producing "http", but it doesn't contain the password "hp" as a substring.
In the third example the string "hahahaha" contains "ah" as a substring. | from sys import stdin
def main():
password=raw_input()
n=input()
flag1=False
flag2=False
for i in xrange(n):
str=raw_input()
if str[0]==password[1]:
flag1=True
if str[1]==password[0]:
flag2=True
if flag1 and flag2 or str==password:
flag1=True
flag2=True
print "YES"
break
if flag1==False or flag2==False:
print "NO"
main()
|
Recenlty Luba got a credit card and started to use it. Let's consider n consecutive days Luba uses the card.
She starts with 0 money on her account.
In the evening of i-th day a transaction ai occurs. If ai > 0, then ai bourles are deposited to Luba's account. If ai < 0, then ai bourles are withdrawn. And if ai = 0, then the amount of money on Luba's account is checked.
In the morning of any of n days Luba can go to the bank and deposit any positive integer amount of burles to her account. But there is a limitation: the amount of money on the account can never exceed d.
It can happen that the amount of money goes greater than d by some transaction in the evening. In this case answer will be «-1».
Luba must not exceed this limit, and also she wants that every day her account is checked (the days when ai = 0) the amount of money on her account is non-negative. It takes a lot of time to go to the bank, so Luba wants to know the minimum number of days she needs to deposit some money to her account (if it is possible to meet all the requirements). Help her!
Input
The first line contains two integers n, d (1 ≤ n ≤ 105, 1 ≤ d ≤ 109) —the number of days and the money limitation.
The second line contains n integer numbers a1, a2, ... an ( - 104 ≤ ai ≤ 104), where ai represents the transaction in i-th day.
Output
Print -1 if Luba cannot deposit the money to her account in such a way that the requirements are met. Otherwise print the minimum number of days Luba has to deposit money.
Examples
Input
5 10
-1 5 0 -5 3
Output
0
Input
3 4
-10 0 20
Output
-1
Input
5 10
-5 0 10 -11 0
Output
2 | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class P893D
{
public static void main(String[] args)
{
FastScanner scan = new FastScanner();
int n = scan.nextInt();
int d = scan.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++)
arr[i] = scan.nextInt();
int dep = 0;
int lo = 0, hi = 0;
for (int i = 0; i < n; i++)
{
int p = arr[i];
if (p < 0)
{
lo += p;
hi += p;
}
else if (p > 0)
{
lo += p;
hi = Math.min(d, hi+p);
if (lo > d)
{
System.out.println(-1);
return;
}
}
else
{
if (hi >= 0) //Don't deposit
{
lo = Math.max(0, lo);
}
else //Deposit
{
dep++;
lo = 0;
hi = d;
}
}
}
System.out.println(dep);
}
static class FastScanner
{
BufferedReader br;
StringTokenizer st;
public FastScanner()
{
try
{
br = new BufferedReader(new InputStreamReader(System.in));
st = new StringTokenizer(br.readLine());
} catch (Exception e)
{
e.printStackTrace();
}
}
public String next()
{
if (st.hasMoreTokens())
return st.nextToken();
try
{
st = new StringTokenizer(br.readLine());
} catch (Exception e)
{
e.printStackTrace();
}
return st.nextToken();
}
public int nextInt()
{
return Integer.parseInt(next());
}
public long nextLong()
{
return Long.parseLong(next());
}
public String nextLine()
{
String line = "";
try
{
line = br.readLine();
} catch (Exception e)
{
e.printStackTrace();
}
return line;
}
}
}
|
Luba thinks about watering her garden. The garden can be represented as a segment of length k. Luba has got n buckets, the i-th bucket allows her to water some continuous subsegment of garden of length exactly ai each hour. Luba can't water any parts of the garden that were already watered, also she can't water the ground outside the garden.
Luba has to choose one of the buckets in order to water the garden as fast as possible (as mentioned above, each hour she will water some continuous subsegment of length ai if she chooses the i-th bucket). Help her to determine the minimum number of hours she has to spend watering the garden. It is guaranteed that Luba can always choose a bucket so it is possible water the garden.
See the examples for better understanding.
Input
The first line of input contains two integer numbers n and k (1 ≤ n, k ≤ 100) — the number of buckets and the length of the garden, respectively.
The second line of input contains n integer numbers ai (1 ≤ ai ≤ 100) — the length of the segment that can be watered by the i-th bucket in one hour.
It is guaranteed that there is at least one bucket such that it is possible to water the garden in integer number of hours using only this bucket.
Output
Print one integer number — the minimum number of hours required to water the garden.
Examples
Input
3 6
2 3 5
Output
2
Input
6 7
1 2 3 4 5 6
Output
7
Note
In the first test the best option is to choose the bucket that allows to water the segment of length 3. We can't choose the bucket that allows to water the segment of length 5 because then we can't water the whole garden.
In the second test we can choose only the bucket that allows us to water the segment of length 1. | def is_prime(a):
return all(a % i for i in range(2, a))
n, k = map(int, input().split())
l = [int(x) for x in input().split()]
if is_prime(k):
if k in l:
print(1)
else:
print(k)
else:
ll = []
for i in range(len(l)):
if k % l[i] == 0:
ll.append(l[i])
print(k // max(ll))
|
You and your friend are participating in a TV show "Run For Your Prize".
At the start of the show n prizes are located on a straight line. i-th prize is located at position ai. Positions of all prizes are distinct. You start at position 1, your friend — at position 106 (and there is no prize in any of these two positions). You have to work as a team and collect all prizes in minimum possible time, in any order.
You know that it takes exactly 1 second to move from position x to position x + 1 or x - 1, both for you and your friend. You also have trained enough to instantly pick up any prize, if its position is equal to your current position (and the same is true for your friend). Carrying prizes does not affect your speed (or your friend's speed) at all.
Now you may discuss your strategy with your friend and decide who will pick up each prize. Remember that every prize must be picked up, either by you or by your friend.
What is the minimum number of seconds it will take to pick up all the prizes?
Input
The first line contains one integer n (1 ≤ n ≤ 105) — the number of prizes.
The second line contains n integers a1, a2, ..., an (2 ≤ ai ≤ 106 - 1) — the positions of the prizes. No two prizes are located at the same position. Positions are given in ascending order.
Output
Print one integer — the minimum number of seconds it will take to collect all prizes.
Examples
Input
3
2 3 9
Output
8
Input
2
2 999995
Output
5
Note
In the first example you take all the prizes: take the first at 1, the second at 2 and the third at 8.
In the second example you take the first prize in 1 second and your friend takes the other in 5 seconds, you do this simultaneously, so the total time is 5. | input()
a=list(map(int,input().split()))
ans=0
for x in a:
z=min(x-1,1000000-x)
ans=max(z,ans)
print(ans)
|
You are given a tree (a graph with n vertices and n - 1 edges in which it's possible to reach any vertex from any other vertex using only its edges).
A vertex can be destroyed if this vertex has even degree. If you destroy a vertex, all edges connected to it are also deleted.
Destroy all vertices in the given tree or determine that it is impossible.
Input
The first line contains integer n (1 ≤ n ≤ 2·105) — number of vertices in a tree.
The second line contains n integers p1, p2, ..., pn (0 ≤ pi ≤ n). If pi ≠ 0 there is an edge between vertices i and pi. It is guaranteed that the given graph is a tree.
Output
If it's possible to destroy all vertices, print "YES" (without quotes), otherwise print "NO" (without quotes).
If it's possible to destroy all vertices, in the next n lines print the indices of the vertices in order you destroy them. If there are multiple correct answers, print any.
Examples
Input
5
0 1 2 1 2
Output
YES
1
2
3
5
4
Input
4
0 1 2 3
Output
NO
Note
In the first example at first you have to remove the vertex with index 1 (after that, the edges (1, 2) and (1, 4) are removed), then the vertex with index 2 (and edges (2, 3) and (2, 5) are removed). After that there are no edges in the tree, so you can remove remaining vertices in any order.
<image> | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.List;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author The Viet Nguyen
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
TaskB solver = new TaskB();
solver.solve(1, in, out);
out.close();
}
static class TaskB {
static final int N = (int) 2e5 + 1;
int n;
List<Integer>[] graph = new ArrayList[N];
int[] sz = new int[N];
int root;
OutputWriter out;
public void solve(int testNumber, InputReader in, OutputWriter out) {
this.out = out;
n = in.readInt();
for (int i = 1; i <= n; i++) graph[i] = new ArrayList<>();
for (int i = 1; i <= n; i++) {
int p = in.readInt();
if (p == 0) root = i;
else graph[p].add(i);
}
if (n % 2 == 0) {
out.printLine("NO");
return;
}
out.printLine("YES");
countEdges(root);
removeVertices(root);
}
void countEdges(int cur) {
sz[cur] = 1;
for (int nxt : graph[cur]) {
countEdges(nxt);
sz[cur] += sz[nxt];
}
}
void removeVertices(int cur) {
for (int nxt : graph[cur]) {
if (sz[nxt] % 2 == 0) {
removeVertices(nxt);
}
}
out.printLine(cur);
for (int nxt : graph[cur]) {
if (sz[nxt] % 2 != 0) {
removeVertices(nxt);
}
}
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private InputReader.SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public int readInt() {
return (int) readLong();
}
public long readLong() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}
public interface SpaceCharFilter {
boolean isSpaceChar(int ch);
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(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 printLine(Object... objects) {
print(objects);
writer.println();
}
public void close() {
writer.close();
}
public void printLine(int i) {
writer.println(i);
}
}
}
|
Adilbek's house is located on a street which can be represented as the OX axis. This street is really dark, so Adilbek wants to install some post lamps to illuminate it. Street has n positions to install lamps, they correspond to the integer numbers from 0 to n - 1 on the OX axis. However, some positions are blocked and no post lamp can be placed there.
There are post lamps of different types which differ only by their power. When placed in position x, post lamp of power l illuminates the segment [x; x + l]. The power of each post lamp is always a positive integer number.
The post lamp shop provides an infinite amount of lamps of each type from power 1 to power k. Though each customer is only allowed to order post lamps of exactly one type. Post lamps of power l cost a_l each.
What is the minimal total cost of the post lamps of exactly one type Adilbek can buy to illuminate the entire segment [0; n] of the street? If some lamps illuminate any other segment of the street, Adilbek does not care, so, for example, he may place a lamp of power 3 in position n - 1 (even though its illumination zone doesn't completely belong to segment [0; n]).
Input
The first line contains three integer numbers n, m and k (1 ≤ k ≤ n ≤ 10^6, 0 ≤ m ≤ n) — the length of the segment of the street Adilbek wants to illuminate, the number of the blocked positions and the maximum power of the post lamp available.
The second line contains m integer numbers s_1, s_2, ..., s_m (0 ≤ s_1 < s_2 < ... s_m < n) — the blocked positions.
The third line contains k integer numbers a_1, a_2, ..., a_k (1 ≤ a_i ≤ 10^6) — the costs of the post lamps.
Output
Print the minimal total cost of the post lamps of exactly one type Adilbek can buy to illuminate the entire segment [0; n] of the street.
If illumintaing the entire segment [0; n] is impossible, print -1.
Examples
Input
6 2 3
1 3
1 2 3
Output
6
Input
4 3 4
1 2 3
1 10 100 1000
Output
1000
Input
5 1 5
0
3 3 3 3 3
Output
-1
Input
7 4 3
2 4 5 6
3 14 15
Output
-1 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
const long long INF = 1e18 + 7;
int a[maxn];
int aa[maxn];
int pre[maxn];
int b[maxn];
int main() {
int i, j, m, n, t, z;
int k;
scanf("%d%d%d", &n, &m, &k);
for (i = 1; i <= m; i++) {
scanf("%d", &a[i]);
aa[a[i]] = 1;
}
for (i = 1; i <= k; i++) {
scanf("%d", &b[i]);
}
if (aa[0]) {
puts("-1");
return 0;
}
for (i = 0; i < n; i++) {
if (!aa[i]) {
pre[i] = i;
} else {
pre[i] = pre[i - 1];
}
}
long long ans = 1e18;
for (i = 1; i <= k; i++) {
long long tem = 0;
int cnt = 0;
while (cnt < n) {
if (cnt + i >= n) {
tem++;
cnt = n;
break;
}
if (pre[cnt + i] <= cnt) {
break;
} else {
cnt = pre[cnt + i];
tem++;
}
}
if (cnt == n) {
ans = min(ans, b[i] * tem);
}
}
if (ans != INF)
printf("%lld\n", ans);
else {
printf("-1\n");
}
return 0;
}
|
As you know Appu created aversion to Maths after that maths problem given by his teacher.So he stopped studying and began to do farming. He has some land where he starts growing sugarcane. At the end of the season he grew N sugarcanes. Is Appu satisfied??. No,
He wants all his sugar canes to be of the same height. He goes to the nearby market .He finds a powder which when applied to one of his sugarcanes will double the height of that sugar cane. Now he needs to find out whether is it possible to make all the sugarcanes of the same height . Oh No!! Again maths.
Please help him to find whether is it possible make all the sugar cane of the same height?
Input
First line contains N - the number of sugarcanes.Next N lines contains heights of sugarcanes seperated by space
Output
Print "YES" if it is possible make all the sugar cane of the same height or
"NO" otherwise (quotes only for clarity)
Constraints
1 ≤ N ≤ 50
Initial Height of all sugarcanes will be between 1 and 1,000,000,000, inclusive.
SAMPLE INPUT
2
1 23
SAMPLE OUTPUT
NO | '''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
num_of_sugarcanes = int(raw_input())
list_of_sugarcanes = map(int,raw_input().split())
max_of_sugarcanes = max(list_of_sugarcanes)
def xyz (list_of_sugarcanes, max_sugar):
for x in list_of_sugarcanes:
z = x
while z < max_sugar:
z *= 2
if z > max_sugar:
return "NO"
return "YES"
print (xyz(list_of_sugarcanes, max_of_sugarcanes)) |
In the previous problem Chandu bought some unsorted arrays and sorted them (in non-increasing order). Now, he has many sorted arrays to give to his girlfriend. But, the number of sorted arrays are very large so Chandu decided to merge two sorted arrays into one sorted array. But he is too lazy to do that. So, he asked your help to merge the two sorted arrays into one sorted array (in non-increasing order).
Input:
First line contains an integer T, denoting the number of test cases.
First line of each test case contains two space separated integers N and M, denoting the size of the two sorted arrays.
Second line of each test case contains N space separated integers, denoting the first sorted array A.
Third line of each test case contains M space separated integers, denoting the second array B.
Output:
For each test case, print (N + M) space separated integer representing the merged array.
Constraints:
1 ≤ T ≤ 100
1 ≤ N, M ≤ 5*10^4
0 ≤ Ai, Bi ≤ 10^9
SAMPLE INPUT
1
4 5
9 7 5 3
8 6 4 2 0
SAMPLE OUTPUT
9 8 7 6 5 4 3 2 0 | def merge(a,b):
c=[]
l1=len(a)
l2=len(b)
i=0
j=0
while i<l1 and j<l2:
if a[i]>b[j]:
c.append(a[i])
i+=1
else:
c.append(b[j])
j+=1
while i<l1:
c.append(a[i])
i+=1
while j<l2:
c.append(b[j])
j+=1
return c
for t in xrange(int(raw_input())):
n,m=map(int,raw_input().split())
a=map(int,raw_input().split())
b=map(int,raw_input().split())
c=merge(a,b)
for i in c:
print i,
print |
You are given an array A of size N, and Q queries to deal with. For each query, you are given an integer X, and you're supposed to find out if X is present in the array A or not.
Input:
The first line contains two integers, N and Q, denoting the size of array A and number of queries. The second line contains N space separated integers, denoting the array of elements Ai. The next Q lines contain a single integer X per line.
Output:
For each query, print YES if the X is in the array, otherwise print NO.
Constraints:
1 ≤ N, Q ≤ 10^5
1 ≤ Ai ≤ 10^9
1 ≤ X ≤ 10^9
SAMPLE INPUT
5 10
50 40 30 20 10
10
20
30
40
50
60
70
80
90
100
SAMPLE OUTPUT
YES
YES
YES
YES
YES
NO
NO
NO
NO
NO | '''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
line1 = raw_input()
arr_inp=[]
for j in line1.split(' '):
arr_inp.append(int(j))
line2 = raw_input()
elemnt_array = {}
for i in line2.split(' '):
elemnt_array[int(i)] = 1
#elemnt_array.sort()
#print elemnt_array, "and quries are", arr_inp[1]
for i in range (arr_inp[1]):
if int(input()) in elemnt_array:
print "YES"
else:
print "NO" |
Golu is given a task of clearing coins fallen down on floor. Naughty being his modus operandi, he thought of playing a game while clearing coins. He arranges the coins like an M X N matrix with random heads (1) and tails (0).
In every move, he chooses a sub-matrix of size L X B [such that max(L,B) >1] and interchanges all heads to tails and vice-versa present in the chosen sub-matrix. Then if he finds a 2X2 sub-matrix exclusively of heads anywhere in the M X N matrix, he removes those coins.
Your task is simple. You have to report the minimum no. of moves taken by him before he clears his first 2X2 sub-matrix.
Input:
Your first line of input consists of two numbers M, N. Each of the next M lines consists of N space-separated integers which are either 0 or 1.
Output:
Output a single line answer giving the minimum no. of steps taken before his first clearance. If it is impossible for him to do so, print "-1" (quotes for clarity).
Constraints :
2 ≤ M,N ≤ 10
Author : Srinivas
Testers : Shubham Parekh , Shreyans
(By IIT Kgp HackerEarth Programming Club)
SAMPLE INPUT
2 4
0 0 1 1
0 0 1 1
SAMPLE OUTPUT
0 | M,N=map(int,raw_input().split())
L=[]
for i in range(M):
L.append(map(int,raw_input().split()))
if M+N==4 and (L==[[0,1],[1,1]] or L==[[1,0],[1,1]] or L==[[1,1],[1,0]] or L==[[1,1],[0,1]]) or L==[[1,0],[0,0]] or L==[[0,1],[0,0]] or L==[[0,0],[1,0]] or L==[[0,0],[0,1]]:
print "-1"
else:
List=[]
for i in range(M-1):
for j in range(N-1):
List.append(([L[i][j],L[i][j+1],L[i+1][j],L[i+1][j+1]],[j!=0,j+2!=N,i!=0,i+2!=M])) #L,R,T,B
zero=False
one=False
for i in List:
if i[0]==[1,1,1,1]:
zero=True
print "0"
break
elif i[0]==[0,0,0,0] or i[0]==[1,0,1,0] or i[0]==[1,1,0,0] or i[0]==[0,1,0,1] or i[0]==[0,0,1,1] or (i[0]==[0,1,1,1] and (i[1][0] or i[1][2])) or (i[0]==[1,0,1,1] and (i[1][1] or i[1][2])) or (i[0]==[1,1,0,1] and (i[1][0] or i[1][3])) or (i[0]==[1,1,1,0] and (i[1][1] or i[1][3])):
one=True
if (not zero):
if (one):
print "1"
else:
print "2" |
A certain business maintains a list of all its customers' names. The list is arranged in order of importance, with the last customer in the list being the most important. Now, he want to create a new list sorted alphabetically according to customers' last names, but among customers with the same last name he want the more important ones to appear earlier in the new list. Alphabetical order (and equality of last names) should not be case sensitive.
Input:-
First line contains no. of test cases and first line of each test case contains n i.e. no. of elements and next n lines contains contains a name.
Output:- Print the new list with each element in a new line.
SAMPLE INPUT
2
5
Tom Jones
ADAMS
BOB ADAMS
Tom Jones
STEVE jONeS
3
Trudy
Trudy
TRUDY
SAMPLE OUTPUT
BOB ADAMS
ADAMS
STEVE jONeS
Tom Jones
Tom Jones
TRUDY
Trudy
Trudy | '''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
def fun(l):
a=[]
b=l[::-1]
for j in range(len(b)):
s=b[j].split(" ")
if(len(s)>=2):
a.append([s[-1].lower(),j])
else:
a.append([s[0].lower(),j])
a.sort(key=lambda tup: tup[0])
# print(a)
for i in a:
print(b[i[1]])
t=int(raw_input())
for u in range(t):
n=int(raw_input())
l=[]
for i in range(n):
l.append(raw_input())
fun(l) |
Monk loves cakes! He visits the Binary Bakery to buy some of his favorite cheesecakes.
The owner of the bakery, Bob, is a clever man. He does not want Monk to finish all his cheesecakes. Hence, he plays a game.
The Monk is given N numbers and has to select K of these numbers. For each number that Monk chooses, he will get as many cheesecakes as the number of 1's in the Binary representation of the number i.e. the number of bits that are set.
Help Monk find the maximum number of cakes that he can have.
Input:
The first line of input contains T. T test cases follow.
First line of each test cases contains 2 space-separated integers N and K.
The next line contains N space-separated integers.
Output:
For each test cases, print the answer in a new line.
Constraints:
1 ≤ T ≤ 10
1 ≤ N ≤ 10^3
0 ≤ K ≤ N
0 ≤ Numbers ≤ 10^5
SAMPLE INPUT
1
4 2
6 1 2 0
SAMPLE OUTPUT
3
Explanation
He chooses numbers 6 (110) and 1 (001) with 2 and 1 set bits respectively. | def count(num):
tmp=num
cnt=0
while(tmp!=0):
if tmp & 1 == 1:
cnt=cnt+1
tmp=tmp >> 1
#print cnt
return cnt
T=int(raw_input())
for i in xrange(T):
N,K=map(int,raw_input().split())
Nums=raw_input().split()
NumsList=map(int,Nums)
l=len(NumsList)
cntList=list()
for j in xrange(l):
cntList.append(count(NumsList[j]))
cntList.sort()
#print cntList
j=0
s=0
while j < K :
s=s+cntList[l-1-j]
j=j+1
print s |
Description
You are given two strings S and T, such that length of S is greater than the length of T.
Then a substring of S is defined as a sequence of characters which appear consecutively in S.
Find the total number of distinct substrings of M such that T is a substring of M
Input Format
One line containing strings S and T separated by a space.
Output Format
One line containing the number of distinct substrings of M such that T is a substring of M
Input Limits:
0 < Length(S), Length(T) < 100
SAMPLE INPUT
abcc c
SAMPLE OUTPUT
6
Explanation
Suppose the string S is abcc. Then the distinct substrings of S are
a, b, c, ab, bc, cc, abc, bcc, abcc | a,b=raw_input().split()
ans=[]
i=0
while i<len(a):
j=i
while j<len(a):
t=a[i:j+1]
if b in t:
if t not in ans:
ans.append(t)
j+=1
i+=1
print len(ans) |
Roy is going through the dark times of his life. Recently his girl friend broke up with him and to overcome the pain of acute misery he decided to restrict himself to Eat-Sleep-Code life cycle. For N days he did nothing but eat, sleep and code.
A close friend of Roy kept an eye on him for last N days. For every single minute of the day, he kept track of Roy's actions and prepared a log file.
The log file contains exactly N lines, each line contains a string of length 1440 ( i.e. number of minutes in 24 hours of the day).
The string is made of characters E, S, and C only; representing Eat, Sleep and Code respectively. i^th character of the string represents what Roy was doing during i^th minute of the day.
Roy's friend is now interested in finding out the maximum of longest coding streak of the day - X.
He also wants to find the longest coding streak of N days - Y.
Coding streak means number of C's without any E or S in between.
See sample test case for clarification.
Input:
First line of each file contains N - number of days.
Following N lines contains a string of exactly 1440 length representing his activity on that day.
Output:
Print X and Y separated by a space in a single line.
Constraints:
1 ≤ N ≤ 365
String consists of characters E, S, and C only.
String length is exactly 1440.
Note: The sample test case does not follow the given constraints on string length to avoid large data. It is meant only for explanation. We assure you that the hidden test files strictly follow the constraints.
SAMPLE INPUT
4
SSSSEEEECCCCEECCCC
CCCCCSSSSEEECCCCSS
SSSSSEEESSCCCCCCCS
EESSSSCCCCCCSSEEEESAMPLE OUTPUT
7 9Explanation
Longest coding streak for each day is as follows:
Day 1: 4
Day 2: 5
Day 3: 7
Day 4: 6
Maximum of these is 7, hence X is 7.
Now in order to find longest coding streak of the all days, we should also check if Roy continued his coding from previous days.
As in the sample test case, Roy was coding for 4 minutes at the end of Day 1 and he continued to code till 5 more minutes on Day 2. Hence the longest coding streak is 4+5 equals 9. There is no any other coding streak larger than this. So the longest coding streak of all days is 9. | def main():
n = int(raw_input())
strings = []
string_streak = 0
total_streak = 0
for i in range(n):
temp_string = raw_input()
strings.append(temp_string)
for string in strings:
temp_string_streak = 0
temp_streak = 0
for char in string:
if char == "E" or char == "S":
if temp_streak > temp_string_streak:
temp_string_streak = temp_streak
temp_streak = 0
if char == "C":
temp_streak += 1
if temp_streak > temp_string_streak:
temp_string_streak = temp_streak
if temp_string_streak > string_streak:
string_streak = temp_string_streak
total_string = ""
for string in strings:
total_string += string
temp_streak = 0
for char in total_string:
if char == "E" or char == "S":
if temp_streak > total_streak:
total_streak = temp_streak
temp_streak = 0
if char == "C":
temp_streak += 1
if temp_streak > total_streak:
total_streak = temp_streak
print str(string_streak) + " " + str(total_streak)
if __name__ == "__main__":
main() |
Problem:
Rani and Nandu decide to play a number game. Both play alternately, Rani playing the first move.
In each of their moves, they can subtract a maximum of k and a minimun of 1 from n ( ie.each of them must subtract from n, any natural number less than or equal to k) , and the new value of n will be the result of this subtraction.
They continue playing this game until the value of n becomes zero or negative. The person to play the last move loses the game.
Both are super-intelligent and hence both play optimally. Given the values of n and k, find out the winner of the game.
Note : Large Input/Output Data. Use fast I/O.
Input:
First line consists of t, the number of test case. The next t lines are such that each line consists of two space separated integers n and k.
Output:
Print the answer to each test case on a new line, 'Rani' if the winner of the game is Rani and 'Nandu' if the winner of the game is Nandu.
Constraints:
1 ≤ t ≤ 1000000
1 ≤ n ≤ 1000000.
1 ≤ k ≤ n.
Problem Setter : Shreyans
Problem Tester : Sandeep
(By IIT Kgp HackerEarth Programming Club)
SAMPLE INPUT
2
2 1
3 2
SAMPLE OUTPUT
Rani
Rani
Explanation
For n=2 and k=1
1st move Rani : n = 2 - 1 = 1
2nd move Nandu : n = 1 - 1 = 0.
Now, n has become zero. So, the game is over. Since Nandu palyed the last move, he loses the game. So,
the winner of the game is Rani.
For n=3 and k=2
1st move Rani : n = 3 - 2 = 1
2nd move Nandu : n = 1 - 1 = 0 or n = 1 - 2 = -1.
Now, n has become zero/negative. So, the game is over. Since Nandu palyed the last move, he loses the
game. So, the winner of the game is Rani. | for _ in xrange(input()):
flag=True
n,k=map(int,raw_input().split())
print "Nandu" if not (n-1)%(k+1) else "Rani" |
Rakesh have learn about vowel in school and is given an assignment by his teacher in which he has to list all vowel together from the word's given to him,but he is busy in watching cricket match and want your help to solve the assignment.
5 vowel (a,e,i,o,u) and you should also take care of uppercase vowel (A,E,I,O,U)
INPUT
T testcase ( 1< t <10 )
then there will be T words
OUTPUT
List of all vowel present in the word
All vowel should be listed as they are found in the word
In case if there is no vowel you have to print "No"
SAMPLE INPUT
3
SdfgAe
Out
Get
SAMPLE OUTPUT
Ae
Ou
e
Explanation
Here Testcase T value is 3
(T=3) which mean there will be three word to check for.
INPUT
3
SdfgAe
Out
Get
OUTPUT
Ae
Ou
e
Here in output order of vowels is same as they occur in word | b="AEIOUaeiou"
t=input()
while t:
t-=1
c=""
a=raw_input()
for x in a:
if x in b:
c+=x
if (c==""):
print "No"
else:
print c |
Takahashi is participating in a programming contest called AXC002, and he has just submitted his code to Problem A.
The problem has N test cases.
For each test case i (1\leq i \leq N), you are given a string S_i representing the verdict for that test case. Find the numbers of test cases for which the verdict is `AC`, `WA`, `TLE`, and `RE`, respectively.
See the Output section for the output format.
Constraints
* 1 \leq N \leq 10^5
* S_i is `AC`, `WA`, `TLE`, or `RE`.
Input
Input is given from Standard Input in the following format:
N
S_1
\vdots
S_N
Output
Let C_0, C_1, C_2, and C_3 be the numbers of test cases for which the verdict is `AC`, `WA`, `TLE`, and `RE`, respectively. Print the following:
AC x C_0
WA x C_1
TLE x C_2
RE x C_3
Output
Let C_0, C_1, C_2, and C_3 be the numbers of test cases for which the verdict is `AC`, `WA`, `TLE`, and `RE`, respectively. Print the following:
AC x C_0
WA x C_1
TLE x C_2
RE x C_3
Examples
Input
6
AC
TLE
AC
AC
WA
TLE
Output
AC x 3
WA x 1
TLE x 2
RE x 0
Input
10
AC
AC
AC
AC
AC
AC
AC
AC
AC
AC
Output
AC x 10
WA x 0
TLE x 0
RE x 0 | #include <bits/stdc++.h>
using namespace std;
int n,cnt[30];
char S[5];
int main()
{
scanf("%d",&n);
for (int i=1;i<=n;i++)
{
scanf("%s",S);
cnt[S[0]-65]++;
}
printf("AC x %d\n",cnt[0]);
printf("WA x %d\n",cnt['W'-65]);
printf("TLE x %d\n",cnt['T'-65]);
printf("RE x %d\n",cnt['R'-65]);
return 0;
}
|
In this problem, we only consider strings consisting of lowercase English letters.
Strings s and t are said to be isomorphic when the following conditions are satisfied:
* |s| = |t| holds.
* For every pair i, j, one of the following holds:
* s_i = s_j and t_i = t_j.
* s_i \neq s_j and t_i \neq t_j.
For example, `abcac` and `zyxzx` are isomorphic, while `abcac` and `ppppp` are not.
A string s is said to be in normal form when the following condition is satisfied:
* For every string t that is isomorphic to s, s \leq t holds. Here \leq denotes lexicographic comparison.
For example, `abcac` is in normal form, but `zyxzx` is not since it is isomorphic to `abcac`, which is lexicographically smaller than `zyxzx`.
You are given an integer N. Print all strings of length N that are in normal form, in lexicographically ascending order.
Constraints
* 1 \leq N \leq 10
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Examples
Input
1
Output
a
Input
2
Output
aa
ab | import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N = scanner.nextInt();
List<StringBuilder> list = rec('a', 'a', N - 1);
for (StringBuilder sb : list) {
System.out.println(sb.toString());
}
}
private static List<StringBuilder> rec(char ch, char max, int remain) {
List<StringBuilder> res = new ArrayList<>();
if (remain == 0) {
res.add(new StringBuilder().append(ch));
return res;
}
if (max < ch + 1) max = (char) (ch + 1);
for (char c = 'a'; c <= max; c++) {
List<StringBuilder> list = rec(c, max, remain - 1);
for (StringBuilder sb : list) {
StringBuilder sb2 = new StringBuilder().append(ch);
sb2.append(sb);
res.add(sb2);
}
}
return res;
}
}
|
Having learned the multiplication table, Takahashi can multiply two integers between 1 and 9 (inclusive) together. He cannot do any other calculation.
Given are two integers A and B.
If Takahashi can calculate A \times B, print the result; if he cannot, print `-1` instead.
Constraints
* 1 \leq A \leq 20
* 1 \leq B \leq 20
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B
Output
If Takahashi can calculate A \times B, print the result; if he cannot, print `-1`.
Examples
Input
2 5
Output
10
Input
5 10
Output
-1
Input
9 9
Output
81 | import java.util.*;
class Main{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
int a = scan.nextInt();
int b = scan.nextInt();
if(a>=1&&a<=9&&b>=1&&b<=9){
System.out.println(a*b);
}else{
System.out.println(-1);
}
}
}
|
There is a staircase with N steps. Takahashi is now standing at the foot of the stairs, that is, on the 0-th step. He can climb up one or two steps at a time.
However, the treads of the a_1-th, a_2-th, a_3-th, \ldots, a_M-th steps are broken, so it is dangerous to set foot on those steps.
How many are there to climb up to the top step, that is, the N-th step, without setting foot on the broken steps? Find the count modulo 1\ 000\ 000\ 007.
Constraints
* 1 \leq N \leq 10^5
* 0 \leq M \leq N-1
* 1 \leq a_1 < a_2 < ... < a_M \leq N-1
Input
Input is given from Standard Input in the following format:
N M
a_1
a_2
.
.
.
a_M
Output
Print the number of ways to climb up the stairs under the condition, modulo 1\ 000\ 000\ 007.
Examples
Input
6 1
3
Output
4
Input
10 2
4
5
Output
0
Input
100 5
1
23
45
67
89
Output
608200469 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll N,M,a,MOD=1e9+7;
cin >> N >> M;
vector<ll> X(N+5,0);
for(int i=0;i<M;i++){
cin >> a;
X[a]=-1;
}
X[0] = 1;
if(X[1]!=-1)X[1] = 1;
for(int i=2;i<N+1;i++){
if(X[i]==-1)continue;
X[i] = ( (X[i-1]!=-1)*X[i-1] + (X[i-2]!=-1)*X[i-2] ) % MOD;
}
cout << X[N] << endl;
} |
There are N cities in Republic of AtCoder. The size of the i-th city is A_{i}. Takahashi would like to build N-1 bidirectional roads connecting two cities so that any city can be reached from any other city by using these roads.
Assume that the cost of building a road connecting the i-th city and the j-th city is |i-j| \times D + A_{i} + A_{j}. For Takahashi, find the minimum possible total cost to achieve the objective.
Constraints
* 1 \leq N \leq 2 \times 10^5
* 1 \leq D \leq 10^9
* 1 \leq A_{i} \leq 10^9
* A_{i} and D are integers.
Input
Input is given from Standard Input in the following format:
N D
A_1 A_2 ... A_N
Output
Print the minimum possible total cost.
Examples
Input
3 1
1 100 1
Output
106
Input
3 1000
1 100 1
Output
2202
Input
6 14
25 171 7 1 17 162
Output
497
Input
12 5
43 94 27 3 69 99 56 25 8 15 46 8
Output
658 | #include<bits/stdc++.h>
#define ll long long
using namespace std;
struct node
{
int u,v;
ll w;
bool operator<(const node &o)const{return w<o.w;}
}e[6000005];
int n,cot=0,a[200005],fail[200005];
ll d;
void add(int l,int r)
{
if(l>=r) return;
int m=l+r>>1;
ll mi=1e18,pos;
for(int i=l;i<=m;i++)
{
ll f=a[i]-d*i;
if(f<mi) mi=f,pos=i;
}
for(int i=m+1;i<=r;i++)
e[cot].u=pos,e[cot].v=i,e[cot++].w=a[i]+a[pos]+d*(i-pos);
mi=1e18;
for(int i=m+1;i<=r;i++)
{
ll f=a[i]+d*i;
if(f<mi) mi=f,pos=i;
}
for(int i=l;i<=m;i++)
e[cot].u=i,e[cot].v=pos,e[cot++].w=a[i]+a[pos]+d*(pos-i);
add(l,m);add(m+1,r);
}
int get_fa(int x)
{
return fail[x]==x?x:fail[x]=get_fa(fail[x]);
}
ll kruskal()
{
sort(e,e+cot);
for(int i=1;i<=200000;i++) fail[i]=i;
ll ans=0;
for(int i=0;i<cot;i++)
{
int fu=get_fa(e[i].u),fv=get_fa(e[i].v);
if(fu==fv) continue;
fail[fu]=fv;
ans+=e[i].w;
}
return ans;
}
int main()
{
scanf("%d%lld",&n,&d);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
add(1,n);
printf("%lld\n",kruskal());
}
|
Ringo Mart, a convenience store, sells apple juice.
On the opening day of Ringo Mart, there were A cans of juice in stock in the morning. Snuke buys B cans of juice here every day in the daytime. Then, the manager checks the number of cans of juice remaining in stock every night. If there are C or less cans, D new cans will be added to the stock by the next morning.
Determine if Snuke can buy juice indefinitely, that is, there is always B or more cans of juice in stock when he attempts to buy them. Nobody besides Snuke buy juice at this store.
Note that each test case in this problem consists of T queries.
Constraints
* 1 \leq T \leq 300
* 1 \leq A, B, C, D \leq 10^{18}
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
T
A_1 B_1 C_1 D_1
A_2 B_2 C_2 D_2
:
A_T B_T C_T D_T
In the i-th query, A = A_i, B = B_i, C = C_i, D = D_i.
Output
Print T lines. The i-th line should contain `Yes` if Snuke can buy apple juice indefinitely in the i-th query; `No` otherwise.
Examples
Input
14
9 7 5 9
9 7 6 9
14 10 7 12
14 10 8 12
14 10 9 12
14 10 7 11
14 10 8 11
14 10 9 11
9 10 5 10
10 10 5 10
11 10 5 10
16 10 5 10
1000000000000000000 17 14 999999999999999985
1000000000000000000 17 15 999999999999999985
Output
No
Yes
No
Yes
Yes
No
No
Yes
No
Yes
Yes
No
No
Yes
Input
24
1 2 3 4
1 2 4 3
1 3 2 4
1 3 4 2
1 4 2 3
1 4 3 2
2 1 3 4
2 1 4 3
2 3 1 4
2 3 4 1
2 4 1 3
2 4 3 1
3 1 2 4
3 1 4 2
3 2 1 4
3 2 4 1
3 4 1 2
3 4 2 1
4 1 2 3
4 1 3 2
4 2 1 3
4 2 3 1
4 3 1 2
4 3 2 1
Output
No
No
No
No
No
No
Yes
Yes
No
No
No
No
Yes
Yes
Yes
No
No
No
Yes
Yes
Yes
No
No
No | from fractions import gcd
T=input()
def check(a,b,c,d):
a-=b
if a<0: return 0
if d<b: return 0
if d>=b:
if c>=b-1: return 1
else:
d=gcd(b,d)
a%=d
l=c+d-a
r=b+d-a-1
# print l,r,d
if l/d<r/d:
return 0
else:
return 1
# l<=a + t * d<=r
for i in xrange(T):
a,b,c,d=map(int,raw_input().split())
if check(a,b,c,d):
print "Yes"
else:
print "No" |
AtCoDeer the deer found two positive integers, a and b. Determine whether the product of a and b is even or odd.
Constraints
* 1 ≤ a,b ≤ 10000
* a and b are integers.
Input
Input is given from Standard Input in the following format:
a b
Output
If the product is odd, print `Odd`; if it is even, print `Even`.
Examples
Input
3 4
Output
Even
Input
1 21
Output
Odd | #include <bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
if((a*b)%2==0)cout<<"Even";
else cout<<"Odd";
return 0;
}
|
We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand. When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.
The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second. When the upper bulb no longer contains any sand, nothing happens.
Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).
We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.
You are given Q queries. Each query is in the form of (t_i,a_i). For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.
Constraints
* 1≤X≤10^9
* 1≤K≤10^5
* 1≤r_1<r_2< .. <r_K≤10^9
* 1≤Q≤10^5
* 0≤t_1<t_2< .. <t_Q≤10^9
* 0≤a_i≤X (1≤i≤Q)
* All input values are integers.
Input
The input is given from Standard Input in the following format:
X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q
Output
For each query, print the answer in its own line.
Examples
Input
180
3
60 120 180
3
30 90
61 1
180 180
Output
60
1
120
Input
100
1
100000
4
0 100
90 100
100 100
101 100
Output
100
10
0
0
Input
100
5
48 141 231 314 425
7
0 19
50 98
143 30
231 55
342 0
365 100
600 10
Output
19
52
91
10
58
42
100 | #include <bits/stdc++.h>
using namespace std;
#define MAX 100007
int r[MAX];
int a[MAX];
int b[MAX];
int k1[MAX];
int main(){
int x,k,q;
cin >> x >> k;
for(int i=1; i<=k; i++)cin >> r[i];
r[k+1]=INT_MAX;
a[0]=0;
b[0]=x;
k1[0]=1;
// printf("%d %d %d\n",a[0],b[0],k1[0]);
for(int i=1; i<=k; i++){
int dt=r[i]-r[i-1];
if(i&1){
a[i]=max(a[i-1]-dt,0);
b[i]=max(b[i-1]-dt,0);
if(a[i]==b[i])k1[i]=(x+1);
else k1[i]=min(k1[i-1]+max(dt-a[i-1],0),x);
}
else{
a[i]=min(a[i-1]+dt,x);
b[i]=min(b[i-1]+dt,x);
if(a[i]==b[i])k1[i]=(x+1);
else k1[i]=max(k1[i-1]-max(dt-x+a[i-1]+1,0),0);
}
// printf("%d %d %d\n",a[i],b[i],k1[i]);
}
cin >> q;
for(int i=1; i<=q; i++){
int tq, aq;
cin >> tq >> aq;
if(tq==0){cout << aq << endl; continue;}
int p=lower_bound(r,r+k+2,tq)-r-1;
int dt=tq-r[p];
int res=min(a[p]+max(aq-k1[p]+1,0),b[p]);
// cout << dt << " " << res << " ";
res= (p&1) ? min(res+dt,x) :max(res-dt,0);
// cout << p << " " << res << endl;
cout << res << endl;
}
} |
There are N students and M checkpoints on the xy-plane.
The coordinates of the i-th student (1 \leq i \leq N) is (a_i,b_i), and the coordinates of the checkpoint numbered j (1 \leq j \leq M) is (c_j,d_j).
When the teacher gives a signal, each student has to go to the nearest checkpoint measured in Manhattan distance.
The Manhattan distance between two points (x_1,y_1) and (x_2,y_2) is |x_1-x_2|+|y_1-y_2|.
Here, |x| denotes the absolute value of x.
If there are multiple nearest checkpoints for a student, he/she will select the checkpoint with the smallest index.
Which checkpoint will each student go to?
Constraints
* 1 \leq N,M \leq 50
* -10^8 \leq a_i,b_i,c_j,d_j \leq 10^8
* All input values are integers.
Input
The input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_N b_N
c_1 d_1
:
c_M d_M
Output
Print N lines.
The i-th line (1 \leq i \leq N) should contain the index of the checkpoint for the i-th student to go.
Examples
Input
2 2
2 0
0 0
-1 0
1 0
Output
2
1
Input
3 4
10 10
-10 -10
3 3
1 2
2 3
3 5
3 5
Output
3
1
2
Input
5 5
-100000000 -100000000
-100000000 100000000
100000000 -100000000
100000000 100000000
0 0
0 0
100000000 100000000
100000000 -100000000
-100000000 100000000
-100000000 -100000000
Output
5
4
3
2
1 | import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = Integer.parseInt(sc.next());
int m = Integer.parseInt(sc.next());
int[] ax = new int[n];
int[] ay = new int[n];
int[] bx = new int[m];
int[] by = new int[m];
for(int i = 0; i<n; i++) {
ax[i] = Integer.parseInt(sc.next());
ay[i] = Integer.parseInt(sc.next());
}
for(int i = 0; i<m; i++) {
bx[i] = Integer.parseInt(sc.next());
by[i] = Integer.parseInt(sc.next());
}
int min = Integer.MAX_VALUE;
int minI = 0;
for(int i = 0; i<n; i++) {
min= Integer.MAX_VALUE;
for(int j = 0; j<m; j++) {
int manhattan = (int)Math.abs(ax[i]-bx[j]) + (int)Math.abs(ay[i]-by[j]);
if(manhattan < min ) {
min = manhattan;
minI = j+1;
}
}
System.out.println(minI);
}
}
} |
Two students of AtCoder Kindergarten are fighting over candy packs.
There are three candy packs, each of which contains a, b, and c candies, respectively.
Teacher Evi is trying to distribute the packs between the two students so that each student gets the same number of candies. Determine whether it is possible.
Note that Evi cannot take candies out of the packs, and the whole contents of each pack must be given to one of the students.
Constraints
* 1 ≦ a, b, c ≦ 100
Input
The input is given from Standard Input in the following format:
a b c
Output
If it is possible to distribute the packs so that each student gets the same number of candies, print `Yes`. Otherwise, print `No`.
Examples
Input
10 30 20
Output
Yes
Input
30 30 100
Output
No
Input
56 25 31
Output
Yes | l=sorted(list(map(int,input().split())))
print("Yes" if l[0]+l[1]==l[2] else "No") |
4 different points on the plane Read the coordinates of $ A (x_a, y_a) $, $ B (x_b, y_b) $, $ C (x_c, y_c) $, $ D (x_d, y_d) $ and read those 4 points Create a program that outputs YES if there is no dent in the quadrangle $ ABCD $ with the coordinates as the vertices, and NO if there is a dent.
A quadrangle with a dent is a quadrangle as shown in Figure 1.
<image>
Input
Given multiple datasets. The format of each dataset is as follows.
$ x_a $, $ y_a $, $ x_b $, $ y_b $, $ x_c $, $ y_c $, $ x_d $, $ y_d $
$ x_a $, $ y_a $, $ x_b $, $ y_b $, $ x_c $, $ y_c $, $ x_d $, $ y_d $ are -100 or more and 100 or less, respectively, and are given as real numbers.
1 No more than two points can be lined up on a straight line. Also, if you connect the points in the order of input, the coordinates of the points will be input in the order of forming a quadrangle. (That is, the points are not given in the order shown in Figure 2.)
The number of datasets does not exceed 100.
Output
Print YES or NO on one line for each dataset.
Example
Input
0.0,0.0,1.0,0.0,1.0,1.0,0.0,1.0
0.0,0.0,3.0,0.0,1.0,1.0,1.0,3.0
Output
YES
NO | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String[] s = sc.next().split(",");
double[] x = new double[6];
double[] y = new double[6];
for(int i=0;i<6;i++){
if(i<4){
x[i] = Double.valueOf(s[2*i]);
y[i] = Double.valueOf(s[2*i+1]);
}else{
x[i] = x[i-4];
y[i] = y[i-4];
}
}
boolean flag = true;
double x1, y1, x2, y2;
double res = 0;
for(int i=0;i<4;i++){
x1 = x[i+1]-x[i];
y1 = y[i+1]-y[i];
x2 = x[i+2]-x[i];
y2 = y[i+2]-y[i];
if(i==0){
res = x1*y2-x2*y1;
}else if(res*(x1*y2-x2*y1)<0){
flag = false;
break;
}
}
if(flag==true) System.out.println("YES");
else System.out.println("NO");
}
}
} |
Sorting algorithms for sorting data are basic algorithms indispensable in computer science. For example, as shown in the figure below, the operation of "sorting the elements of an array of integer values in ascending order" is alignment.
<image>
Many alignment algorithms have been devised, but one of the basic algorithms is bubble sort. As an example, let's arrange an array of given integer values in ascending order by bubble sort.
<image>
In bubble sort, each calculation step divides the array into "sorted parts" and "unsorted parts". Initially, the entire array will be the unsorted part.
From the beginning of the unsorted part, compare the adjacent elements (green element in the figure) and swap them so that the larger value is to the right. If the two values are equal, they will not be exchanged.
<image>
Repeat this process until the end of the unsorted part (white element in the figure). Finally, add the end to the sorted part (blue element in the figure) to complete one step.
Repeat this step until the unsorted part has a length of 1.
<image>
<image>
<image>
When the length of the unsorted part becomes 1, the sorting process ends.
Now, let's create a program that takes an array of n numbers as input, sorts the numbers in ascending order from the beginning of the array by the above bubble sort procedure, and outputs the number of exchanges of the required array elements. Please give me.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
a1
a2
::
an
The first line gives the number n (1 ≤ n ≤ 100), and the following n lines give the i-th number ai (1 ≤ ai ≤ 1000000).
The number of datasets does not exceed 20.
Output
Outputs the number of data element exchanges (integer) for each data set on one line.
Example
Input
5
5
3
2
1
4
6
1
2
3
4
5
6
3
3
2
1
0
Output
7
0
3 | def bubble_sort(A, N):
flag = True
c = 0
i = 0
while flag:
flag = False
for j in range(N-1, i, -1):
if A[j] < A[j-1]:
A[j], A[j-1] = A[j-1], A[j]
c += 1
flag = True
i += 1
return c
while True:
N = int(raw_input())
if N == 0:
break
A = [int(raw_input()) for _ in xrange(N)]
print bubble_sort(A, N) |
PCK, which recycles Aizu's precious metal, Aizunium, has a network all over the country and collects Aizunium with many collection vehicles. This company standardizes the unit of weight and number of lumps for efficient processing.
A unit called "bokko" is used for the weight of the lump. x Bocco's Aidunium weighs 2 x grams. If you compare it to a jewel, it's like a "carat." In addition, the unit called "Marugu" is used for the number of lumps. y Marg is 2y. It's like a "dozen" of items in a box. However, x and y must be integers greater than or equal to 0.
Recovery vehicle i collects ai bocco-weighted aidunium by bi-margue. The collected edunium is put into a furnace and melted to regenerate some lumps of edunium, but try to reduce the number of lumps of edunium as much as possible. At this time, the total weight of the collected Izunium and the total weight of the regenerated Izunium do not change.
Create a program that finds the result that minimizes the number of regenerated Izunium lumps given the weight of the Izunium lumps collected by the recovery vehicle in Bocco units and the number of Marg units.
Input
The input is given in the following format.
N
a1 b1
a2 b2
::
aN bN
The first line gives the number of recovery vehicles N (1 ≤ N ≤ 100000). In the next N lines, the integer ai (0 ≤ ai ≤ 100000) representing the weight in "Bocco" units and the integer bi (0 ≤ bi ≤) representing the number in "Margue" units of the mass of Aidunium collected by the recovery vehicle i. 100000) is given.
Output
The weight in Bocco units and the number in Marg units are output in ascending order of weight so that the number of lumps of Izunium obtained after regeneration is minimized.
Examples
Input
3
2 1
1 3
2 2
Output
3 0
5 0
Input
1
100000 2
Output
100002 0 | #include <iostream>
#include <algorithm>
#include <array>
#include <math.h>
#include <set>
#include <stdlib.h>
#include <string>
#include <vector>
#define INT_MAX 2000000000
#define INF 1000000000
#define MOD 1000000007
#define ll long long
#define rep(i,a,b) for(i = (a); i < (b); i++)
#define bitget(a,b) (((a) >> (b)) & 1)
using namespace std;
int i, j, k;
int main() {
int n;
int a[100000], b[100000];
cin >> n;
rep(i, 0, n)
cin >> a[i] >> b[i];
int c[100000] = {};
int d[100000] = {};
rep(i, 0, n)
d[i] = a[i] + b[i];
sort(d, d + n);
rep(i, 0, n) {
c[d[i] / 31] += (1 << (d[i] % 31));
if (c[d[i]/31] < 0) {
c[d[i]/31] = c[d[i]/31] & 2147483647;
c[d[i]/31+ 1] += 1;
}
}
rep(i, 0, 1000000) {
if (bitget(c[i / 31], i % 31) == 1) {
cout << i << " " << "0" << endl;
}
}
return 0;
} |
problem
If you write a positive integer in decimal notation (without leading 0) and look at the digit numbers in order, when the number increases and decreases alternately, the number is "zigza". Let's call it. For example, 2947 is a zigzag number because the digit numbers are in the order of 2 → 9 → 4 → 7 and increase → decrease → increase. In addition, 71946 is a zigzag number because it is in the order of decrease → increase → decrease → increase. On the other hand, 123, 71446, 71442 and 88 are not zigzag numbers. A one-digit positive integer is considered to be a zigzag number.
Create a program that finds the remainder of the number of zigzags divided by 10000 out of multiples of M between A and B.
input
The input consists of three lines, with one positive integer written on each line.
The integer on the first line represents A, the integer on the second line represents B, and the integer on the third line represents M. These satisfy 1 ≤ A ≤ B ≤ 10500 and 1 ≤ M ≤ 500.
* Note that the values of A and B may not fit in the data types that represent ordinary integers.
output
Output the remainder of the number of zigzag numbers divided by 10000 out of multiples of M between A and B in one line.
Input / output example
Input example 1
100
200
Five
Output example 1
13
In I / O example 1, the number of zigzags that are multiples of 5 from 100 to 200 is 13 of 105, 120, 130, 140, 150, 160, 165, 170, 175, 180, 185, 190, 195. ..
Input example 2
6
1234567
3
Output example 2
246
In I / O example 2, there are 50246 zigzag numbers that are multiples of 3 from 6 to 1234567, so 246, which is the remainder of dividing it by 10000, is output.
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
100
200
5
Output
13 | #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
int mod=10000;
struct Mod {
public:
int num;
Mod() : Mod(0) { ; }
Mod(long long int n) : num((n % mod + mod) % mod) {
//static_assert(mod<INT_MAX / 2, "mod is too big, please make num 'long long int' from 'int'");
}
Mod(int n) : Mod(static_cast<long long int>(n)) { ; }
operator int() { return num; }
};
Mod operator+(const Mod a, const Mod b) { return Mod((a.num + b.num) % mod); }
Mod operator+(const long long int a, const Mod b) { return Mod(a) + b; }
Mod operator+(const Mod a, const long long int b) { return b + a; }
Mod operator++(Mod &a) { return a + Mod(1); }
Mod operator-(const Mod a, const Mod b) { return Mod((mod + a.num - b.num) % mod); }
Mod operator-(const long long int a, const Mod b) { return Mod(a) - b; }
Mod operator--(Mod &a) { return a - Mod(1); }
Mod operator*(const Mod a, const Mod b) { return Mod(((long long)a.num * b.num) % mod); }
Mod operator*(const long long int a, const Mod b) { return Mod(a)*b; }
Mod operator*(const Mod a, const long long int b) { return Mod(b)*a; }
Mod operator*(const Mod a, const int b) { return Mod(b)*a; }
Mod operator+=(Mod &a, const Mod b) { return a = a + b; }
Mod operator+=(long long int &a, const Mod b) { return a = a + b; }
Mod operator-=(Mod &a, const Mod b) { return a = a - b; }
Mod operator-=(long long int &a, const Mod b) { return a = a - b; }
Mod operator*=(Mod &a, const Mod b) { return a = a * b; }
Mod operator*=(long long int &a, const Mod b) { return a = a * b; }
Mod operator*=(Mod& a, const long long int &b) { return a = a * b; }
Mod operator^(const Mod a, const int n) {
if (n == 0) return Mod(1);
Mod res = (a * a) ^ (n / 2);
if (n % 2) res = res * a;
return res;
}
Mod mod_pow(const Mod a, const int n) {
if (n == 0) return Mod(1);
Mod res = mod_pow((a * a), (n / 2));
if (n % 2) res = res * a;
return res;
}
Mod inv(const Mod a) { return a ^ (mod - 2); }
Mod operator/(const Mod a, const Mod b) {
assert(b.num != 0);
return a * inv(b);
}
Mod operator/(const long long int a, const Mod b) {
return Mod(a) / b;
}
Mod operator/=(Mod &a, const Mod b) {
return a = a / b;
}
#define MAX_MOD_N 1024000
Mod fact[MAX_MOD_N], factinv[MAX_MOD_N];
void init() {
fact[0] = Mod(1); factinv[0] = 1;
for (int i = 0; i < MAX_MOD_N - 1; ++i) {
fact[i + 1] = fact[i] * Mod(i + 1);
factinv[i + 1] = factinv[i] / Mod(i + 1);
}
}
Mod comb(const int a, const int b) {
return fact[a] * factinv[b] * factinv[a - b];
}
//keta prenum,upping,aless,bmore,bai
Mod dp[502][10][2][2][2][500][2];
long long int powmod(long long int a, long long int b, const int mod) {
assert(b >= 0);
if (b == 0)return 1;
if (b == 1)return a;
long long int ans = 1;
long long int aa = powmod(a, b / 2, mod);
ans *= aa*aa;
ans %= mod;
if (b % 2)ans *= a;
ans %= mod;
return ans;
}
int main() {
string A, B; int M; cin >> A >> B >> M;
int asize = A.size(); int bsize = B.size();
for (int i = asize; i <= 501; ++i) {
A = '0' + A;
}
for (int i = bsize; i <= 501; ++i) {
B= '0' + B;
}
Mod ans = 0;
for (int i = 0; i < 10; ++i) {
bool amore = i >= (A[501] - '0');
bool bless = i <= (B[501] - '0');
dp[0][i][0][amore][bless][i%M][0]+=1;
dp[0][i][1][amore][bless][i%M][0]+=1;
dp[0][i][0][amore][bless][i%M][1] += 1;
}
for (int keta = 1; keta <= 501; ++keta) {
for (int prenum = 0; prenum < 10; ++prenum) {
for (int upping = 0; upping < 2; ++upping) {
for (int amore = 0; amore < 2; ++amore) {
for (int bless = 0; bless< 2; ++bless) {
for (int bai = 0; bai < M; ++bai) {
for (int death = 0; death < 2; ++death) {
if (dp[keta - 1][prenum][upping][amore][bless][bai][death]) {
for (int nextnum = 0; nextnum < 10; ++nextnum) {
if (death){
if (nextnum) {
continue;
}
}
else {
if (upping) {
if (nextnum <= prenum)continue;
}
else {
if (nextnum >= prenum)continue;
}
}
bool nextamore, nextbless;
if (nextnum >(A[501 - keta] - '0')) {
nextamore = true;
}
else if (nextnum == (A[501 - keta] - '0')) {
nextamore = amore;
}
else {
nextamore = false;
}
if (nextnum > (B[501 - keta] - '0')) {
nextbless = false;
}
else if (nextnum == (B[501 - keta] - '0')) {
nextbless = bless;
}
else {
nextbless = true;
}
int nextbai = bai +powmod(10, keta,M)*nextnum;
nextbai %= M;
assert(nextbai < mod);
if (keta == 1 && nextnum == 1 && (!upping) == 1 && nextamore == 1 && nextbless == 1 && nextbai == 0) {
int c = 0; c++;
}
dp[keta][nextnum][!upping][nextamore][nextbless][nextbai][death] += dp[keta - 1][prenum][upping][amore][bless][bai][death];
/*if (nextnum == 0 && keta == 3 && !nextbai&&death) {
cout << nextnum << " " << prenum << endl;
cout << dp[keta - 1][prenum][upping][amore][bless][bai][death] << endl;;
}*/
if (!death&&nextnum) {
dp[keta][nextnum][!upping][nextamore][nextbless][nextbai][1] += dp[keta - 1][prenum][upping][amore][bless][bai][death];
}
}
}
}
}
}
}
}
}
}
for (int prenum = 0; prenum < 10; ++prenum) {
for (int upping = 0; upping < 2; ++upping) {
for (int death = 1; death < 2; ++death) {
if (dp[501][prenum][upping][1][1][0][death]) {
ans += dp[501][prenum][upping][1][1][0][death];
}
}
}
}
cout << ans << endl;
return 0;
} |
Problem
KND is a student programmer at the University of Aizu. There are N towns around his town. He loves cream so he built a factory in a town to eat cream every day. The factory produces F liters of fresh cream daily. Every time you carry the cream, it will be damaged by the absolute difference between the temperature of the destination town and the temperature of the destination town. The trouble is that the temperature in this neighborhood cannot be measured by a thermometer. However, the survey was able to derive an N-element linear simultaneous equation consisting of N linear equations with the temperature of each town as a variable. You can know the temperature of each town by solving this. Also, a pipeline is used to transport fresh cream from one town to another. The pipeline has a limited amount of cream that can be sent per day. I want to send F liters of fresh cream a day from the town s where the factory is located to the town t where KND lives in the best possible condition. The towns shall be numbered starting with 0. Each term of the equation consists of at most one variable and has one constant term. F liters of fresh cream can be sent to any town within a day, no matter how you carry it.
Constraints
The input satisfies the following conditions.
* All inputs are integers.
* 0 <T ≤ 40
* 2 <N ≤ 100
* 0 ≤ s <N
* 0 ≤ t <N
* s ≠ t
* 0 <F ≤ 1000
* 0 ≤ Mi ≤ N
* -1000 ≤ ai, j ≤ 1000
* 0 ≤ fi, j <1000
* The temperature in each town is unique.
Input
The input consists of multiple test cases. One test case is given in the following format. The number of test cases is given as input.
T
N s t F
a1,1 a1,2 ... a1,N c1
a2,1 a2,2 ... a2, N c2
...
aN, 1 aN, 2 ... aN, N cN
M1
d1,1 d1,2 ... d1, M1
f1,1 f1,2 ... f1, M1
M2
d2,1 d2,2 ... d2, M2
f2,1 f2,2 ... f2, M2
...
MN
dN, 1 dN, 2 ... dN, M2
fN, 1 fN, 2 ... fN, M2
here,
* T: Number of test cases
* N: Number of towns
* s: Town with factory
* t: KND The town where you live
* F: Amount of fresh cream made per day
* ai, j: Coefficient of the temperature of the j-th town in the i-th equation as an unknown of the simultaneous equations. If ai, j = 0, the temperature of the jth town does not appear in this equation. See also the example below.
* ci: Constant term of the i-th equation
* Mi: The number of machines that move the cream in the i-th town
* di, j: The town to which the j-th machine owned by the i-th town moves the cream
* fi, j: The amount of liters that the j-th machine in the i-th town can move cream per day
Is.
Input example of a matrix representing N-element first-order simultaneous equations:
a + b = 6 1 1 0 6
3a + 2b + c = 10 => 3 2 1 10
a --2b + 3c = 6 1 -2 3 6
a, b, c represent the temperature of towns 0,1,2.
Output
For each test case, when you carry F liters of fresh cream a day from the town s where the factory is located to the town t where KND lives, output the value that minimizes the sum of the damage of the fresh cream in one line. This value should not differ more than 10-5 from the value of the judge output. Also, if you can't carry F liters of cream from town s to town t in a day, print impossible in one line.
Example
Input
3
3 0 2 5
1 1 1 6
3 2 1 10
1 -2 3 6
2
1 2
3 3
1
2
3
0
3 0 2 5
1 1 1 6
3 2 1 10
1 -2 3 6
2
1 2
2 2
1
2
2
0
10 2 7 20
8 9 -5 6 -9 5 1 0 4 9 4
3 -1 -8 0 -5 4 3 0 -3 2 4
-4 5 8 -4 1 -8 -6 3 3 5 -7
-7 0 2 5 8 -5 -9 -8 1 -2 -1
3 8 1 -3 8 2 -5 8 -3 4 -4
-2 5 0 -2 -4 4 -3 9 6 -1 -2
4 1 2 -9 3 5 6 -4 4 -1 -4
-4 6 6 9 -2 1 -9 -3 -7 3 -4
1 -1 6 3 1 -5 9 5 -5 -9 -5
-7 4 6 8 8 4 -4 4 -7 -8 -5
5
1 5 0 6 3
15 17 14 7 15
3
1 5 7
6 8 14
10
3 5 3 5 9 5 9 5 1 4
12 6 16 11 16 7 9 3 13 13
10
9 1 5 6 2 5 8 5 9 4
15 8 8 14 13 13 18 1 12 11
5
3 5 0 4 6
14 15 4 14 11
9
5 0 6 2 7 8 8 6 6
6 5 7 17 17 17 17 19 3
9
7 7 2 7 8 4 7 7 0
4 13 16 10 19 17 19 12 19
3
1 5 1
3 7 16
8
5 7 4 9 1 4 6 8
4 3 6 12 6 19 10 1
4
1 3 6 3
5 15 18 14
Output
10.0000000000
impossible
11.9354380207 | #include <bits/stdc++.h>
using namespace std;
#define dump(...) cout<<"# "<<#__VA_ARGS__<<'='<<(__VA_ARGS__)<<endl
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define peri(i,a,b) for(int i=int(b);i-->int(a);)
#define rep(i,n) repi(i,0,n)
#define per(i,n) peri(i,0,n)
#define all(c) begin(c),end(c)
#define mp make_pair
#define mt make_tuple
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;
template<typename T1,typename T2>
ostream& operator<<(ostream& os,const pair<T1,T2>& p){
return os<<'('<<p.first<<','<<p.second<<')';
}
template<typename Tuple>
void print_tuple(ostream&,const Tuple&){}
template<typename Car,typename... Cdr,typename Tuple>
void print_tuple(ostream& os,const Tuple& t){
print_tuple<Cdr...>(os,t);
os<<(sizeof...(Cdr)?",":"")<<get<sizeof...(Cdr)>(t);
}
template<typename... Args>
ostream& operator<<(ostream& os,const tuple<Args...>& t){
print_tuple<Args...>(os<<'(',t);
return os<<')';
}
template<typename Ch,typename Tr,typename C,typename=decltype(begin(C()))>
basic_ostream<Ch,Tr>& operator<<(basic_ostream<Ch,Tr>& os,const C& c){
os<<'[';
for(auto i=begin(c);i!=end(c);++i)
os<<(i==begin(c)?"":" ")<<*i;
return os<<']';
}
constexpr int INF=1e9;
constexpr int MOD=1e9+7;
constexpr double EPS=1e-9;
bool GaussJordan(const vvd& _a,const vd& b,vd& x)
{
int n=_a.size();
vvd a(n,vd(n+1));
rep(i,n){
copy(all(_a[i]),begin(a[i]));
a[i][n]=b[i];
}
rep(i,n){
int p=i;
repi(j,i+1,n) if(abs(a[p][i])<abs(a[j][i])) p=j;
if(abs(a[p][i])<EPS) return false;
swap(a[i],a[p]);
peri(j,i,n+1) a[i][j]/=a[i][i];
rep(j,n) if(j!=i) peri(k,i,n+1) a[j][k]-=a[j][i]*a[i][k];
}
rep(i,n) x[i]=a[i][n];
return true;
}
struct Edge{
int src,dst;
double cost;
int cap,flow;
Edge(){}
Edge(int s,int d,double co,int ca=0,int f=0):src(s),dst(d),cost(co),cap(ca),flow(f){}
};
bool operator<(const Edge& a,const Edge& b){return a.cost<b.cost;}
bool operator>(const Edge& a,const Edge& b){return a.cost>b.cost;}
struct Graph{
vector<Edge> es;
vi head,next;
Graph(){}
Graph(int n):head(n,-1){}
// コスト:-co,容量:0の逆辺も追加する
void AddEdge(int u,int v,double co,int ca){
es.emplace_back(u,v,co,ca); next.push_back(head[u]); head[u]=es.size()-1;
es.emplace_back(v,u,-co,0); next.push_back(head[v]); head[v]=es.size()-1;
}
};
double MinCostFlow(Graph& g,int tap,int sink,int flow)
{
int n=g.head.size();
double res=0;
vd pots(n);
while(flow>EPS){
vd cost(n,INF);
vi prev(n,-1);
priority_queue<Edge,vector<Edge>,greater<Edge>> pq;
pq.emplace(-1,tap,0);
while(pq.size()){
Edge cur=pq.top(); pq.pop();
if(cur.cost>cost[cur.dst]-EPS) continue;
cost[cur.dst]=cur.cost;
prev[cur.dst]=cur.src;
for(int i=g.head[cur.dst];i!=-1;i=g.next[i]){
Edge e=g.es[i];
if(e.cap-e.flow==0) continue;
pq.emplace(i,e.dst,cost[e.src]+e.cost+pots[e.src]-pots[e.dst]);
}
}
if(cost[sink]==INF) return -1;
rep(i,n) pots[i]+=cost[i];
int augment=flow;
for(int v=sink;v!=tap;v=g.es[prev[v]].src){
Edge e=g.es[prev[v]];
augment=min(augment,e.cap-e.flow);
}
if(augment<EPS) return -1;
for(int v=sink;v!=tap;v=g.es[prev[v]].src){
int i=prev[v];
g.es[i].flow+=augment;
g.es[i^1].flow-=augment;
}
flow-=augment;
res+=augment*pots[sink];
}
return res;
}
void solve()
{
int n,s,t,f; cin>>n>>s>>t>>f;
vd cs(n);
{
vvd a(n,vd(n));
vd b(n);
rep(i,n){
rep(j,n) cin>>a[i][j];
cin>>b[i];
}
GaussJordan(a,b,cs);
}
Graph g(n);
rep(i,n){
int m; cin>>m;
vi ds(m),fs(m);
rep(j,m) cin>>ds[j];
rep(j,m) cin>>fs[j];
rep(j,m) g.AddEdge(i,ds[j],abs(cs[ds[j]]-cs[i]),fs[j]);
}
double res=MinCostFlow(g,s,t,f);
if(res==-1)
puts("impossible");
else
printf("%.10f\n",res);
}
int main()
{
int tc; cin>>tc;
rep(_,tc) solve();
} |
You are the God of Wind.
By moving a big cloud around, you can decide the weather: it invariably rains under the cloud, and the sun shines everywhere else.
But you are a benign God: your goal is to give enough rain to every field in the countryside, and sun to markets and festivals. Small humans, in their poor vocabulary, only describe this as “weather forecast”.
You are in charge of a small country, called Paccimc. This country is constituted of 4 × 4 square areas, denoted by their numbers.
<image>
Your cloud is of size 2 × 2, and may not cross the borders of the country.
You are given the schedule of markets and festivals in each area for a period of time.
On the first day of the period, it is raining in the central areas (6-7-10-11), independently of the schedule.
On each of the following days, you may move your cloud by 1 or 2 squares in one of the four cardinal directions (North, West, South, and East), or leave it in the same position. Diagonal moves are not allowed. All moves occur at the beginning of the day.
You should not leave an area without rain for a full week (that is, you are allowed at most 6 consecutive days without rain). You don’t have to care about rain on days outside the period you were given: i.e. you can assume it rains on the whole country the day before the period, and the day after it finishes.
Input
The input is a sequence of data sets, followed by a terminating line containing only a zero.
A data set gives the number N of days (no more than 365) in the period on a single line, followed by N lines giving the schedule for markets and festivals. The i-th line gives the schedule for the i-th day. It is composed of 16 numbers, either 0 or 1, 0 standing for a normal day, and 1 a market or festival day. The numbers are separated by one or more spaces.
Output
The answer is a 0 or 1 on a single line for each data set, 1 if you can satisfy everybody, 0 if there is no way to do it.
Example
Input
1
0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0
7
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 0 0 0 1 0 0 0 0 1 1 0 0 1
0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1
0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0
0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1
0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0
7
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 0
0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0
0 1 0 0 0 0 0 1 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0
15
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0
0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0
1 1 0 0 0 0 0 0 0 0 1 0 0 1 0 0
0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0
1 0 0 1 1 0 0 0 0 1 0 1 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 1 0 1 0 1 0 0 0 0 0 0
0
Output
0
1
0
1 | #include<iostream>
using namespace std;
const int M = 1000000;
int n;
int sch[400][20];
bool dp[2][M];
int dy[] = {0,-1,0,1,0}, dx[] = {0,0,1,0,-1};
bool table[5][5];
int y,x;
int main(){
while(cin >> n,n){
for(int i=0;i<n;i++){
for(int j=0;j<16;j++)cin >> sch[i][j];
}
for(int i=0;i<M;i++)dp[0][i] = false;
dp[0][4] = !sch[0][5] && !sch[0][6] && !sch[0][9] && !sch[0][10];
for(int i=0;i<n-1;i++){
int now = i&1, nxt = 1-now;
for(int j=0;j<M;j++)dp[nxt][j] = false;
for(int j=0;j<M;j++){
if(dp[now][j]){
for(int ii=0;ii<4;ii++){
for(int jj=0;jj<4;jj++){
table[ii][jj] = ((i<5)?true:false);
}
}
int tmp = j;
for(int z=0;z<6;z++){
int pos = tmp%10;
y = pos/3; x = pos%3;
for(int ii=0;ii<=1;ii++){
for(int jj=0;jj<=1;jj++){
table[y+ii][x+jj] = true;
}
}
tmp/=10;
}
tmp = j%10;
y = tmp/3; x = tmp%3;
for(int ii=1;ii<=2;ii++){
for(int jj=0;jj<=4;jj++){
bool f = true;
int ny = y+ii*dy[jj], nx = x+ii*dx[jj];
if(ny<0 || nx<0 || ny>=3 || nx>=3)continue;
bool piyo[5][5];
for(int iii=0;iii<4;iii++){
for(int jjj=0;jjj<4;jjj++){
piyo[iii][jjj] = table[iii][jjj];
}
}
for(int iii=0;iii<=1;iii++){
for(int jjj=0;jjj<=1;jjj++){
if(sch[i+1][ (ny+iii)*4+nx+jjj ]){
f = false;
goto END;
}
piyo[ny+iii][nx+jjj] = true;
}
}
for(int iii=0;iii<4;iii++){
for(int jjj=0;jjj<4;jjj++){
if(!piyo[iii][jjj]){
f = false;
goto END;
}
}
}
END:;
dp[nxt][(j*10+(ny*3+nx))%M] |= f;
}
}
}
}
}
bool ans = false;
for(int i=0;i<M;i++)ans |= dp[(n-1)&1][i];
if(ans)cout << "1\n";
else cout << "0\n";
}
}
|
Example
Input
2 1
1 2 2
Output
1 | #include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 29;
struct UnionFind
{
vector< int > data;
UnionFind(int sz)
{
data.assign(sz, -1);
}
int find(int k)
{
return (data[k] < 0 ? k : data[k] = find(data[k]));
}
void unite(int x, int y)
{
x = find(x);
y = find(y);
if(x == y) return;
if(data[x] > data[y]) swap(x, y);
data[x] += data[y];
data[y] = x;
}
};
vector< pair< int, int > > g[100001];
vector< int > leftt[100001], rightt[100001], just[100001];
vector< int > gg[100001];
int deg[100001];
int rec(int idx, int back = -1)
{
if(rightt[idx][0] == INF) {
for(int i = 0; i < g[idx].size(); i++) {
int to, rev;
tie(to, rev) = g[idx][i];
if(i == back) continue;
just[idx][i] = rec(to, rev) + 1;
}
for(int i = 0; i < g[idx].size(); i++) {
leftt[idx][i + 1] = max(leftt[idx][i], just[idx][i]);
}
for(int i = (int) g[idx].size() - 1; i >= 0; i--) {
rightt[idx][i] = max(rightt[idx][i + 1], just[idx][i]);
}
}
if(back == -1) return (rightt[idx][0]);
return (max(leftt[idx][back], rightt[idx][back + 1]));
}
int main()
{
int N, M;
vector< pair< int, int > > edges, arcs;
scanf("%d %d", &N, &M);
UnionFind uf(N);
for(int i = 0; i < M; i++) {
int x, y, t;
cin >> x >> y >> t;
--x, --y;
if(t == 1) {
arcs.emplace_back(x, y);
g[x].emplace_back(y, -1);
} else {
if(uf.find(x) == uf.find(y)) {
cout << "Infinite" << endl;
return (0);
}
uf.unite(x, y);
edges.emplace_back(x, y);
g[y].emplace_back(x, g[x].size());
g[x].emplace_back(y, g[y].size() - 1);
}
}
{
for(auto &e : arcs) {
gg[uf.find(e.first)].push_back(uf.find(e.second));
++deg[uf.find(e.second)];
}
vector< int > order;
for(int i = 0; i < N; i++) {
if(deg[i] == 0) order.push_back(i);
}
for(int i = 0; i < order.size(); i++) {
for(auto &e : gg[order[i]]) {
if(--deg[e] == 0) order.push_back(e);
}
}
if(order.size() != N) {
cout << "Infinite" << endl;
return (0);
}
}
int ret = 0;
for(int i = 0; i < N; i++) {
int sz = g[i].size();
just[i].assign(sz, INF);
leftt[i].assign(sz + 1, INF);
rightt[i].assign(sz + 1, INF);
leftt[i][0] = rightt[i][sz] = 0;
}
for(int i = 0; i < N; i++) ret = max(ret, rec(i));
cout << ret << endl;
} |
Short Phrase
A Short Phrase (aka. Tanku) is a fixed verse, inspired by Japanese poetry Tanka and Haiku. It is a sequence of words, each consisting of lowercase letters 'a' to 'z', and must satisfy the following condition:
> (The Condition for a Short Phrase)
> The sequence of words can be divided into five sections such that the total number of the letters in the word(s) of the first section is five, that of the second is seven, and those of the rest are five, seven, and seven, respectively.
The following is an example of a Short Phrase.
>
> do the best
> and enjoy today
> at acm icpc
>
In this example, the sequence of the nine words can be divided into five sections (1) "do" and "the", (2) "best" and "and", (3) "enjoy", (4) "today" and "at", and (5) "acm" and "icpc" such that they have 5, 7, 5, 7, and 7 letters in this order, respectively. This surely satisfies the condition of a Short Phrase.
Now, Short Phrase Parnassus published by your company has received a lot of contributions. By an unfortunate accident, however, some irrelevant texts seem to be added at beginnings and ends of contributed Short Phrases. Your mission is to write a program that finds the Short Phrase from a sequence of words that may have an irrelevant prefix and/or a suffix.
Input
The input consists of multiple datasets, each in the following format.
> n
> w1
> ...
> wn
>
Here, n is the number of words, which is a positive integer not exceeding 40; wi is the i-th word, consisting solely of lowercase letters from 'a' to 'z'. The length of each word is between 1 and 10, inclusive. You can assume that every dataset includes a Short Phrase.
The end of the input is indicated by a line with a single zero.
Output
For each dataset, output a single line containing i where the first word of the Short Phrase is wi. When multiple Short Phrases occur in the dataset, you should output the first one.
Sample Input
9
do
the
best
and
enjoy
today
at
acm
icpc
14
oh
yes
by
far
it
is
wow
so
bad
to
me
you
know
hey
15
abcde
fghijkl
mnopq
rstuvwx
yzz
abcde
fghijkl
mnopq
rstuvwx
yz
abcde
fghijkl
mnopq
rstuvwx
yz
0
Output for the Sample Input
1
2
6
Example
Input
9
do
the
best
and
enjoy
today
at
acm
icpc
14
oh
yes
by
far
it
is
wow
so
bad
to
me
you
know
hey
15
abcde
fghijkl
mnopq
rstuvwx
yzz
abcde
fghijkl
mnopq
rstuvwx
yz
abcde
fghijkl
mnopq
rstuvwx
yz
0
Output
1
2
6 | #include<bits/stdc++.h>
using namespace std;
#define lp(i,n) for(int i=0;i<n;i++)
int main(){
while(1){
int n;
cin>>n;
if(n==0) break;
int a[50];
string memo;
lp(i,n){
cin>>memo;
a[i]=memo.size();
}
lp(i,n){
int ans=0;
int count=0,stats=0;
for(int j=i;j<n;j++){
if(stats==0||stats==2){
count+=a[j];
if(count==5){
stats++;
count=0;
}
if(count>5) break;
}
else if(stats==1||stats==3||stats==4){
count+=a[j];
if(count==7){
stats++;
count=0;
}
if(count>7) break;
}
if(stats==5) {
ans=1;
break;
}
}
if(ans==1) {
cout<<i+1<<endl;
break;
}
}
}
return 0;
}
|
Edward R. Nelson is visiting a strange town for some task today. This city is built on a two-dimensional flat ground with several vertical buildings each of which forms a convex polygon when seen from above on it (that is to say, the buidlings are convex polygon columns). Edward needs to move from the point S to the point T by walking along the roads on the ground. Since today the sun is scorching and it is very hot, he wants to walk in the sunshine as less as possible.
Your task is to write program that outputs the route whose length in the sunshine is the shortest, given the information of buildings, roads and the direction of the sun.
Input
The input consists of multiple data sets. Each data set is given in the following format:
N M
NV1 H1 X1,1 Y1,1 X1,2 Y1,2 . . . X1,NV1 Y1,NV1
...
NVN HN XN,1 YN,1 XN,2 YN,2 . . . XN,NVN YN,NVN
RX1,1 RY1,1 RX1,2 RY1,2
...
RXM,1 RYM,1 RXM,2 RYM,2
θ φ
SX SY TX TY
All numbers are integers. N is the number of the buildings (1 ≤ N ≤ 15). M is the number of the roads (1 ≤ M ≤ 15). NVi is the number of the vertices of the base of the i-th building (3 ≤ NVi ≤ 10). Hi is the height of the i-th building. Xi, j and Yi, j are the (x, y)-coordinates of the j-th vertex of the base of the i-th building. RXk,. and RYk,. are the coordinates of the endpoints of the k-th roads. θ is the direction of the sun, which is given by a counterclockwise degree which starts in the positive direction of x (0 ≤ θ < 360). φ is the elevation angle of the sun (0 < φ < 90). (SX, SY) and (TX, TY) are the coordinates of the points S and T, respectively. All coordinates range from 0 to 1000.
The end of the input is represented by a line with N = M = 0. This line should not be processed.
It is guaranteed that both the points S and T are on the roads. No pair of an edge of a shade and a road is parallel. You should assume that the sun is located infinitely far away and that it doesn’t move while Edward is walking.
Output
For each data set, output in one line the length for which he has to walk in the sunshine at least. Your program may output an arbitrary number of digits after the decimal point. However, the error should be 0.001 or less.
Example
Input
1 1
4 10 0 0 10 0 10 10 0 10
-5 -20 30 15
135 45
0 -15 15 0
0 0
Output
11.213 | #include <iostream>
#include <iomanip>
#include <complex>
#include <vector>
#include <algorithm>
#include <cmath>
#include <array>
#include <utility>
#include <map>
using namespace std;
const double EPS = 1e-6;
const double INF = 1e12;
const double PI = acos(-1);
#define EQ(n,m) (abs((n)-(m)) < EPS)
#define X real()
#define Y imag()
typedef complex<double> P;
typedef vector<P> VP;
struct L : array<P, 2>{
L(const P& a, const P& b){ at(0)=a; at(1)=b; }
L(){}
};
namespace std{
bool operator < (const P& a, const P& b){
return !EQ(a.X,b.X) ? a.X<b.X : a.Y+EPS<b.Y;
}
bool operator == (const P& a, const P& b){
return abs(a-b) < EPS;
}
}
double dot(P a, P b){
return (conj(a)*b).X;
}
double cross(P a, P b){
return (conj(a)*b).Y;
}
int ccw(P a, P b, P c){
b -= a;
c -= a;
if(cross(b,c) > EPS) return +1; //ccw
if(cross(b,c) < -EPS) return -1; //cw
if(dot(b,c) < -EPS) return +2; //c-a-b
if(abs(c)-abs(b) > EPS) return -2; //a-b-c
return 0; //a-c-b
}
bool intersectSS(const L& a, const L& b){
return ( ccw(a[0],a[1],b[0]) *ccw(a[0],a[1],b[1]) <= 0 ) &&
( ccw(b[0],b[1],a[0]) *ccw(b[0],b[1],a[1]) <= 0 );
}
bool intersectSP(const L& s, const P &p){
return abs(cross(s[0]-p, s[1]-p))<EPS && dot(s[0]-p, s[1]-p)<EPS;
}
bool isParallel(const P &a, const P &b){
return abs(cross(a,b)) < EPS;
}
bool isParallel(const L &a, const L &b){
return isParallel(a[1]-a[0], b[1]-b[0]);
}
P crosspointLL(const L &l, const L &m) {
double A = cross(l[1]-l[0], m[1]-m[0]);
double B = cross(l[1]-l[0], l[1]-m[0]);
return m[0] + B/A *(m[1]-m[0]);
}
int in_poly(const P &p, const VP &poly){
int n = poly.size();
int ret = -1;
for(int i=0; i<n; i++){
P a = poly[i]-p;
P b = poly[(i+1)%n]-p;
if(a.Y > b.Y) swap(a,b);
if(intersectSP(L(a,b), P(0,0))) return 0;
if(a.Y<=0 && b.Y>0 && cross(a,b)<0) ret = -ret;
}
return ret;
}
VP convex(VP v){
VP ret;
int n = v.size();
sort(v.begin(), v.end());
for(int i=0; i<n; i++){
while((int)ret.size()>1 && cross(ret.back()-ret[ret.size()-2], v[i]-ret.back()) < EPS){
ret.pop_back();
}
ret.push_back(v[i]);
}
int t = ret.size();
for(int i=n-2; i>=0; i--){
while((int)ret.size()>t && cross(ret.back()-ret[ret.size()-2], v[i]-ret.back()) < EPS){
ret.pop_back();
}
ret.push_back(v[i]);
}
if((int)ret.size() > 1) ret.pop_back();
return ret;
}
pair<vector<vector<double> >, VP> arrangementEX(const vector<L> &l, const VP &p){
vector<VP> cp(l.size());
VP plist = p;
for(int i=0; i<(int)l.size(); i++){
for(int j=i+1; j<(int)l.size(); j++){
if(!isParallel(l[i], l[j]) && intersectSS(l[i], l[j])){
P cpij = crosspointLL(l[i], l[j]);
cp[i].push_back(cpij);
cp[j].push_back(cpij);
plist.push_back(cpij);
}
}
for(int j=0; j<(int)p.size(); j++){
if(intersectSP(l[i], p[j])){
cp[i].push_back(p[j]);
}
}
cp[i].push_back(l[i][0]);
cp[i].push_back(l[i][1]);
plist.push_back(l[i][0]);
plist.push_back(l[i][1]);
sort(cp[i].begin(), cp[i].end());
cp[i].erase(unique(cp[i].begin(), cp[i].end()), cp[i].end());
}
sort(plist.begin(), plist.end());
plist.erase(unique(plist.begin(), plist.end()), plist.end());
int n = plist.size();
map<P, int> conv;
for(int i=0; i<n; i++){
conv[plist[i]] = i;
}
vector<vector<double> > adj(n, vector<double>(n, INF));
for(int i=0; i<(int)cp.size(); i++){
for(int j=0; j<(int)cp[i].size()-1; j++){
int jidx = conv[cp[i][j]];
int jp1idx = conv[cp[i][j+1]];
adj[jidx][jp1idx] = adj[jp1idx][jidx] = 0;
}
}
return make_pair(adj, plist);
}
int main(){
while(1){
//input
int n,m;
cin >> n >> m;
if(n == 0) break;
vector<VP> poly(n);
vector<double> h(n);
for(int i=0; i<n; i++){
int nv;
cin >> nv >> h[i];
poly[i].resize(nv);
for(int j=0; j<nv; j++){
int x,y;
cin >> x >> y;
poly[i][j] = P(x, y);
}
}
vector<L> lines(m);
for(int i=0; i<m; i++){
int xs,ys,xt,yt;
cin >> xs >> ys >> xt >> yt;
lines[i] = L(P(xs, ys), P(xt, yt));
}
double th,phi;
cin >> th >> phi;
th *= PI/180; phi *= PI/180;
P dir = P(cos(th+PI), sin(th+PI)) /tan(phi);
for(int i=0; i<n; i++){
VP tmp = poly[i];
P idir = dir *h[i];
for(int j=0; j<(int)poly[i].size(); j++){
tmp.push_back(poly[i][j] +idir);
}
poly[i] = convex(tmp);
}
VP sg(2);
int sx,sy,tx,ty;
cin >> sx >> sy >> tx >> ty;
sg[0] = P(sx, sy);
sg[1] = P(tx, ty);
//calc costs of edges
auto ret = arrangementEX(lines, sg);
auto &adj = ret.first;
VP &plist = ret.second;
int pn = plist.size();
int sidx = lower_bound(plist.begin(), plist.end(), sg[0]) -plist.begin();
int gidx = lower_bound(plist.begin(), plist.end(), sg[1]) -plist.begin();
for(int i=0; i<pn; i++){
for(int j=i+1;j<pn; j++){
if(adj[i][j] == INF) continue;
L e(plist[i], plist[j]);
VP cp(2);
cp[0] = e[0];
cp[1] = e[1];
for(int k=0; k<n; k++){
int vn = poly[k].size();
for(int l=0; l<vn; l++){
L edge(poly[k][l], poly[k][(l+1)%vn]);
if(!isParallel(e, edge) && intersectSS(e, edge)){
cp.push_back(crosspointLL(e, edge));
}
}
}
sort(cp.begin(), cp.end());
cp.erase(unique(cp.begin(), cp.end()), cp.end());
double cost = 0;
for(int k=0; k<(int)cp.size()-1; k++){
P mid = (cp[k] +cp[k+1]) /2.0;
bool in = false;
for(int l=0; l<n; l++){
if(in_poly(mid, poly[l]) >= 0){
in = true;
break;
}
}
if(!in){
cost += abs(cp[k+1] -cp[k]);
}
}
adj[i][j] = adj[j][i] = cost;
}
}
for(int k=0; k<pn; k++){
for(int i=0; i<pn; i++){
for(int j=0; j<pn; j++){
adj[i][j] = min(adj[i][j], adj[i][k] +adj[k][j]);
}
}
}
cout << fixed << setprecision(4);
cout << adj[sidx][gidx] << endl;
}
return 0;
}
|
I have n tickets for a train with a rabbit. Each ticket is numbered from 0 to n − 1, and you can use the k ticket to go to p⋅ak + q⋅bk station.
Rabbit wants to go to the all-you-can-eat carrot shop at the station m station ahead of the current station, but wants to walk as short as possible. The stations are lined up at regular intervals. When using, how many stations can a rabbit walk to reach the store?
Input
1 ≤ n, m, a, b, p, q ≤ 1 000 000 000 000 (integer)
Output
Output the number of rabbits that can reach the store on foot at the minimum number of stations in one line.
Examples
Input
6 200 2 3 4 5
Output
1
Input
6 1 2 3 4 5
Output
1 | #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
template<class T>
using Table = vector<vector<T>>;
const ld eps=1e-10;
//// < "D:\D_Download\Visual Studio 2015\Projects\programing_contest_c++\Debug\a.txt"
int K, R, L;
ld P;
ld E;
ld T;
long long int atime(const long long int l, const long long int r) {
if (l > LLONG_MAX / r) {
return LLONG_MAX;
}
else {
return l*r;
}
}
long long int powint(long long int a, long long int b) {
if (!b)return 1;
else {
return atime(a, powint(a, b - 1));
}
}
long long int aplus(const long long int l, const long long int r) {
if (l > LLONG_MAX / 3 || R > LLONG_MAX)return LLONG_MAX;
else return l + r;
}
//ld getans(const ld amin, const ld amax,const int rest,const ld per) {
// if (!rest||per<4e-8) {
// return abs((amin + amax) / 2 - T) < E+eps;
// }
// if (amin > E + T+eps)return 0;
// if (amax < T-E - eps)return 0;
// if (amin > T - E - eps&&T + E + eps < amax)return 1;
// ld amid = (amin + amax) / 2;
// if (amid > T-eps) {
// return getans(amin, amid,rest-1,per*(1-P))*(1-P) + getans(amid, amax,rest-1,per*P)*P;
// }
// else {
// return getans(amin, amid, rest - 1,per*P)*P + getans(amid, amax, rest - 1,per*(1-P))*(1 - P);
// }
//}
void getans(const vector<long long int>& sums,const vector<long long int>&tickets, const int now, long long int &ans,const long long int rest) {
if (now == tickets.size()) {
ans = min(ans, rest);
return;
}
if (ans < rest - sums[now])return;
if (rest >= tickets[now]) {
getans(sums, tickets, now + 1, ans, rest - tickets[now]);
}
else {
ans = min(ans, tickets[now] - rest);
}
getans(sums, tickets, now + 1, ans, rest);
}
int main() {
//cin >> K >> R >> L;
//cin >> P >> E >> T;
//ld ans = getans(R, L, K,1);
//cout << setprecision(22) << fixed << ans << endl;
//return 0;
long long int N, M, A, B, P, Q; cin >> N >> M >> A >> B >> P >> Q;
if (A > B) {
swap(A, B);
swap(P, Q);
}
assert(A <= B);
if (A == 1 && B == 1) {
long long int ticdis = P + Q;
if (atime(ticdis,N) <= M) {
cout << M - atime(ticdis, N) << endl;
}
else {
cout << min(ticdis-M%ticdis,M%ticdis) << endl;
}
}
else {
vector<long long int>tickets;
long long int ans = M;
for (int k = 0; k < N; ++k) {
long long int tic =aplus( atime(P, powint(A, k)), atime(Q, powint(B, k)));
if (tic > M) {
ans = min(ans, tic - M);
break;
}
else {
tickets.emplace_back(tic);
}
}
reverse(tickets.begin(), tickets.end());
vector<long long int>sums(tickets);
for (int i = sums.size()-1; i >0; --i) {
sums[i - 1] += sums[i];
}
getans(sums, tickets, 0, ans, M);
cout << ans << endl;
}
return 0;
} |
Taro is an elementary school student who has just learned multiplication. Somehow, he likes multiplication, so when he sees numbers, he wants to multiply. He seems to like to do the following for integers greater than or equal to 0. (Processing flow)
* Procedure 1. If a certain integer n greater than or equal to 0 is a single digit in decimal notation, the process ends there. Otherwise go to step 2
* Step 2. When an integer n of 10 or more is displayed in decimal, it is possible to break it into two numbers by inserting a break between some digits (for example, 2012-> 20, 12). For possible cutting methods like this, multiply the two obtained numbers and set the largest one as the next n, and return to step 1. (For details, see "Supplementary information on step 2" below.)
Taro seems to like this process, but I can't predict how many times step 2 should be repeated, and I think it may have to be done infinitely. So I asked Taro's older brother and college student how many times this step 2 should be done for an integer n greater than or equal to 0.
Your job is to give Q integers greater than or equal to 0 N1 .. NQ, so find out how many steps 2 will be performed on each integer before the end of the process. If you need an infinite number of steps, output -1.
Supplement on step 2
You should also take into account those that have a 0 at the beginning of the digit as a result of the isolation.
For example, when n = 1024, 1 * 024, 10 * 24, and 102 * 4 are calculated as 24,240,408, respectively, so 408 is selected and this is the next n.
Constraints
> 1 ≤ Q ≤ 100
> 0 ≤ Ni ≤ 106
>
Input
> Q
> N1
> N2
> ...
> NQ
>
* Q represents the number of integers greater than or equal to 0 given
* Ni is an integer greater than or equal to 0 that Taro is interested in, and represents the i-th one.
Output
Output Q integers separated by line breaks
> R1
> R2
> ..
> RQ
>
* Ri represents the number of times step 2 is executed before the processing is completed for Ni.
* Ri is -1 if step 2 needs to be performed infinitely for Ni
Examples
Input
3
9
99
123
Output
0
2
3
Input
2
999999
1000000
Output
12
1 | #include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <map>
#include <sstream>
using namespace std;
string toString(int n){
ostringstream os;
os << n;
return os.str();
}
int main(){
int Q;
string N;
cin >> Q;
while(Q--){
cin >> N;
int i;
for(i = 0 ; N.size() != 1 ; i++){
int ans = -1;
for(int j = 1 ; j < N.size() ; j++){
string a = N.substr(0, j);
string b = N.substr(j);
ans = max(ans, atoi(a.c_str()) * atoi(b.c_str()));
}
N = toString(ans);
}
cout << i << endl;
}
return 0;
} |
Step up and down
Kazuki, commonly known as Kerr, who attends JAG University, was invited by your friend this summer to participate in the ICPC (International Collegiate Potchari Contest). ICPC is a sports contest and requires a high degree of athletic ability. However, Mr. Kerr was always in front of the computer, and he was so lacking in exercise that he was tired even if he moved a little. Therefore, Kerr decided to start an easy-to-start exercise, "stepping up and down," as the first step to achieve good results with ICPC.
As the name suggests, stepping up and down is a simple exercise that simply repeats going up and down between the step and the floor. However, in stepping up and down, the effect cannot be obtained unless the feet are raised and lowered correctly. Correct ascent and descent is the movement of the foot that satisfies either of the following two types.
* From the state where both feet are on the floor, the left foot and the right foot are raised on the stepping stone, and both feet are on the stepping stone. Either the left foot or the right foot may be raised first.
* From the state where both feet are on the platform, the left foot and the right foot are lowered to the floor, and both feet are on the floor. Either the left foot or the right foot may be lowered first.
As can be seen from the above, raising and lowering only one leg continuously from the state of being on the floor or stepping stone does not result in correct raising and lowering. In the stepping up / down movement, when any of the above correct up / down movements is satisfied, it is counted as one time, and the larger the count number, the more effective the effect can be obtained. Note that even if you don't go back and forth between the floor and the platform, it counts as one only one way.
You want your teammate, Kerr, to be as strong as possible. So you decided to write a program and check if Kerr was skipping the step up and down. Since the information of the foot that Kerr moved by going up and down the platform is given, find the number of times that he went up and down correctly. However, it is assumed that both feet are on the floor before going up and down the platform.
Input
The input consists of multiple data sets, and the number of data sets contained in one input is 150 or less. The format of each data set is as follows.
> $ n $
> $ f_1 $ $ f_2 $ ... $ f_n $
In the first line, the integer $ n $ ($ 1 \ le n \ le 100 $) representing the number of times the foot is moved is given. In the second line, $ f_i $, which is a character string representing the movement of the foot, is given in chronological order by $ n $, separated by spaces. $ f_i $ is one of the following four types of character strings.
* "lu": Raise your left foot to the platform.
* "ru": Raise your right foot to the platform.
* "ld": Lower your left foot to the floor.
* "rd": Lower your right foot to the floor.
It can be assumed that no action is input that lowers the foot on the floor or raises the foot on the platform.
The line where $ n $ is 0 indicates the end of input. Do not process this data.
Output
For each dataset, output the number of correct steps up and down in one line. Note that if you do not output a line break at the end of each line, or if you output unnecessary characters, it will be judged as an incorrect answer.
Sample Input
Four
lu ru ld rd
Four
lu ld lu ru
1
lu
Ten
ru lu ld rd ru rd ru lu lu rd ld
0
Output for Sample Input
2
1
0
Four
Example
Input
4
lu ru ld rd
4
lu ld lu ru
1
lu
10
ru lu ld rd ru rd ru lu rd ld
0
Output
2
1
0
4 | while 1:
n = input()
if n == 0:
break
F = raw_input().split()
mode = 1
s = [0,0]
ans = 0
for f in F:
if f[0]=="l":
s[0]^=1
if mode != s[0]:
mode = -1
else:
s[1]^=1
if mode != s[1]:
mode = -1
if s[0]==s[1]:
if mode == s[0]:
ans += 1
mode = s[0]^1
print ans |
Example
Input
4 3
1 3 4 7
Output
6 | #include<bits/stdc++.h>
using namespace std;
int N,K;
int dp[2][1001][1001];
int dm[2][1001][1001];
int a[1000];
int main(){
scanf("%d %d",&N,&K);
for(int i=0;i<N;i++)scanf("%d",&a[i]);
sort(a,a+N);
fill( (int*)dp[0], (int*)dp[1], 1e9);
int ans=1e9;
for(int T=1;T<=K;T++){
int t=T%2;
int u=1-t;
for(int i=0;i<N;i++){
dp[0][i][i+1]=0;
dp[1][i][i+1]=0;
}
for(int w=2;w<=N;w++){
for(int i=0;i+w<=N;i++){
int j=i+w;
int si=i+1;
int ti=j-1;
if(w>2){
si=dm[t][i][j-1];
ti=dm[t][i+1][j];
}
dp[t][i][j]=1e9;
for(int k=si;k<=ti;k++){
if(dp[t][i][j] > dp[u][i][k]+dp[u][k][j]+a[j-1]-a[k-1]){
dp[t][i][j]=dp[u][i][k]+dp[u][k][j]+a[j-1]-a[k-1];
dm[t][i][j]=k;
}
}
}
}
}
printf("%d\n",dp[K%2][0][N]);
return 0;
} |
problem
Given $ N $ different natural numbers $ a_i $. I decided to make a pair by choosing a different natural number from the given natural numbers. Output one pair that can be created with a value difference that is a multiple of $ N -1 $.
It should be noted that such a pair always exists.
Example
Input
5
1 2 4 7 10
Output
2 10 | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
template<class S,class T> ostream& operator << (ostream& out,const pair<S,T>& o){ out << "(" << o.first << "," << o.second << ")"; return out; }
template<class T> ostream& operator << (ostream& out,const vector<T> V){ for(int i = 0; i < V.size(); i++){ out << V[i]; if(i!=V.size()-1) out << " ";} return out; }
template<class T> ostream& operator << (ostream& out,const vector<vector<T> > Mat){ for(int i = 0; i < Mat.size(); i++) { if(i != 0) out << endl; out << Mat[i];} return out; }
template<class S,class T> ostream& operator << (ostream& out,const map<S,T> mp){ out << "{ "; for(auto it = mp.begin(); it != mp.end(); it++){ out << it->first << ":" << it->second; if(mp.size()-1 != distance(mp.begin(),it)) out << ", "; } out << " }"; return out; }
/*
<url:https://onlinejudge.u-aizu.ac.jp/services/room.html#RitsCamp18Day1/problems/A>
問題文============================================================
N 個の相違なる自然数 ai が与えられる。与えられた自然数から相違なる自然数を選び、ペアを作ることにした。
作ることができるペアのうち、値の差が N−1 の倍数であるペアを一つ出力せよ。
なお、そのようなペアは必ず存在する。
=================================================================
解説=============================================================
================================================================
*/
void solve(){
ll N; cin >> N;
vector<ll> a(N); for(auto& in:a) cin >> in;
[&]{
for(int i = 0; i < N;i++){
for(int j = i+1; j < N;j++){
if(a[i] == a[j]) continue;
if(abs(a[i] - a[j])%(N-1) == 0){
cout << a[i] << " " << a[j] << endl;
return;
}
}
}
return;
}();
}
int main(void) {
cin.tie(0); ios::sync_with_stdio(false);
solve();
return 0;
}
|
Problem
A large-scale cluster † type supercomputer (commonly known as "SAKURA") cluster at Maze University consists of $ N $ computers (nodes) and $ M $ physical communication channels that can communicate with each other. .. In addition, each node is assigned an identification number from 1 to $ N $.
This time, the use of SAKURA will be approved not only by university personnel but also by companies in the prefecture. Along with that, it is necessary to inspect each node that composes SAKURA. However, since the usage schedule of SAKURA is filled up to several months ahead, the entire system cannot be stopped even during the inspection. Therefore, inspect the nodes one by one a day.
The inspection takes place over $ N $ days and inspects the node $ i $ on the $ i $ day. At this time, the node to be inspected and the communication path directly connected to that node are separated from the SAKURA cluster. As a result, the entire cluster of SAKURA is divided into one or more clusters, and one of them is operated in place of SAKURA. Naturally, the node under inspection cannot be operated.
When divided into multiple clusters, only the cluster with the highest "overall performance value" is operated. The "total performance value" of each cluster is the sum of the "single performance values" set for each node that composes it.
Since the number of nodes that make up SAKURA, the number of communication channels, and the "single performance value" set for each node are given, the "total performance value" of the cluster operated during the inspection on the $ i $ day is output. Let's do it.
†: A cluster is a system that combines one or more computers into a single unit. Here, it is a set of nodes connected by a physical communication path.
Constraints
The input satisfies the following conditions.
* $ 2 \ leq N \ leq 10 ^ 5 $
* $ N-1 \ leq M \ leq min (\ frac {N \ times (N-1)} {2}, 10 ^ 5) $
* $ 1 \ leq w_i \ leq 10 ^ 6 $
* $ 1 \ leq u_i, v_i \ leq N, u_i \ ne v_i $
* $ (u_i, v_i) \ ne (u_j, v_j), (u_i, v_i) \ ne (v_j, u_j), i \ ne j $
* All inputs are integers
Input
The input is given in the following format.
$ N $ $ M $
$ w_1 $ $ w_2 $ ... $ w_N $
$ u_1 $ $ v_1 $
$ u_2 $ $ v_2 $
...
$ u_M $ $ v_M $
The number of nodes that make up the cluster $ N $ and the number of communication channels $ M $ are given on the first line, separated by blanks.
In the second line, $ N $ integers representing the "single performance value" of each node are given, separated by blanks. The $ i $ th integer $ w_i $ represents the "single performance value" of the node $ i $.
The $ M $ lines from the third line are given the identification numbers of the two nodes that each channel connects, separated by blanks. The input on the 2 + $ i $ line indicates that the channel connects the node $ u_i $ and the node $ v_i $ to each other.
Output
The output consists of $ N $ lines.
In the $ i $ line, the "total performance value" of the cluster operated on the $ i $ day is output.
Examples
Input
9 10
1 2 3 4 5 6 7 8 9
1 2
2 3
2 4
3 4
4 5
4 6
2 7
7 8
7 9
9 1
Output
44
25
42
30
40
39
30
37
36
Input
16 19
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
1 2
2 3
3 4
3 5
1 6
6 7
6 8
7 8
8 9
8 10
10 11
11 12
12 10
1 13
13 14
14 15
15 13
14 16
15 16
Output
63
122
124
132
131
73
129
86
127
103
125
124
78
122
121
120
Input
2 1
1 2
1 2
Output
2
1 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb push_back
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
typedef vector<int>vint;
typedef pair<int,int>pint;
typedef vector<pint>vpint;
template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}
vector<int> G[1000000];
vector<pair<int, int> > bridge;
vector<int> articulation;
int ord[1000000], low[1000000];
bool vis[1000000];
int W[111111];
int al=0;
int sum[111111];
int ans[111111];
void dfs(int v, int p, int &k)
{
vis[v] = true;
sum[v]=W[v];
ord[v] = k++;
low[v] = ord[v];
bool isArticulation = false;
int ct = 0;
vint g;
for (int i = 0; i < G[v].size(); i++){
if (!vis[G[v][i]]){
ct++;
g.pb(G[v][i]);
dfs(G[v][i], v, k);
sum[v]+=sum[G[v][i]];
low[v] = min(low[v], low[G[v][i]]);
if (~p && ord[v] <= low[G[v][i]]) isArticulation = true;
}
else if (G[v][i] != p){
low[v] = min(low[v], ord[G[v][i]]);
}
}
if (p == -1 && ct > 1) isArticulation = true;
if(isArticulation){
int s=0;
for(auto u:g){
if(low[u]>=ord[v])chmax(ans[v],sum[u]);
else s+=sum[u];
}
chmax(ans[v],al-sum[v]+s);
}
else{
ans[v]=al-W[v];
}
}
signed main(){
int N,M;scanf("%lld%lld",&N,&M);
rep(i,N)scanf("%lld",&W[i]);
rep(i,M){
int a,b;
scanf("%lld%lld",&a,&b);
a--;b--;
G[a].pb(b);G[b].pb(a);
}
al=accumulate(W,W+N,0ll);
int k=0;
dfs(0,-1,k);
rep(i,N)printf("%lld\n",ans[i]);
return 0;
} |
Write a program of the Selection Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
SelectionSort(A)
1 for i = 0 to A.length-1
2 mini = i
3 for j = i to A.length-1
4 if A[j] < A[mini]
5 mini = j
6 swap A[i] and A[mini]
Note that, indices for array elements are based on 0-origin.
Your program should also print the number of swap operations defined in line 6 of the pseudocode in the case where i ≠ mini.
Constraints
1 ≤ N ≤ 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by space characters.
Output
The output consists of 2 lines.
In the first line, please print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character.
In the second line, please print the number of swap operations.
Examples
Input
6
5 6 4 2 1 3
Output
1 2 3 4 5 6
4
Input
6
5 2 4 6 1 3
Output
1 2 3 4 5 6
3 | #include <iostream>
using namespace std;
int main(void)
{
int n, an[100], cnt = 0;
cin >> n;
for(int i = 0; i < n; i++)
cin >> an[i];
for(int i = 0; i < n; i++) {
int mini = i;
int tmp = an[i];
for(int j = i; j < n; j++) {
if(an[j] < an[mini]) {
mini = j;
}
}
if(i != mini) {
an[i] = an[mini];
an[mini] = tmp;
cnt++;
}
}
for(int i = 0; i < n; i++)
cout << an[i] << (i == n - 1 ? "\n" : " ");
cout << cnt << endl;
return 0;
} |
Taro is going to play a card game. However, now he has only n cards, even though there should be 52 cards (he has no Jokers).
The 52 cards include 13 ranks of each of the four suits: spade, heart, club and diamond.
Note
解説
Input
In the first line, the number of cards n (n ≤ 52) is given.
In the following n lines, data of the n cards are given. Each card is given by a pair of a character and an integer which represent its suit and rank respectively. A suit is represented by 'S', 'H', 'C' and 'D' for spades, hearts, clubs and diamonds respectively. A rank is represented by an integer from 1 to 13.
Output
Print the missing cards. The same as the input format, each card should be printed with a character and an integer separated by a space character in a line. Arrange the missing cards in the following priorities:
* Print cards of spades, hearts, clubs and diamonds in this order.
* If the suits are equal, print cards with lower ranks first.
Example
Input
47
S 10
S 11
S 12
S 13
H 1
H 2
S 6
S 7
S 8
S 9
H 6
H 8
H 9
H 10
H 11
H 4
H 5
S 2
S 3
S 4
S 5
H 12
H 13
C 1
C 2
D 1
D 2
D 3
D 4
D 5
D 6
D 7
C 3
C 4
C 5
C 6
C 7
C 8
C 9
C 10
C 11
C 13
D 9
D 10
D 11
D 12
D 13
Output
S 1
H 3
H 7
C 12
D 8 | n=int(input())
cs = [ (s,k) for s in ['S','H','C','D'] for k in range(1,14) ]
for _ in range(n):
s,k=input().split()
cs.remove((s,int(k)))
for (s, k) in cs:
print(s, k) |