input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
Nitesh recently discovered a new game CODATHON with the help of a very intelligent alien friend Jupiter.
In this game a student had various challenges and each challenge had infinite number of problems.
The scoring system in this game was quite different. There are 2 ways of scoring on a given problem:
If you are in the first 200 to submit solution you get +a points,
In all other cases you get +b points,
Note : a,b are different for every challenge.
Now for a particular challenge with scores a and b, Nitesh wants to find out the largest score that is not possible to achieve.
Also Nitesh decided not to make a>b always ( after all Jupiter suggested it & nobody knows why !!! :P ).
Input
First Line of Input Contains T, Number of testcases,
Each testcase has 2 numbers a and b.
Output
For each testcase output the largest score which is not possible to achieve in a new line.
If all scores are achievable print 'infinite solutions' without quotes.
NOTE : The output in some cases can be extremely large, therefore print it modulo 10^9+7.
Constraints
1 ≤ T ≤ 10^9
1 ≤ a ≤ 10^18
1 ≤ b ≤ 10^18
Example
Input:
2
3 4
5 7
Output:
5
23
Explanation
Example case 1: With a=3 and b=4, except 5 all scores are possible:
eg. 6 = 3 + 3
7 = 3 + 4
8 = 4 + 4 and so on.
|
import sys
f = sys.stdin
MOD = 1000000007
T = int(f.readline())
while T:
A,B = [int(x) for x in f.readline().split()]
ans = A * B - A - B
ans %= MOD
if ans < 0 :
ans += MOD
print ans
T -= 1
|
A daily train consists of N cars. Let's consider one particular car. It has 54 places numbered consecutively from 1 to 54, some of which are already booked and some are still free. The places are numbered in the following fashion:
The car is separated into 9 compartments of 6 places each, as shown in the picture. So, the 1st compartment consists of places 1, 2, 3, 4, 53 and 54, the 2nd compartment consists of places 5, 6, 7, 8, 51 and 52, and so on.
A group of X friends wants to buy tickets for free places, all of which are in one compartment (it's much funnier to travel together). You are given the information about free and booked places in each of the N cars. Find the number of ways to sell the friends exactly X tickets in one compartment (note that the order in which the tickets are sold doesn't matter).
Input
The first line of the input contains two integers X and N (1 ≤ X ≤ 6, 1 ≤ N ≤ 10) separated by a single space. Each of the following N lines contains the information about one car which is a string of length 54 consisting of '0' and '1'. The i-th character (numbered from 1) is '0' if place i in the corresponding car is free, and is '1' if place i is already booked.
Output
Output just one integer -- the requested number of ways.
Example
Input:
1 3
100101110000001011000001111110010011110010010111000101
001010000000101111100000000000000111101010101111111010
011110011110000001010100101110001011111010001001111010
Output:
85
Input:
6 3
100101110000001011000001111110010011110010010111000101
001010000000101111100000000000000111101010101111111010
011110011110000001010100101110001011111010001001111010
Output:
1
Input:
3 2
000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000
Output:
360
Explanation:
In the first test case, any of the free places can be sold. In the second test case, the only free compartment in the train is compartment 3 in the first car (places 9, 10, 11, 12, 49 and 50 are all free). In the third test case, the train is still absolutely free; as there are 20 ways to sell 3 tickets in an empty compartment, the answer is 2 * 9 * 20 = 360.
|
first = raw_input()
inp = first.split()
x = int(inp[0])
y = int(inp[1])
train = []
ans = 0
for i in range(y):
train.append(str(raw_input()))
strin = str(train[i])
empty = []
empty.append(int( 6 - (int(strin[0])+int(strin[1])+int(strin[2])+int(strin[3])+int(strin[52])+int(strin[53]))))
empty.append(int( 6 - (int(strin[4])+int(strin[5])+int(strin[6])+int(strin[7])+int(strin[50])+int(strin[51]))))
empty.append(int( 6 - (int(strin[8])+int(strin[9])+int(strin[10])+int(strin[11])+int(strin[48])+int(strin[49]))))
empty.append(int( 6 - (int(strin[12])+int(strin[13])+int(strin[14])+int(strin[15])+int(strin[46])+int(strin[47]))))
empty.append(int( 6 - (int(strin[16])+int(strin[17])+int(strin[18])+int(strin[19])+int(strin[44])+int(strin[45]))))
empty.append(int( 6 - (int(strin[20])+int(strin[21])+int(strin[22])+int(strin[23])+int(strin[42])+int(strin[43]))))
empty.append(int( 6 - (int(strin[24])+int(strin[25])+int(strin[26])+int(strin[27])+int(strin[40])+int(strin[41]))))
empty.append(int(6 - (int(strin[28])+int(strin[29])+int(strin[30])+int(strin[31])+int(strin[38])+int(strin[39]))))
empty.append(int( 6 - (int(strin[32])+int(strin[33])+int(strin[34])+int(strin[35])+int(strin[36])+int(strin[37]))))
for j in range(9):
num = 1
den = 1
if empty[j]==x:
ans = ans+1
elif empty[j]>x:
for k in range(x):
num = num*(empty[j]-k)
den = den*(k+1)
ans = ans+num/den
print ans
|
Valentine's Day is coming and our friend Mr.IDC has fallen in love with a girl. He just could not control his feelings and went to propose her.
When he proposed her the girl gave him a challenge and asked him to solve it and the condition was if he will solve the challenge successfully then only she will accept his proposal.
Since the girl likes mathematics very much so she asked him to calculate the sum of numbers from 1 to N as:
for ( i=1;i<=N;i++ )
sum += i % MOD;
( Since the girl is also in love with him so she does not want him to waste his time on large numbers, therefore she is gave him the MOD value also to reduce his calculations. )
Now she wants him to calculate the sum using the above definition. This sum will also prove how much he love her. ;)
Input
First Line of input contains T, the number of testcases.
The next T lines will contain two integers N and MOD.
Output
For each testcase print the output in a new line.
Constraints:
1 <= T <= 1000
1 <= N <= 10^9
1 <= MOD <= 10^9
Example
Input:
3
20 5
10 2
5 3
Output:
40
5
6
Explanation
Testcase 1: For N = 20 m = 5,
Sum = 1%5 + 2%5 + 3%5 + 4%5 + 5%5 + 6%5 + 7%5 + 8%5 + 9%5 + 10%5 + 11%5 + 12%5 + 13%5 + 14%5 + 15%5 + 16%5 + 17%5 + 18%5 + 19%5 + 20%5 = 40
You can check yourself for testcase 2 and 3.
|
for _ in range(input()):
n,m=map(int,raw_input().split())
if n<m:
print n*(n+1)/2
elif n==m:
print n*(n-1)/2
else:
print (m*(m-1)/2)*(n//m)+(((n%m)*(n%m+1))/2)
|
Chef Ceil has some matchsticks in his kitchen.
Detail of matchsticks:
There are N matchsticks in total. They are numbered from to 0 to N-1 inclusive. All matchsticks have same length. But they may have different rates of burning. For i^th matchstick, we denote bi as the time required for that matchstick to completely burn-down if lighted at one end. The matchsticks have uniform rate of burning.
If lighted at both ends simultaneously, the matchstick will take only half of the original time to burn down.
Arrangement:
He ties rear end of the all the matchsticks together at one point and the front end is kept free. The matchstick numbered i is adjacent to matchstick numbered i+1 for all 0<= i <=N-2.
Bodies of matchsticks do not touch each other, except at rear end. All matchsticks are kept on the floor.
Task:
There are Q queries, in each query we ask:
If he lights the free end of all matchsticks numbered between L and R both inclusive, what will be the time needed for all matchsticks to get completely burnt.
Input
First line of input contains one integer N, total number of matchsticks. The next line contains N space separated integers bi, where bi is the time required for i^th matchstick to completely burn-down if lighted at one end.
Next line contains one integer Q, total number of queries you need to answer. Then there are Q queries in next Q lines. Each line has two space separated integers L and R.
Output
Print Q lines, one for each query, printing the answer for each query, that is, the time it will take for all the matchsticks to get completely burn down. Every time you must print your answer with 1 decimal place.
Constraints:
1 <= N <= 10^5
1<= bi <= 10^8
1 <= Q <= 10^5
0 <= L <= R <= N-1
Example
Input
1
5
1
0 0
Output
5.0
Input
2
3 5
1
0 1
Output
4.0
Input
18
3 4 2 1 5 7 9 7 10 5 12 3 1 1 2 1 3 2
1
4 10
Output
9.0
Explanation
For the last input, in figure yellow colored matches are lighted by a lighter simultaneously.
The numbers indicate the time required to burn that matchstick (if lighted at one end)
Now the first lighted matchstick will completely burn in 5 seconds. Then it will light up all the rest matches from the rear end.
Some matches will have fire at both ends and thus after 5 seconds, they will start burning with twice the original rate.
Thus time taken for matches to burn completely will be :
(from left to right): 8.0, 9.0, 7.0, 6.0, 5.0, 6.0, 7.0, 6.0, 7.5, 5.0, 8.5, 8.0, 6.0, 6.0, 7.0, 6.0, 8.0, 7.0.
So, the answer will be 9.0 (the maximum among these).
|
intMax = 10**8+1
def treeQuery(tree1, tree2, start, end, rangeStart, rangeEnd, index):
if rangeStart<=start and rangeEnd>=end:
return tree1[index], tree2[index]
if end<rangeStart or start>rangeEnd:
return intMax, -1
middleIndex = (start + end) / 2
a,c = treeQuery(tree1, tree2, start, middleIndex, rangeStart, rangeEnd, (2*index)+1)
b,d = treeQuery(tree1, tree2, middleIndex+1, end, rangeStart, rangeEnd, (2*index)+2)
return min(a,b), max(c,d)
def treeMaxQuery(tree, start, end, rangeStart, rangeEnd, index):
if rangeStart<=start and rangeEnd>=end:
return -1
if end<rangeStart or start>rangeEnd:
return tree[index]
middleIndex = (start + end) / 2
return max(treeMaxQuery(tree, start, middleIndex, rangeStart, rangeEnd, (2*index)+1),
treeMaxQuery(tree, middleIndex+1, end, rangeStart, rangeEnd, (2*index)+2))
def makeTree(nums, start, end, tree1, tree2, index):
if start==end:
tree1[index] = nums[start]
tree2[index] = nums[start]
return nums[start], nums[start]
middleindex = (start + end) / 2
a,c = makeTree(nums, start, middleindex, tree1, tree2, (index*2)+1)
b,d = makeTree(nums, middleindex+1, end, tree1, tree2, (index*2)+2)
tree1[index] = min(a,b)
tree2[index] = max(c,d)
return tree1[index], tree2[index]
def getSegmentationTree(nums,n):
import math
val = (2*(2**int(math.ceil(math.log(n,2))))) - 1
tree1 = [0] * val
tree2 = [0] * val
start = 0
end = n-1
startindex = 0
makeTree(nums, start, end, tree1, tree2, startindex)
return tree1, tree2
def main():
import sys
tokenizedInput = map(int, sys.stdin.read().split()) # Read at once, tokenize
n = tokenizedInput[0]
nums = tokenizedInput[1:n+1]
tree1, tree2 = getSegmentationTree(nums,n)
q = tokenizedInput[n+1]
readAt = n+2
s = ""
for i in xrange(q):
num1,num2 = tokenizedInput[readAt:readAt+2]
minR, maxR = treeQuery(tree1, tree2, 0, n-1, num1, num2,0)
ans = float(maxR-minR)/2
if maxR!=tree2[0]:
max1 = tree2[0]
else:
max1 = treeMaxQuery(tree2,0,n-1, num1, num2,0)
maax = max(max1, ans)
maax += minR
s += "%.1f\n" % maax
readAt+=2
print s[:-1]
main()
|
"I heard that you're settled down
That you found a girl and you're married now.
I heard that your dreams came true.
Guess she gave you things I didn't give to you."
Adele just got news about her old lover. She is in her study, reminiscing all the memories they shared and feeling lonely.
After some initial sobbing, she decided to send him a secret message. But she has a peculiar habit of enclosing all the messages in a series of parenthesis.
Now, Adele's husband gets hold of this message and finds out about the affair. He also knows that, only the message enclosed in the highest number of parenthesis is intended for her lover, all other parts are just a build-up because Adele likes Rolling in the Deep!.
He knows that Adele loves uniformity and thus the message will be balanced.Also She has written just one intended message for her lover. He needs your help to find out the message Adele is sending to her lover.
Input
A single line containing a string S, denoting the message Adele is sending to her lover.
Output
A single line containing the intended message.
Subtask #1 (40 points)
1 ≤ |S| ≤ 100
Subtask #2 (60 points)
1 ≤ |S| ≤ 100000
Sample
Input:
((Never mind(I'll find(someone like you))))
Output:
someone like you
Explanation
The message "someone like you" is enclosed inside 4 braces, which is the highest, and thus is the intended message Adele wants to send.
|
a=raw_input()
c=0
m=0
s=''
sTemp=''
for i in a:
if i=='(':
c+=1
sTemp=''
else:
if i==')' and c>m:
s=sTemp
sTemp=''
m=c
c-=1
else:
if i==')':
c-=1
sTemp=''
else:
sTemp+=i
print s
|
On the icy planet Zorg, the Vogons are putting together a zoo. One cage will house a collection of Kubudu dragons. Unlike the limited number of blood types found in other creatures, Kubudu dragons have a large variety of blood types. Each dragon’s blood type is fixed when it is born and is given by a positive integer.
These blood types determine how the dragons interact with each other. Two dragons whose blood types are close to each other will quickly start fighting and eventually destroy each other. At any given time, there is a threshold K such that it is safe to put two Kubudu dragons in the same cage only if their blood types differ by K or more.
A batch of freshly hatched Kubudu dragons has arrived. Each dragon has had its blood tested and is tagged with its blood type. The Vogon zookeeper would like to determine the size of the largest collection of dragons from this batch that can safely be placed in a single cage. Given the dragons’ fighting tendencies, this means that for each pair of dragons in the cage, their blood types should differ by at least K.
For instance, suppose that K is 3 and there are 12 Kubudu dragons whose blood types are 1, 5, 6, 1, 8, 3, 12, 2, 13, 7, 9 and 11. From this batch, the maximum number of dragons that can be placed safely in the same cage is 4—for example, the dragons with blood types: 6, 12, 2 and 9.
You will be given the blood types of N Kubudu dragons and the threshold K. Your task is to compute the size of the largest group of dragons from this collection that can safely be placed in the same cage.
Input
The first line of input has two space separated integers N and K, where N is the number of Kubudu dragons and K is the threshold below which they fight, as described above. The second line of input consists of N space separated integers, the blood types of the N dragons.
Output
A single integer, the size of the largest collection of dragons that can be safely placed in the same cage.
Test data In all cases, 1 ≤ N ≤ 10^6. In 30% of the inputs, 1 ≤ N ≤ 5000. The blood types of the dragons lie in the range 1 to 10^7
Example
Sample Input:
12 3
1 5 6 1 8 3 12 2 13 7 9 11
Sample Output:
4
|
N,K = map(int, raw_input().split())
L = sorted(set(map(int, raw_input().split())))
cmax = 0
cur_index = 0
cur_val = L[cur_index]
#import time
while 1:
#print "loop,",L
if cur_index == len(L)-1:
break
j = cur_index
cur_count = 1
loop_val = L[j]
L[j]=0
#print "{} {} {}".format(j, loop_val, cur_val)
while j < len(L)-1:
if L[j+1] != 0:
if L[j+1]-loop_val >= K:
loop_val = L[j+1]
cur_count += 1
L[j+1] = 0
j += 1
#print "cur count {}\n".format(cur_count)
if cur_count > cmax: cmax = cur_count
for i in xrange(cur_index+1,len(L)):
if L[i] != 0:
cur_index = i
cur_val = L[i]
break
cur_index = len(L)-1
#time.sleep(5)
print cmax
|
Once when Gerald studied in the first year at school, his teacher gave the class the following homework. She offered the students a string consisting of n small Latin letters; the task was to learn the way the letters that the string contains are written. However, as Gerald is too lazy, he has no desire whatsoever to learn those letters. That's why he decided to lose some part of the string (not necessarily a connected part). The lost part can consist of any number of segments of any length, at any distance from each other. However, Gerald knows that if he loses more than k characters, it will be very suspicious.
Find the least number of distinct characters that can remain in the string after no more than k characters are deleted. You also have to find any possible way to delete the characters.
Input
The first input data line contains a string whose length is equal to n (1 ≤ n ≤ 105). The string consists of lowercase Latin letters. The second line contains the number k (0 ≤ k ≤ 105).
Output
Print on the first line the only number m — the least possible number of different characters that could remain in the given string after it loses no more than k characters.
Print on the second line the string that Gerald can get after some characters are lost. The string should have exactly m distinct characters. The final string should be the subsequence of the initial string. If Gerald can get several different strings with exactly m distinct characters, print any of them.
Examples
Input
aaaaa
4
Output
1
aaaaa
Input
abacaba
4
Output
1
aaaa
Input
abcdefgh
10
Output
0
Note
In the first sample the string consists of five identical letters but you are only allowed to delete 4 of them so that there was at least one letter left. Thus, the right answer is 1 and any string consisting of characters "a" from 1 to 5 in length.
In the second sample you are allowed to delete 4 characters. You cannot delete all the characters, because the string has length equal to 7. However, you can delete all characters apart from "a" (as they are no more than four), which will result in the "aaaa" string.
In the third sample you are given a line whose length is equal to 8, and k = 10, so that the whole line can be deleted. The correct answer is 0 and an empty string.
|
#include <bits/stdc++.h>
using namespace std;
string str, ans;
int myMap[1000];
struct myPair {
int cnt;
char let;
} mp;
vector<myPair> myVect;
bool operator<(const myPair a, const myPair b) { return a.cnt < b.cnt; }
bool mark[1000];
int main() {
int i, j, k, asa = 0;
cin >> str >> k;
for (i = 0; i < str.length(); ++i) {
myMap[str[i]]++;
}
for (i = 'a'; i <= 'z'; ++i) {
if (myMap[i] != 0) {
mp.let = char(i);
mp.cnt = myMap[i];
myVect.push_back(mp);
}
}
sort(myVect.begin(), myVect.end());
for (i = 0; i < myVect.size(); ++i) {
if (myVect[i].cnt <= k) {
k -= myVect[i].cnt;
mark[myVect[i].let] = 1;
asa++;
}
}
cout << myVect.size() - asa << endl;
for (i = 0; i < str.length(); ++i) {
if (mark[str[i]] == false) {
ans += str[i];
}
}
cout << ans << endl;
return 0;
}
|
Vasya has got a magic matrix a of size n × m. The rows of the matrix are numbered from 1 to n from top to bottom, the columns are numbered from 1 to m from left to right. Let a_{ij} be the element in the intersection of the i-th row and the j-th column.
Vasya has also got a chip. Initially, the chip is in the intersection of the r-th row and the c-th column (that is, in the element a_{rc}). Vasya performs the following process as long as possible: among all elements of the matrix having their value less than the value of the element with the chip in it, Vasya randomly and equiprobably chooses one element and moves his chip to this element.
After moving the chip, he adds to his score the square of the Euclidean distance between these elements (that is, between the element in which the chip is now and the element the chip was moved from). The process ends when there are no elements having their values less than the value of the element with the chip in it.
Euclidean distance between matrix elements with coordinates (i_1, j_1) and (i_2, j_2) is equal to √{(i_1-i_2)^2 + (j_1-j_2)^2}.
Calculate the expected value of the Vasya's final score.
It can be shown that the answer can be represented as P/Q, where P and Q are coprime integer numbers, and Q not≡ 0~(mod ~ 998244353). Print the value P ⋅ Q^{-1} modulo 998244353.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 1 000) — the number of rows and the number of columns in the matrix a.
The following n lines contain description of the matrix a. The i-th line contains m integers a_{i1}, a_{i2}, ..., a_{im} ~ (0 ≤ a_{ij} ≤ 10^9).
The following line contains two integers r and c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — the index of row and the index of column where the chip is now.
Output
Print the expected value of Vasya's final score in the format described in the problem statement.
Examples
Input
1 4
1 1 2 1
1 3
Output
2
Input
2 3
1 5 7
2 3 1
1 2
Output
665496238
Note
In the first example, Vasya will move his chip exactly once. The expected value of the final score is equal to (1^2 + 2^2+ 1^2)/(3) = 2.
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int x, w;
edge() {}
edge(int x, int w) : x(x), w(w) {}
};
inline void read(int &x) {
char ch;
int f = 1;
x = 0;
do {
ch = getchar();
if (ch == '-') f = -f;
} while (ch < '0' || ch > '9');
do {
x = (x << 3) + (x << 1) + (ch & 15);
ch = getchar();
} while (ch >= '0' && ch <= '9');
x *= f;
}
const int maxs = 1000010;
const long long M = 998244353;
struct node {
long long x, y;
int w;
} blk[maxs];
long long inv[maxs], f[maxs], Sfp2[maxs], Sx[maxs], Sy[maxs];
int main() {
int n, m, s, sx, sy;
read(n);
read(m);
s = n * m;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
int pls = (i - 1) * m + j;
read(blk[pls].w);
blk[pls].x = i;
blk[pls].y = j;
}
read(sx);
read(sy);
sort(blk + 1, blk + s + 1, [&](node &x, node &y) { return x.w < y.w; });
inv[1] = 1;
for (int i = 2; i <= s; ++i) inv[i] = (-M / i * inv[M % i] % M) % M;
int l;
for (l = 1; blk[l + 1].w == blk[l].w; ++l) {
Sx[l] = (Sx[l - 1] + blk[l].x) % M;
Sy[l] = (Sy[l - 1] + blk[l].y) % M;
Sfp2[l] =
(Sfp2[l - 1] + blk[l].x * blk[l].x % M + blk[l].y * blk[l].y % M) % M;
}
Sx[l] = (Sx[l - 1] + blk[l].x) % M;
Sy[l] = (Sy[l - 1] + blk[l].y) % M;
Sfp2[l] = Sfp2[l - 1] + blk[l].x * blk[l].x + blk[l].y * blk[l].y;
for (int i = 1; i <= l; ++i)
if (sx == blk[i].x && sy == blk[i].y) {
printf("0\n");
return 0;
}
for (int i = l + 1; i <= s; ++i) {
while (blk[l + 1].w != blk[i].w) ++l;
long long p2 = (blk[i].x * blk[i].x % M + blk[i].y * blk[i].y % M) % M;
f[i] =
(inv[l] *
(Sfp2[l] - 2 * (Sx[l] * blk[i].x % M + Sy[l] * blk[i].y % M)) % M +
p2) %
M;
if (blk[i].x == sx && blk[i].y == sy) {
printf("%lld\n", (f[i] % M + M) % M);
break;
}
Sfp2[i] = (Sfp2[i - 1] + p2 + f[i]) % M;
Sx[i] = (Sx[i - 1] + blk[i].x) % M;
Sy[i] = (Sy[i - 1] + blk[i].y) % M;
}
return 0;
}
|
You stumbled upon a new kind of chess puzzles. The chessboard you are given is not necesserily 8 × 8, but it still is N × N. Each square has some number written on it, all the numbers are from 1 to N^2 and all the numbers are pairwise distinct. The j-th square in the i-th row has a number A_{ij} written on it.
In your chess set you have only three pieces: a knight, a bishop and a rook. At first, you put one of them on the square with the number 1 (you can choose which one). Then you want to reach square 2 (possibly passing through some other squares in process), then square 3 and so on until you reach square N^2. In one step you are allowed to either make a valid move with the current piece or replace it with some other piece. Each square can be visited arbitrary number of times.
A knight can move to a square that is two squares away horizontally and one square vertically, or two squares vertically and one square horizontally. A bishop moves diagonally. A rook moves horizontally or vertically. The move should be performed to a different square from the one a piece is currently standing on.
You want to minimize the number of steps of the whole traversal. Among all the paths to have the same number of steps you want to choose the one with the lowest number of piece replacements.
What is the path you should take to satisfy all conditions?
Input
The first line contains a single integer N (3 ≤ N ≤ 10) — the size of the chessboard.
Each of the next N lines contains N integers A_{i1}, A_{i2}, ..., A_{iN} (1 ≤ A_{ij} ≤ N^2) — the numbers written on the squares of the i-th row of the board.
It is guaranteed that all A_{ij} are pairwise distinct.
Output
The only line should contain two integers — the number of steps in the best answer and the number of replacement moves in it.
Example
Input
3
1 9 3
8 6 7
4 2 5
Output
12 1
Note
Here are the steps for the first example (the starting piece is a knight):
1. Move to (3, 2)
2. Move to (1, 3)
3. Move to (3, 2)
4. Replace the knight with a rook
5. Move to (3, 1)
6. Move to (3, 3)
7. Move to (3, 2)
8. Move to (2, 2)
9. Move to (2, 3)
10. Move to (2, 1)
11. Move to (1, 1)
12. Move to (1, 2)
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
import java.util.ArrayList;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
ThreePieces solver = new ThreePieces();
solver.solve(1, in, out);
out.close();
}
static class ThreePieces {
int[][][][][] dp = new int[201][10][10][100][3];
int INF = (int) (1e9);
ArrayList<int[]>[][][] move = new ArrayList[10][10][3];
int N;
int[] moveR = new int[]{-2, -1, 1, 2};
int[] moveC = new int[]{-2, -1, 1, 2};
public void solve(int testNumber, InputReader in, PrintWriter out) {
N = in.nextInt();
int[][] loc = new int[N * N][2];
int[][] arr = new int[N][N];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
int a = in.nextInt() - 1;
loc[a] = new int[]{i, j};
arr[i][j] = a;
move[i][j][0] = posKnight(i, j);
move[i][j][1] = posBishop(i, j);
move[i][j][2] = posRook(i, j);
}
}
for (int i = 0; i <= 200; i++) {
for (int j = 0; j < 10; j++) {
for (int k = 0; k < 10; k++) {
for (int d = 0; d < 100; d++) {
for (int z = 0; z < 3; z++) {
dp[i][j][k][d][z] = INF;
}
}
}
}
}
Arrays.fill(dp[0][loc[0][0]][loc[0][1]][0], 0);
for (int i = 0; i < 200; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < N; k++) {
for (int d = 0; d < N * N; d++) {
for (int m = 0; m < 3; m++) {
for (int next = 0; next < 3; next++) {
if (next == m) {
for (int[] c : move[j][k][next]) {
if (arr[c[0]][c[1]] == d + 1) {
dp[i + 1][c[0]][c[1]][d + 1][next] = Math.min(dp[i + 1][c[0]][c[1]][d + 1][next], dp[i][j][k][d][m]);
} else {
dp[i + 1][c[0]][c[1]][d][next] = Math.min(dp[i + 1][c[0]][c[1]][d][next], dp[i][j][k][d][m]);
}
}
} else {
dp[i + 1][j][k][d][next] = Math.min(dp[i + 1][j][k][d][next], dp[i][j][k][d][m] + 1);
}
}
}
}
}
}
}
for (int i = 2; i <= 200; i++) {
if (has(dp[i][loc[N * N - 1][0]][loc[N * N - 1][1]][N * N - 1])) {
int res = INF;
for (int v : dp[i][loc[N * N - 1][0]][loc[N * N - 1][1]][N * N - 1]) {
res = Math.min(res, v);
}
out.println(i + " " + res);
return;
}
}
}
boolean has(int[] a) {
for (int i : a) {
if (i != INF) {
return true;
}
}
return false;
}
boolean isValid(int r, int c) {
return r >= 0 && r < N && c >= 0 && c < N;
}
ArrayList<int[]> posKnight(int r, int c) {
ArrayList<int[]> pos = new ArrayList<>();
for (int rM : moveR) {
for (int cM : moveC) {
if (Math.abs(rM) != Math.abs(cM)) {
int newR = r + rM;
int newC = c + cM;
if (isValid(newR, newC)) {
pos.add(new int[]{newR, newC});
}
}
}
}
return pos;
}
ArrayList<int[]> posRook(int r, int c) {
ArrayList<int[]> pos = new ArrayList<>();
for (int i = 0; i < N; i++) {
pos.add(new int[]{r, i});
pos.add(new int[]{i, c});
}
return pos;
}
ArrayList<int[]> posBishop(int r, int c) {
ArrayList<int[]> pos = new ArrayList<>();
for (int k = 1; k < N; k++) {
int[] mR = new int[]{k, -k, k, -k};
int[] mC = new int[]{k, k, -k, -k};
for (int i = 0; i < 4; i++) {
int newR = r + mR[i];
int newC = c + mC[i];
if (isValid(newR, newC)) {
pos.add(new int[]{newR, newC});
}
}
}
return pos;
}
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
}
}
|
You're given an array a. You should repeat the following operation k times: find the minimum non-zero element in the array, print it, and then subtract it from all the non-zero elements of the array. If all the elements are 0s, just print 0.
Input
The first line contains integers n and k (1 ≤ n,k ≤ 10^5), the length of the array and the number of operations you should perform.
The second line contains n space-separated integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9), the elements of the array.
Output
Print the minimum non-zero element before each operation in a new line.
Examples
Input
3 5
1 2 3
Output
1
1
1
0
0
Input
4 2
10 3 5 3
Output
3
2
Note
In the first sample:
In the first step: the array is [1,2,3], so the minimum non-zero element is 1.
In the second step: the array is [0,1,2], so the minimum non-zero element is 1.
In the third step: the array is [0,0,1], so the minimum non-zero element is 1.
In the fourth and fifth step: the array is [0,0,0], so we printed 0.
In the second sample:
In the first step: the array is [10,3,5,3], so the minimum non-zero element is 3.
In the second step: the array is [7,0,2,0], so the minimum non-zero element is 2.
|
# coding: utf-8
# Your code here!
import sys
n,k = map(int,input().split())
A = list(map(int,input().split()))
A.sort()
cnt = 0
prev = 0
for i in range(len(A)):
ans = A[i] - prev
if ans != 0:
print(ans)
prev = A[i]
cnt += 1
if cnt == k:
break
for _ in range(k-cnt):
print(0)
|
Today at the lesson of mathematics, Petya learns about the digital root.
The digital root of a non-negative integer is the single digit value obtained by an iterative process of summing digits, on each iteration using the result from the previous iteration to compute a digit sum. The process continues until a single-digit number is reached.
Let's denote the digital root of x as S(x). Then S(5)=5, S(38)=S(3+8=11)=S(1+1=2)=2, S(10)=S(1+0=1)=1.
As a homework Petya got n tasks of the form: find k-th positive number whose digital root is x.
Petya has already solved all the problems, but he doesn't know if it's right. Your task is to solve all n tasks from Petya's homework.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^3) — the number of tasks in Petya's homework. The next n lines contain two integers k_i (1 ≤ k_i ≤ 10^{12}) and x_i (1 ≤ x_i ≤ 9) — i-th Petya's task in which you need to find a k_i-th positive number, the digital root of which is x_i.
Output
Output n lines, i-th line should contain a single integer — the answer to the i-th problem.
Example
Input
3
1 5
5 2
3 1
Output
5
38
19
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.*;
import java.util.Stack;
public class ROUGH {
static long m=998244353;
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
public static void main(String[] args) {
FastReader sc=new FastReader();
//Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t-->0) {
/* int n = sc.nextInt();
String s = sc.next();
int pos = -1;
for(int i=0;i<n-1;++i) {
int a = Integer.parseInt(s.substring(0,i+1));
int b = Integer.parseInt(s.substring(i+1,n));
if(a<b) {
pos = i+1;
break;
}
}
if(pos==-1)
System.out.println("NO");
else
{
System.out.println(s.substring(0,pos)+" "+s.substring(pos,n));
}
*/
long k = sc.nextLong();
int x = sc.nextInt();
long ans = (k-1)*9 + x;
System.out.println(ans);
}
}
}
|
Finished her homework, Nastya decided to play computer games. Passing levels one by one, Nastya eventually faced a problem. Her mission is to leave a room, where a lot of monsters live, as quickly as possible.
There are n manholes in the room which are situated on one line, but, unfortunately, all the manholes are closed, and there is one stone on every manhole. There is exactly one coin under every manhole, and to win the game Nastya should pick all the coins. Initially Nastya stands near the k-th manhole from the left. She is thinking what to do.
In one turn, Nastya can do one of the following:
* if there is at least one stone on the manhole Nastya stands near, throw exactly one stone from it onto any other manhole (yes, Nastya is strong).
* go to a neighboring manhole;
* if there are no stones on the manhole Nastya stays near, she can open it and pick the coin from it. After it she must close the manhole immediately (it doesn't require additional moves).
<image> The figure shows the intermediate state of the game. At the current position Nastya can throw the stone to any other manhole or move left or right to the neighboring manholes. If she were near the leftmost manhole, she could open it (since there are no stones on it).
Nastya can leave the room when she picks all the coins. Monsters are everywhere, so you need to compute the minimum number of moves Nastya has to make to pick all the coins.
Note one time more that Nastya can open a manhole only when there are no stones onto it.
Input
The first and only line contains two integers n and k, separated by space (2 ≤ n ≤ 5000, 1 ≤ k ≤ n) — the number of manholes and the index of manhole from the left, near which Nastya stays initially. Initially there is exactly one stone near each of the n manholes.
Output
Print a single integer — minimum number of moves which lead Nastya to pick all the coins.
Examples
Input
2 2
Output
6
Input
4 2
Output
13
Input
5 1
Output
15
Note
Let's consider the example where n = 2, k = 2. Nastya should play as follows:
* At first she throws the stone from the second manhole to the first. Now there are two stones on the first manhole.
* Then she opens the second manhole and pick the coin from it.
* Then she goes to the first manhole, throws two stones by two moves to the second manhole and then opens the manhole and picks the coin from it.
So, 6 moves are required to win.
|
from sys import stdin
n, m = map(int, stdin.readline().split())
print(n * 3 + min(m - 1, n - m))
|
There are n shovels in the nearby shop. The i-th shovel costs a_i bourles.
Misha has to buy exactly k shovels. Each shovel can be bought no more than once.
Misha can buy shovels by several purchases. During one purchase he can choose any subset of remaining (non-bought) shovels and buy this subset.
There are also m special offers in the shop. The j-th of them is given as a pair (x_j, y_j), and it means that if Misha buys exactly x_j shovels during one purchase then y_j most cheapest of them are for free (i.e. he will not pay for y_j most cheapest shovels during the current purchase).
Misha can use any offer any (possibly, zero) number of times, but he cannot use more than one offer during one purchase (but he can buy shovels without using any offers).
Your task is to calculate the minimum cost of buying k shovels, if Misha buys them optimally.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 2 ⋅ 10^5, 1 ≤ k ≤ min(n, 2000)) — the number of shovels in the shop, the number of special offers and the number of shovels Misha has to buy, correspondingly.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the cost of the i-th shovel.
The next m lines contain special offers. The j-th of them is given as a pair of integers (x_i, y_i) (1 ≤ y_i ≤ x_i ≤ n) and means that if Misha buys exactly x_i shovels during some purchase, then he can take y_i most cheapest of them for free.
Output
Print one integer — the minimum cost of buying k shovels if Misha buys them optimally.
Examples
Input
7 4 5
2 5 4 2 6 3 1
2 1
6 5
2 1
3 1
Output
7
Input
9 4 8
6 8 5 1 8 1 1 2 1
9 2
8 4
5 3
9 7
Output
17
Input
5 1 4
2 5 7 4 6
5 4
Output
17
Note
In the first example Misha can buy shovels on positions 1 and 4 (both with costs 2) during the first purchase and get one of them for free using the first or the third special offer. And then he can buy shovels on positions 3 and 6 (with costs 4 and 3) during the second purchase and get the second one for free using the first or the third special offer. Then he can buy the shovel on a position 7 with cost 1. So the total cost is 4 + 2 + 1 = 7.
In the second example Misha can buy shovels on positions 1, 2, 3, 4 and 8 (costs are 6, 8, 5, 1 and 2) and get three cheapest (with costs 5, 1 and 2) for free. And then he can buy shovels on positions 6, 7 and 9 (all with costs 1) without using any special offers. So the total cost is 6 + 8 + 1 + 1 + 1 = 17.
In the third example Misha can buy four cheapest shovels without using any special offers and get the total cost 17.
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
int a[maxn], s[maxn];
int g[maxn], f[maxn];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= m; ++i) {
int x, y;
cin >> x >> y;
if (x <= k) g[x] = max(g[x], y);
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= k; ++i) s[i] = s[i - 1] + a[i];
for (int i = 1; i <= k; ++i) {
f[i] = 0;
for (int j = 0; j < i; ++j) f[i] = max(f[i], f[j] + s[j + g[i - j]] - s[j]);
}
cout << s[k] - f[k] << endl;
return 0;
}
|
Authors guessed an array a consisting of n integers; each integer is not less than 2 and not greater than 2 ⋅ 10^5. You don't know the array a, but you know the array b which is formed from it with the following sequence of operations:
1. Firstly, let the array b be equal to the array a;
2. Secondly, for each i from 1 to n:
* if a_i is a prime number, then one integer p_{a_i} is appended to array b, where p is an infinite sequence of prime numbers (2, 3, 5, ...);
* otherwise (if a_i is not a prime number), the greatest divisor of a_i which is not equal to a_i is appended to b;
3. Then the obtained array of length 2n is shuffled and given to you in the input.
Here p_{a_i} means the a_i-th prime number. The first prime p_1 = 2, the second one is p_2 = 3, and so on.
Your task is to recover any suitable array a that forms the given array b. It is guaranteed that the answer exists (so the array b is obtained from some suitable array a). If there are multiple answers, you can print any.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains 2n integers b_1, b_2, ..., b_{2n} (2 ≤ b_i ≤ 2750131), where b_i is the i-th element of b. 2750131 is the 199999-th prime number.
Output
In the only line of the output print n integers a_1, a_2, ..., a_n (2 ≤ a_i ≤ 2 ⋅ 10^5) in any order — the array a from which the array b can be obtained using the sequence of moves given in the problem statement. If there are multiple answers, you can print any.
Examples
Input
3
3 5 2 3 2 4
Output
3 4 2
Input
1
2750131 199999
Output
199999
Input
1
3 6
Output
6
|
import java.util.*;
import java.lang.*;
import java.lang.reflect.Array;
import java.io.*;
import java.math.*;
import java.text.DecimalFormat;
public class Temp{
static class InputReader {
private final InputStream stream;
private final byte[] buf = new byte[8192];
private int curChar, snumChars;
public InputReader(InputStream st) {
this.stream = st;
}
public int read() {
if (snumChars == -1)
throw new InputMismatchException();
if (curChar >= snumChars) {
curChar = 0;
try {
snumChars = stream.read(buf);
}
catch (IOException e) {
throw new InputMismatchException();
}
if (snumChars <= 0)
return -1;
}
return buf[curChar++];
}
public int ni() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public long nl() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public int[] nia(int n) {
int a[] = new int[n];
for (int i = 0; i < n; i++) {
a[i] = ni();
}
return a;
}
public String rs() {
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 nextLine() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isEndOfLine(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
private boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
}
static PrintWriter w = new PrintWriter(System.out);
public static class Key {
private final int x;
private final int y;
public Key(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Key)) return false;
Key key = (Key) o;
return x == key.x && y == key.y;
}
@Override
public int hashCode() {
int result = x;
result = 31 * result + y;
return result;
}
}
static long mod=1000000007L;
static ArrayList<Integer> arr[];
static int n;
static boolean prime[]=new boolean[(int)(1e7+1)];
static ArrayList<Integer> pri=new ArrayList<>();
static int maxD[]=new int[(int)3e6+1];
static void findMaxD(){
for(int i:pri){
if(i<=2)continue;
if(prime[i]){
for(int j=3;(j*i)<=(int)3e6;j+=2){
maxD[j*i]=Math.max(Math.max(i, j),maxD[j*i]);
}
}
}
for(int i=2;i<=(int)3e6;i+=2){
maxD[i]=i/2;
}
}
static void sieve() {
Arrays.fill(prime, true);
pri.add(-1);
prime[0] = prime[1] = false;
for(int i = 2 ; i <=(int)1e7 ; ++i) {
if(prime[i]) {
pri.add(i);
int j=2*i;
while(j<=(int)1e7){
prime[j]=false;
j+=i;
}
}
}
}
public static void main (String[] args)throws IOException{
InputReader sc=new InputReader(System.in);
sieve();
findMaxD();
int n=sc.ni();
//TreeMap<Integer,Integer> map=new TreeMap<>();
int co[]=new int[(int)3e6+1];
for(int i=0;i<2*n;i++){
int a=sc.ni();
co[a]++;
// if(map.containsKey(a))map.replace(a,map.get(a)+1);
// else map.put(a,1);
}
ArrayList<Integer> ans=new ArrayList<>();
for(int i=(int)3e6;i>2;i--){
if(co[i]>0&&!prime[i]){
int l=co[i];
for(int k=0;k<l&&co[maxD[i]]>0;k++){
ans.add(i);
co[i]--;
co[maxD[i]]--;
}
}
}
for(int i=2;i<=(int)3e6;i++){
if(co[i]>0&&prime[i]){
int l=co[i];
for(int k=0;k<l&&co[pri.get(i)]>0;k++){
co[i]--;
co[pri.get(i)]--;
ans.add(i);
}
}
}
for(int i:ans)w.print(i+" ");
w.println();
w.close();
}
}
|
Finally, a basketball court has been opened in SIS, so Demid has decided to hold a basketball exercise session. 2 ⋅ n students have come to Demid's exercise session, and he lined up them into two rows of the same size (there are exactly n people in each row). Students are numbered from 1 to n in each row in order from left to right.
<image>
Now Demid wants to choose a team to play basketball. He will choose players from left to right, and the index of each chosen player (excluding the first one taken) will be strictly greater than the index of the previously chosen player. To avoid giving preference to one of the rows, Demid chooses students in such a way that no consecutive chosen students belong to the same row. The first student can be chosen among all 2n students (there are no additional constraints), and a team can consist of any number of students.
Demid thinks, that in order to compose a perfect team, he should choose students in such a way, that the total height of all chosen students is maximum possible. Help Demid to find the maximum possible total height of players in a team he can choose.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10^5) — the number of students in each row.
The second line of the input contains n integers h_{1, 1}, h_{1, 2}, …, h_{1, n} (1 ≤ h_{1, i} ≤ 10^9), where h_{1, i} is the height of the i-th student in the first row.
The third line of the input contains n integers h_{2, 1}, h_{2, 2}, …, h_{2, n} (1 ≤ h_{2, i} ≤ 10^9), where h_{2, i} is the height of the i-th student in the second row.
Output
Print a single integer — the maximum possible total height of players in a team Demid can choose.
Examples
Input
5
9 3 5 7 3
5 8 1 4 5
Output
29
Input
3
1 2 9
10 1 1
Output
19
Input
1
7
4
Output
7
Note
In the first example Demid can choose the following team as follows:
<image>
In the second example Demid can choose the following team as follows:
<image>
|
n = int(raw_input())
h1 = list(map(int, raw_input().split()))
h2 = list(map(int, raw_input().split()))
dp1 = [0] * n
dp2 = [0] * n
dp1[0] = h1[0]
dp2[0] = h2[0]
for i in range(1, n):
dp1[i] = max(dp2[i-1] + h1[i], dp1[i-1])
dp2[i] = max(dp1[i-1] + h2[i], dp2[i-1])
print(max(dp1[n-1], dp2[n-1]))
|
Let's define p_i(n) as the following permutation: [i, 1, 2, ..., i - 1, i + 1, ..., n]. This means that the i-th permutation is almost identity (i.e. which maps every element to itself) permutation but the element i is on the first position. Examples:
* p_1(4) = [1, 2, 3, 4];
* p_2(4) = [2, 1, 3, 4];
* p_3(4) = [3, 1, 2, 4];
* p_4(4) = [4, 1, 2, 3].
You are given an array x_1, x_2, ..., x_m (1 ≤ x_i ≤ n).
Let pos(p, val) be the position of the element val in p. So, pos(p_1(4), 3) = 3, pos(p_2(4), 2) = 1, pos(p_4(4), 4) = 1.
Let's define a function f(p) = ∑_{i=1}^{m - 1} |pos(p, x_i) - pos(p, x_{i + 1})|, where |val| is the absolute value of val. This function means the sum of distances between adjacent elements of x in p.
Your task is to calculate f(p_1(n)), f(p_2(n)), ..., f(p_n(n)).
Input
The first line of the input contains two integers n and m (2 ≤ n, m ≤ 2 ⋅ 10^5) — the number of elements in each permutation and the number of elements in x.
The second line of the input contains m integers (m, not n) x_1, x_2, ..., x_m (1 ≤ x_i ≤ n), where x_i is the i-th element of x. Elements of x can repeat and appear in arbitrary order.
Output
Print n integers: f(p_1(n)), f(p_2(n)), ..., f(p_n(n)).
Examples
Input
4 4
1 2 3 4
Output
3 4 6 5
Input
5 5
2 1 5 3 5
Output
9 8 12 6 8
Input
2 10
1 2 1 1 2 2 2 2 2 2
Output
3 3
Note
Consider the first example:
x = [1, 2, 3, 4], so
* for the permutation p_1(4) = [1, 2, 3, 4] the answer is |1 - 2| + |2 - 3| + |3 - 4| = 3;
* for the permutation p_2(4) = [2, 1, 3, 4] the answer is |2 - 1| + |1 - 3| + |3 - 4| = 4;
* for the permutation p_3(4) = [3, 1, 2, 4] the answer is |2 - 3| + |3 - 1| + |1 - 4| = 6;
* for the permutation p_4(4) = [4, 1, 2, 3] the answer is |2 - 3| + |3 - 4| + |4 - 1| = 5.
Consider the second example:
x = [2, 1, 5, 3, 5], so
* for the permutation p_1(5) = [1, 2, 3, 4, 5] the answer is |2 - 1| + |1 - 5| + |5 - 3| + |3 - 5| = 9;
* for the permutation p_2(5) = [2, 1, 3, 4, 5] the answer is |1 - 2| + |2 - 5| + |5 - 3| + |3 - 5| = 8;
* for the permutation p_3(5) = [3, 1, 2, 4, 5] the answer is |3 - 2| + |2 - 5| + |5 - 1| + |1 - 5| = 12;
* for the permutation p_4(5) = [4, 1, 2, 3, 5] the answer is |3 - 2| + |2 - 5| + |5 - 4| + |4 - 5| = 6;
* for the permutation p_5(5) = [5, 1, 2, 3, 4] the answer is |3 - 2| + |2 - 1| + |1 - 4| + |4 - 1| = 8.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long int mi = INT_MAX, ma = INT_MIN, gcd, i, j, k, w, d, x, y, x1, y1, p,
q, r, n, m, root, sum;
cin >> n >> m;
long long int a[m];
for (i = 0; i < m; i++) cin >> a[i];
long long int ans[n + 2];
memset(ans, 0, sizeof(ans));
for (i = 0; i < m - 1; i++) {
p = min(a[i], a[i + 1]);
q = max(a[i], a[i + 1]);
if (p == q) continue;
ans[0] += (q - p);
ans[p] -= (q - p);
ans[p] += (q - 1);
ans[p + 1] -= (q - 1);
ans[p + 1] += (q - p - 1);
ans[q] -= (q - p - 1);
ans[q] += (p);
ans[q + 1] -= (p);
ans[q + 1] += (q - p);
}
for (i = 1; i <= n; i++) {
ans[i] += ans[i - 1];
cout << ans[i] << " ";
}
return 0;
}
|
You're given an undirected graph with n nodes and m edges. Nodes are numbered from 1 to n.
The graph is considered harmonious if and only if the following property holds:
* For every triple of integers (l, m, r) such that 1 ≤ l < m < r ≤ n, if there exists a path going from node l to node r, then there exists a path going from node l to node m.
In other words, in a harmonious graph, if from a node l we can reach a node r through edges (l < r), then we should able to reach nodes (l+1), (l+2), …, (r-1) too.
What is the minimum number of edges we need to add to make the graph harmonious?
Input
The first line contains two integers n and m (3 ≤ n ≤ 200\ 000 and 1 ≤ m ≤ 200\ 000).
The i-th of the next m lines contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i), that mean that there's an edge between nodes u and v.
It is guaranteed that the given graph is simple (there is no self-loop, and there is at most one edge between every pair of nodes).
Output
Print the minimum number of edges we have to add to the graph to make it harmonious.
Examples
Input
14 8
1 2
2 7
3 4
6 3
5 7
3 8
6 8
11 12
Output
1
Input
200000 3
7 9
9 8
4 5
Output
0
Note
In the first example, the given graph is not harmonious (for instance, 1 < 6 < 7, node 1 can reach node 7 through the path 1 → 2 → 7, but node 1 can't reach node 6). However adding the edge (2, 4) is sufficient to make it harmonious.
In the second example, the given graph is already harmonious.
|
#include <bits/stdc++.h>
using namespace std;
void dfs(vector<int> graph[], int u, int comp[], int k, bool visit[]) {
int size = graph[u].size();
visit[u] = true;
comp[u] = k;
for (int i = 0; i < size; i++) {
if (!visit[graph[u][i]]) {
dfs(graph, graph[u][i], comp, k, visit);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, i, j, u, v;
cin >> n >> m;
vector<int> graph[n];
for (i = 0; i < m; i++) {
cin >> u >> v;
graph[u - 1].push_back(v - 1);
graph[v - 1].push_back(u - 1);
}
bool visit[n];
int comp[n], k = 0;
memset(visit, false, n);
for (i = 0; i < n; i++) {
if (!visit[i]) {
dfs(graph, i, comp, k, visit);
k++;
}
}
vector<int> ve[k];
for (i = 0; i < n; i++) {
ve[comp[i]].push_back(i);
}
bool set[k];
memset(set, false, k);
int edges = 0;
for (i = 0; i < k; i++) {
if (!set[i]) {
set[i] = true;
if (ve[i].size() > 1) {
int max = ve[i][ve[i].size() - 1];
int start = ve[i][0];
for (j = start; j < max; j++) {
if (!set[comp[j]]) {
edges++;
set[comp[j]] = true;
if (ve[comp[j]][ve[comp[j]].size() - 1] > max) {
max = ve[comp[j]][ve[comp[j]].size() - 1];
}
}
}
}
}
}
cout << edges;
return 0;
}
|
You are given a non-empty string s=s_1s_2... s_n, which consists only of lowercase Latin letters. Polycarp does not like a string if it contains at least one string "one" or at least one string "two" (or both at the same time) as a substring. In other words, Polycarp does not like the string s if there is an integer j (1 ≤ j ≤ n-2), that s_{j}s_{j+1}s_{j+2}="one" or s_{j}s_{j+1}s_{j+2}="two".
For example:
* Polycarp does not like strings "oneee", "ontwow", "twone" and "oneonetwo" (they all have at least one substring "one" or "two"),
* Polycarp likes strings "oonnee", "twwwo" and "twnoe" (they have no substrings "one" and "two").
Polycarp wants to select a certain set of indices (positions) and remove all letters on these positions. All removals are made at the same time.
For example, if the string looks like s="onetwone", then if Polycarp selects two indices 3 and 6, then "onetwone" will be selected and the result is "ontwne".
What is the minimum number of indices (positions) that Polycarp needs to select to make the string liked? What should these positions be?
Input
The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Next, the test cases are given.
Each test case consists of one non-empty string s. Its length does not exceed 1.5⋅10^5. The string s consists only of lowercase Latin letters.
It is guaranteed that the sum of lengths of all lines for all input data in the test does not exceed 1.5⋅10^6.
Output
Print an answer for each test case in the input in order of their appearance.
The first line of each answer should contain r (0 ≤ r ≤ |s|) — the required minimum number of positions to be removed, where |s| is the length of the given line. The second line of each answer should contain r different integers — the indices themselves for removal in any order. Indices are numbered from left to right from 1 to the length of the string. If r=0, then the second line can be skipped (or you can print empty). If there are several answers, print any of them.
Examples
Input
4
onetwone
testme
oneoneone
twotwo
Output
2
6 3
0
3
4 1 7
2
1 4
Input
10
onetwonetwooneooonetwooo
two
one
twooooo
ttttwo
ttwwoo
ooone
onnne
oneeeee
oneeeeeeetwooooo
Output
6
18 11 12 1 6 21
1
1
1
3
1
2
1
6
0
1
4
0
1
1
2
1 11
Note
In the first example, answers are:
* "onetwone",
* "testme" — Polycarp likes it, there is nothing to remove,
* "oneoneone",
* "twotwo".
In the second example, answers are:
* "onetwonetwooneooonetwooo",
* "two",
* "one",
* "twooooo",
* "ttttwo",
* "ttwwoo" — Polycarp likes it, there is nothing to remove,
* "ooone",
* "onnne" — Polycarp likes it, there is nothing to remove,
* "oneeeee",
* "oneeeeeeetwooooo".
|
t = int(input())
for _ in range(t):
s = input()
i = 0
R = []
while i < len(s):
# print(s[i:i+5])
if i+4<len(s) and s[i:i+5] == "twone":
# print('paso')
R.append(i+2+1)
i+=5
elif i+2<len(s) and (s[i:i+3] == "one" or s[i:i+3] == "two"):
R.append(i+1+1)
i+=3
else: i+=1
print(len(R))
for i in R:
print(i, end=' ')
print()
|
In this problem, we will deal with binary strings. Each character of a binary string is either a 0 or a 1. We will also deal with substrings; recall that a substring is a contiguous subsequence of a string. We denote the substring of string s starting from the l-th character and ending with the r-th character as s[l ... r]. The characters of each string are numbered from 1.
We can perform several operations on the strings we consider. Each operation is to choose a substring of our string and replace it with another string. There are two possible types of operations: replace 011 with 110, or replace 110 with 011. For example, if we apply exactly one operation to the string 110011110, it can be transformed into 011011110, 110110110, or 110011011.
Binary string a is considered reachable from binary string b if there exists a sequence s_1, s_2, ..., s_k such that s_1 = a, s_k = b, and for every i ∈ [1, k - 1], s_i can be transformed into s_{i + 1} using exactly one operation. Note that k can be equal to 1, i. e., every string is reachable from itself.
You are given a string t and q queries to it. Each query consists of three integers l_1, l_2 and len. To answer each query, you have to determine whether t[l_1 ... l_1 + len - 1] is reachable from t[l_2 ... l_2 + len - 1].
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of string t.
The second line contains one string t (|t| = n). Each character of t is either 0 or 1.
The third line contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries.
Then q lines follow, each line represents a query. The i-th line contains three integers l_1, l_2 and len (1 ≤ l_1, l_2 ≤ |t|, 1 ≤ len ≤ |t| - max(l_1, l_2) + 1) for the i-th query.
Output
For each query, print either YES if t[l_1 ... l_1 + len - 1] is reachable from t[l_2 ... l_2 + len - 1], or NO otherwise. You may print each letter in any register.
Example
Input
5
11011
3
1 3 3
1 4 2
1 2 3
Output
Yes
Yes
No
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const LL H = 998244353;
LL n, q, s[200010], sum[200010], h[2][200010];
char str[200010];
LL pw(LL x, LL p) {
if (!p) return 1;
LL t = pw(x, p / 2);
if (p % 2)
return t * t % H * x % H;
else
return t * t % H;
}
int main() {
scanf("%lld%s%lld", &n, str + 1, &q);
LL l = 0;
for (LL i = 1; i <= n; i++)
if (str[i] == '0') {
sum[i] = sum[i - 1] + 1;
s[++l] = i % 2;
} else
sum[i] = sum[i - 1];
for (LL i = 1; i <= l; i++) {
h[0][i] = (h[0][i - 1] * 2 + s[i]) % H;
h[1][i] = (h[1][i - 1] * 2 + 1 - s[i]) % H;
}
while (q--) {
LL p1, p2, len, q1, q2, c1, c2, h1, h2;
scanf("%lld%lld%lld", &p1, &p2, &len);
q1 = sum[p1 - 1], c1 = sum[p1 + len - 1] - q1;
q2 = sum[p2 - 1], c2 = sum[p2 + len - 1] - q2;
if (c1 != c2) {
puts("No");
continue;
}
h1 = ((h[p1 % 2][q1 + c1] - h[p1 % 2][q1] * pw(2, c1)) % H + H) % H;
h2 = ((h[p2 % 2][q2 + c2] - h[p2 % 2][q2] * pw(2, c2)) % H + H) % H;
if (h1 == h2)
puts("Yes");
else
puts("No");
}
return 0;
}
|
Unary is a minimalistic Brainfuck dialect in which programs are written using only one token.
Brainfuck programs use 8 commands: "+", "-", "[", "]", "<", ">", "." and "," (their meaning is not important for the purposes of this problem). Unary programs are created from Brainfuck programs using the following algorithm. First, replace each command with a corresponding binary code, using the following conversion table:
* ">" → 1000,
* "<" → 1001,
* "+" → 1010,
* "-" → 1011,
* "." → 1100,
* "," → 1101,
* "[" → 1110,
* "]" → 1111.
Next, concatenate the resulting binary codes into one binary number in the same order as in the program. Finally, write this number using unary numeral system — this is the Unary program equivalent to the original Brainfuck one.
You are given a Brainfuck program. Your task is to calculate the size of the equivalent Unary program, and print it modulo 1000003 (106 + 3).
Input
The input will consist of a single line p which gives a Brainfuck program. String p will contain between 1 and 100 characters, inclusive. Each character of p will be "+", "-", "[", "]", "<", ">", "." or ",".
Output
Output the size of the equivalent Unary program modulo 1000003 (106 + 3).
Examples
Input
,.
Output
220
Input
++++[>,.<-]
Output
61425
Note
To write a number n in unary numeral system, one simply has to write 1 n times. For example, 5 written in unary system will be 11111.
In the first example replacing Brainfuck commands with binary code will give us 1101 1100. After we concatenate the codes, we'll get 11011100 in binary system, or 220 in decimal. That's exactly the number of tokens in the equivalent Unary program.
|
/**
*
* @author xerxes
*/
import java.io.*;
import java.lang.*;
import java.math.*;
import java.text.*;
import java.util.*;
public class Main {
BufferedReader reader;
public static void main(String[] args) throws IOException {
Main ob = new Main();
ob.Run();
System.exit(0);
}
char[] sig = {'>', '<', '+', '-', '.', ',', '[', ']'};
String[] val = {"1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"};
String str;
String line;
int len;
long mod = 1000003;
public void Run() throws IOException {
reader = new BufferedReader(new InputStreamReader(System.in));
line = reader.readLine();
len = line.length();
str = "";
for (int i = 0; i < len; ++i) {
char ch = line.charAt(i);
str += f(ch);
}
// System.out.println(str);
BigInteger res = BigInteger.ZERO;
int n = str.length();
for(int i=n-1,id=0;i>=0;--i,++id){
char ch = str.charAt(i);
if( ch=='0' )continue;
BigInteger tmp = fastPow(2,id);
res = ( res.add(tmp) );
res = res.mod( BigInteger.valueOf(mod)) ;
}
System.out.println(res);
}
public String f(char ch) {
for (int i = 0; i <= 8; ++i) {
if (ch == sig[i]) {
return val[i];
}
}
return "0";
}
public BigInteger fastPow(long x, long y) {
BigInteger base = BigInteger.valueOf(x);
BigInteger res = BigInteger.ONE;
while (y > 0) {
if ((y % 2)!=0) {
res = res.multiply(base);
}
base = base.multiply(base);
y/=2;
}
return res;
}
}
|
Johnny's younger sister Megan had a birthday recently. Her brother has bought her a box signed as "Your beautiful necklace — do it yourself!". It contains many necklace parts and some magic glue.
The necklace part is a chain connecting two pearls. Color of each pearl can be defined by a non-negative integer. The magic glue allows Megan to merge two pearls (possibly from the same necklace part) into one. The beauty of a connection of pearls in colors u and v is defined as follows: let 2^k be the greatest power of two dividing u ⊕ v — [exclusive or](https://en.wikipedia.org/wiki/Exclusive_or#Computer_science) of u and v. Then the beauty equals k. If u = v, you may assume that beauty is equal to 20.
Each pearl can be combined with another at most once. Merging two parts of a necklace connects them. Using the glue multiple times, Megan can finally build the necklace, which is a cycle made from connected necklace parts (so every pearl in the necklace is combined with precisely one other pearl in it). The beauty of such a necklace is the minimum beauty of a single connection in it. The girl wants to use all available necklace parts to build exactly one necklace consisting of all of them with the largest possible beauty. Help her!
Input
The first line contains n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of necklace parts in the box. Each of the next n lines contains two integers a and b (0 ≤ a, b < 2^{20}), which denote colors of pearls presented in the necklace parts. Pearls in the i-th line have indices 2i - 1 and 2i respectively.
Output
The first line should contain a single integer b denoting the maximum possible beauty of a necklace built from all given parts.
The following line should contain 2n distinct integers p_i (1 ≤ p_i ≤ 2n) — the indices of initial pearls in the order in which they appear on a cycle. Indices of pearls belonging to the same necklace part have to appear at neighboring positions in this permutation (so 1 4 3 2 is not a valid output, whereas 2 1 4 3 and 4 3 1 2 are). If there are many possible answers, you can print any.
Examples
Input
5
13 11
11 1
3 5
17 1
9 27
Output
3
8 7 9 10 5 6 1 2 3 4
Input
5
13 11
11 1
3 5
17 1
7 29
Output
2
8 7 10 9 5 6 4 3 2 1
Input
1
1 1
Output
20
2 1
Note
In the first example the following pairs of pearls are combined: (7, 9), (10, 5), (6, 1), (2, 3) and (4, 8). The beauties of connections equal correspondingly: 3, 3, 3, 20, 20.
The following drawing shows this construction.
<image>
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1100000;
int n, a[N], b[N];
struct node {
int to;
int u, v;
node() {}
node(int x, int y, int z) : to(x), u(y), v(z) {}
};
int fir[N];
vector<node> e[N];
vector<int> rev[N], print;
vector<bool> vis[N];
void dfs(int from) {
for (int &i = fir[from]; i < e[from].size(); ++i)
if (!vis[from][i]) {
int to = e[from][i].to, u = e[from][i].u, v = e[from][i].v;
vis[from][i] = vis[to][rev[from][i]] = true;
dfs(to);
print.push_back(v), print.push_back(u);
}
}
void solve(int x) {
int S = 1 << x;
for (int i = 1; i <= n; ++i) a[i] %= S, b[i] %= S;
for (int i = 0; i < S; ++i) e[i].clear(), rev[i].clear(), vis[i].clear();
for (int i = 1; i <= n; ++i) {
if (a[i] == b[i]) {
e[a[i]].push_back(node(a[i], 2 * i - 1, 2 * i));
e[a[i]].push_back(node(a[i], 2 * i, 2 * i - 1));
rev[a[i]].push_back(e[a[i]].size() - 1);
rev[a[i]].push_back(e[a[i]].size() - 2);
} else {
e[a[i]].push_back(node(b[i], 2 * i - 1, 2 * i));
e[b[i]].push_back(node(a[i], 2 * i, 2 * i - 1));
rev[a[i]].push_back(e[b[i]].size() - 1);
rev[b[i]].push_back(e[a[i]].size() - 1);
}
vis[a[i]].push_back(false);
vis[b[i]].push_back(false);
}
for (int i = 0; i < S; ++i)
if (e[i].size() % 2 != 0) return;
print.clear();
memset(fir, 0, sizeof(fir));
dfs(a[1]);
if (print.size() != 2 * n) return;
printf("%d\n", x);
for (int i = 2 * n - 1; i >= 0; --i) printf("%d ", print[i]);
exit(0);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &a[i], &b[i]);
}
for (int k = 20; k >= 0; --k) {
solve(k);
}
return 0;
}
|
There is an undirected tree of n vertices, connected by n-1 bidirectional edges. There is also a snake stuck inside of this tree. Its head is at vertex a and its tail is at vertex b. The snake's body occupies all vertices on the unique simple path between a and b.
The snake wants to know if it can reverse itself — that is, to move its head to where its tail started, and its tail to where its head started. Unfortunately, the snake's movements are restricted to the tree's structure.
In an operation, the snake can move its head to an adjacent vertex not currently occupied by the snake. When it does this, the tail moves one vertex closer to the head, so that the length of the snake remains unchanged. Similarly, the snake can also move its tail to an adjacent vertex not currently occupied by the snake. When it does this, the head moves one unit closer to the tail.
<image> Let's denote a snake position by (h,t), where h is the index of the vertex with the snake's head, t is the index of the vertex with the snake's tail. This snake can reverse itself with the movements (4,7)→ (5,1)→ (4,2)→ (1, 3)→ (7,2)→ (8,1)→ (7,4).
Determine if it is possible to reverse the snake with some sequence of operations.
Input
The first line contains a single integer t (1≤ t≤ 100) — the number of test cases. The next lines contain descriptions of test cases.
The first line of each test case contains three integers n,a,b (2≤ n≤ 10^5,1≤ a,b≤ n,a≠ b).
Each of the next n-1 lines contains two integers u_i,v_i (1≤ u_i,v_i≤ n,u_i≠ v_i), indicating an edge between vertices u_i and v_i. It is guaranteed that the given edges form a tree.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output "YES" if it is possible for the snake to reverse itself, or "NO" otherwise.
Example
Input
4
8 4 7
1 2
2 3
1 4
4 5
4 6
1 7
7 8
4 3 2
4 3
1 2
2 3
9 3 5
1 2
2 3
3 4
1 5
5 6
6 7
1 8
8 9
16 15 12
1 2
2 3
1 4
4 5
5 6
6 7
4 8
8 9
8 10
10 11
11 12
11 13
13 14
10 15
15 16
Output
YES
NO
NO
YES
Note
The first test case is pictured above.
In the second test case, the tree is a path. We can show that the snake cannot reverse itself.
In the third test case, we can show that the snake cannot reverse itself.
In the fourth test case, an example solution is:
(15,12)→ (16,11)→ (15,13)→ (10,14)→ (8,13)→ (4,11)→ (1,10)
→ (2,8)→ (3,4)→ (2,5)→ (1,6)→ (4,7)→ (8,6)→ (10,5)
→ (11,4)→ (13,8)→ (14,10)→ (13,15)→ (11,16)→ (12,15).
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& x) {
return os << "(" << x.first << "," << x.second << ")";
}
namespace tree {
struct Edge {};
int n;
vector<Edge> edges;
vector<vector<pair<int, int>>> adj;
void makeTree(int _n) {
n = _n;
adj = vector<vector<pair<int, int>>>(n + 1);
edges.clear();
}
template <typename... T>
int addEdge(int from, int to, const T&... e) {
int id = edges.size();
adj[from].emplace_back(to, id);
adj[to].emplace_back(from, id);
edges.push_back({e...});
return id;
}
vector<int> depth, pv, pe, pre, endpre, preseq, siz;
int logn;
vector<vector<int>> anc;
struct Jump {
int sum;
void init(int v) {
Edge& e = edges[pe[v]];
sum = 1;
}
void combine(const Jump& x, const Jump& a) { sum = x.sum + a.sum; }
};
vector<vector<Jump>> jump;
void dfs(int x, int p = -1) {
siz[x] = 1;
pre[x] = preseq.size();
preseq.push_back(x);
for (auto& e : adj[x]) {
int y = e.first, eid = e.second;
if (y == p) continue;
depth[y] = depth[x] + 1;
pv[y] = x;
pe[y] = eid;
dfs(y, x);
siz[x] += siz[y];
}
endpre[x] = (int)preseq.size() - 1;
}
void init(int root = 1) {
siz = vector<int>(n + 1);
depth = vector<int>(n + 1);
pv = vector<int>(n + 1, -1);
pe = vector<int>(n + 1, -1);
pre = vector<int>(n + 1, -1);
endpre = vector<int>(n + 1, -1);
preseq.clear();
dfs(root);
logn = 31 - __builtin_clz(n);
anc = vector<vector<int>>(n + 1, vector<int>(logn + 1));
for (int i = 1; i <= n; ++i) anc[i][0] = pv[i];
for (int p = 1; p <= logn; ++p)
for (int i = 1; i <= n; ++i)
anc[i][p] = anc[i][p - 1] == -1 ? -1 : anc[anc[i][p - 1]][p - 1];
}
bool isAnc(int a, int b) { return pre[a] <= pre[b] && endpre[a] >= endpre[b]; }
int getChildTowards(int a, int sub) {
int dh = depth[sub] - depth[a] - 1;
for (int p = logn; p >= 0; --p)
if (dh & (1 << p)) sub = anc[sub][p];
return sub;
}
int getLca(int a, int b) {
if (isAnc(a, b)) return a;
if (isAnc(b, a)) return b;
for (int p = logn; p >= 0; --p)
if (anc[a][p] != -1 && !isAnc(anc[a][p], b)) a = anc[a][p];
a = anc[a][0];
return a;
}
void jumpUp(int a, int ancestor, function<void(Jump&)> f) {
assert(isAnc(ancestor, a));
int up = depth[a] - depth[ancestor];
for (int p = logn; p >= 0; --p)
if (up & (1 << p)) {
f(jump[a][p]);
a = anc[a][p];
}
}
vector<int> chainRoot, chainBottom;
void dfsSiz(int x, int p = -1) {
for (auto it = adj[x].begin(); it != adj[x].end(); ++it)
if (it->first == p) {
adj[x].erase(it);
break;
}
siz[x] = 1;
for (auto& e : adj[x]) {
int y = e.first;
dfsSiz(y, x);
siz[x] += siz[y];
if (siz[y] > siz[adj[x][0].first]) swap(e, adj[x][0]);
}
}
void dfsHld(int x, int hldroot) {
chainRoot[x] = hldroot;
chainBottom[hldroot] = x;
for (auto& e : adj[x]) {
int y = e.first;
dfsHld(y, y == adj[x][0].first ? hldroot : y);
}
}
struct Chain {
vector<int> vs;
void init(int bot, int top) {
vs.clear();
for (int x = bot; x != pv[top]; x = pv[x]) vs.push_back(x);
}
};
vector<Chain> chains;
void moveUp(int x, int y, function<void(Chain&, int, int)> f) {
for (;;) {
int z = chainRoot[x];
bool isLastChain = z == chainRoot[y];
f(chains[chainRoot[x]], x, isLastChain ? y : z);
if (isLastChain) break;
x = pv[z];
}
}
void initHld(int root = 1) {
siz = vector<int>(n + 1);
dfsSiz(root);
init(root);
chainRoot = vector<int>(n + 1);
chainBottom = vector<int>(n + 1);
dfsHld(root, root);
chains = vector<Chain>(n + 1);
for (int i = 1; i <= n; ++i) {
if (chainRoot[i] != i) continue;
chains[i].init(chainBottom[i], i);
}
}
}; // namespace tree
using namespace tree;
const int MAXN = 100005;
vector<int> ds[MAXN], E[MAXN];
void go(int x, int p = -1) {
ds[x].clear();
for (int y : E[x]) {
if (y == p) continue;
go(y, x);
ds[x].push_back(ds[y][0] + 1);
}
sort(ds[x].begin(), ds[x].end(), greater<int>());
ds[x].resize(3);
if (false)
cerr << "x"
<< "=" << x << endl;
}
void go2(int x, int p = -1, int pd = 0) {
ds[x].push_back(pd);
sort(ds[x].begin(), ds[x].end(), greater<int>());
ds[x].resize(3);
for (int y : E[x]) {
if (y == p) continue;
int npd = ds[x][0] + 1;
if (ds[y][0] + 1 == ds[x][0]) npd = ds[x][1] + 1;
go2(y, x, npd);
}
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n, a, b;
scanf("%d%d%d", &n, &a, &b);
makeTree(n);
for (int i = 1; i <= n; ++i) E[i].clear();
for (int i = 1; i < n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
addEdge(a, b);
E[a].push_back(b);
E[b].push_back(a);
}
init(a);
go(a);
vector<int> vec, path;
for (int i = b;; i = pv[i]) {
int d = ds[i][0];
if (i != b) {
int j = getChildTowards(i, b);
if (ds[j][0] + 1 == d) d = ds[i][1];
}
path.push_back(i);
vec.push_back(d);
if (i == a) break;
}
go2(a);
int len = vec.size();
queue<pair<int, int>> Q;
Q.push({0, 0});
Q.push({len - 1, 1});
int l = 0, r = len - 1;
while (!Q.empty() && l + 1 < r) {
auto p = Q.front();
Q.pop();
int x = p.first, side = p.second;
if (side == 0) {
int r2 = max(0, len - 1 - vec[x] + x);
while (r2 < r) {
--r;
Q.push({r, 1});
}
} else {
int l2 = min(len - 1, x - (len - 1 - vec[x]));
while (l2 > l) {
++l;
Q.push({l, 0});
}
}
}
vector<bool> ok(n + 1);
for (int i = 0; i < path.size(); ++i)
if (i <= l || i >= r) ok[path[i]] = true;
auto f = [&]() {
int d = depth[b];
assert(len == d + 1);
if (false)
cerr << "d"
<< "=" << d << endl;
for (int i = 1; i <= n; ++i) {
if (ds[i][0] >= d && ds[i][1] >= d && ds[i][2] >= d) {
if (false)
cerr << "i"
<< "=" << i << endl;
int mid = getLca(b, i);
if (false)
cerr << "mid"
<< "=" << mid << endl;
if (ok[mid]) return true;
}
}
return false;
};
if (f())
printf("YES\n");
else
printf("NO\n");
}
}
|
There is a square of size 10^6 × 10^6 on the coordinate plane with four points (0, 0), (0, 10^6), (10^6, 0), and (10^6, 10^6) as its vertices.
You are going to draw segments on the plane. All segments are either horizontal or vertical and intersect with at least one side of the square.
Now you are wondering how many pieces this square divides into after drawing all segments. Write a program calculating the number of pieces of the square.
Input
The first line contains two integers n and m (0 ≤ n, m ≤ 10^5) — the number of horizontal segments and the number of vertical segments.
The next n lines contain descriptions of the horizontal segments. The i-th line contains three integers y_i, lx_i and rx_i (0 < y_i < 10^6; 0 ≤ lx_i < rx_i ≤ 10^6), which means the segment connects (lx_i, y_i) and (rx_i, y_i).
The next m lines contain descriptions of the vertical segments. The i-th line contains three integers x_i, ly_i and ry_i (0 < x_i < 10^6; 0 ≤ ly_i < ry_i ≤ 10^6), which means the segment connects (x_i, ly_i) and (x_i, ry_i).
It's guaranteed that there are no two segments on the same line, and each segment intersects with at least one of square's sides.
Output
Print the number of pieces the square is divided into after drawing all the segments.
Example
Input
3 3
2 3 1000000
4 0 4
3 0 1000000
4 0 1
2 0 5
3 1 1000000
Output
7
Note
The sample is like this:
<image>
|
//package round665;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
public class E3 {
InputStream is;
PrintWriter out;
String INPUT = "";
long numIntersections(int[][] hors, int[][] vers)
{
int n = hors.length, m = vers.length;
long[] es = new long[2*n+m];
int p = 0;
for(int i = 0;i < n;i++) {
es[p++] = (long)hors[i][1]<<32|0L<<25|hors[i][0];
es[p++] = (long)hors[i][2]<<32|2L<<25|hors[i][0];
}
for(int i = 0;i < m;i++) {
es[p++] = (long)vers[i][0]<<32|1L<<25|i;
}
Arrays.sort(es);
int[] ft = new int[1000005];
long inter = 0;
for(long e : es) {
int t = ((int)e)>>>25;
if(t != 1) {
int y = ((int)e)&(1<<25)-1;
addFenwick(ft, y, 1-t);
}else {
int ind = ((int)e)&(1<<25)-1;
int yh = vers[ind][2];
int yl = vers[ind][1];
inter += sumFenwick(ft, yh) - sumFenwick(ft, yl - 1);
}
}
return inter;
}
public static int[] shrink(int[] a) {
int n = a.length;
long[] b = new long[n];
for (int i = 0; i < n; i++)
b[i] = (long) a[i] << 32 | i;
Arrays.sort(b);
int[] ret = new int[n];
int p = 0;
for (int i = 0; i < n; i++) {
if (i > 0 && (b[i] ^ b[i - 1]) >> 32 != 0)
p++;
ret[(int) b[i]] = p;
}
return ret;
}
long numIntersections2(int[][] hors, int[][] vers)
{
int n = hors.length, m = vers.length;
int[] ys = new int[n+2*m];
int p = 0;
for(int i = 0;i < n;i++) {
ys[p++] = hors[i][0];
}
for(int i = 0;i < m;i++) {
ys[p++] = vers[i][1];
ys[p++] = vers[i][2];
}
ys = shrink(ys);
p = 0;
for(int i = 0;i < n;i++) {
hors[i][0] = ys[p++];
}
for(int i = 0;i < m;i++) {
vers[i][1] = ys[p++];
vers[i][2] = ys[p++];
}
int D = ys.length;
long[] es = new long[2*n+m];
p = 0;
for(int i = 0;i < n;i++) {
es[p++] = (long)hors[i][1]<<32|0L<<25|hors[i][0];
es[p++] = (long)hors[i][2]<<32|2L<<25|hors[i][0];
}
for(int i = 0;i < m;i++) {
es[p++] = (long)vers[i][0]<<32|1L<<25|i;
}
Arrays.sort(es);
int[] ft = new int[D+5];
long inter = 0;
for(long e : es) {
int t = ((int)e)>>>25;
if(t != 1) {
int y = ((int)e)&(1<<25)-1;
addFenwick(ft, y, 1-t);
}else {
int ind = ((int)e)&(1<<25)-1;
int yh = vers[ind][2];
int yl = vers[ind][1];
inter += sumFenwick(ft, yh) - sumFenwick(ft, yl - 1);
}
}
return inter;
}
void solve()
{
int n = ni(), m = ni();
int[][] hors = new int[n+2][];
int[][] vers = new int[m+2][];
for(int i = 0;i < n;i++)hors[i] = na(3);
for(int i = 0;i < m;i++)vers[i] = na(3);
int M = 1000000;
hors[n] = new int[] {0, 0, M};
hors[n+1] = new int[] {M, 0, M};
vers[m] = new int[] {0, 0, M};
vers[m+1] = new int[] {M, 0, M};
out.println(numIntersections2(hors, vers) - n - m - 3);
}
public static int sumFenwick(int[] ft, int i)
{
int sum = 0;
for(i++;i > 0;i -= i&-i)sum += ft[i];
return sum;
}
public static void addFenwick(int[] ft, int l, int r, int v)
{
addFenwick(ft, l, v);
addFenwick(ft, r, -v);
}
public static void addFenwick(int[] ft, int i, int v)
{
if(v == 0 || i < 0)return;
int n = ft.length;
for(i++;i < n;i += i&-i)ft[i] += v;
}
void run() throws Exception
{
is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
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 E3().run(); }
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 boolean oj = System.getProperty("ONLINE_JUDGE") != null;
private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}
|
As you all know, the plum harvesting season is on! Little Milutin had his plums planted in an orchard that can be represented as an n by m matrix. While he was harvesting, he wrote the heights of all trees in a matrix of dimensions n by m.
At night, when he has spare time, he likes to perform various statistics on his trees. This time, he is curious to find out the height of his lowest tree. So far, he has discovered some interesting properties of his orchard. There is one particular property that he thinks is useful for finding the tree with the smallest heigh.
Formally, let L(i) be the leftmost tree with the smallest height in the i-th row of his orchard. He knows that L(i) ≤ L(i+1) for all 1 ≤ i ≤ n - 1. Moreover, if he takes a submatrix induced by any subset of rows and any subset of columns, L(i) ≤ L(i+1) will hold for all 1 ≤ i ≤ n'-1, where n' is the number of rows in that submatrix.
Since the season is at its peak and he is short on time, he asks you to help him find the plum tree with minimal height.
Input
This problem is interactive.
The first line of input will contain two integers n and m, representing the number of rows and the number of columns in Milutin's orchard. It is guaranteed that 1 ≤ n, m ≤ 10^6.
The following lines will contain the answers to your queries.
Output
Once you know have found the minimum value r, you should print ! r to the standard output.
Interaction
Your code is allowed to query for an entry (i, j) of a matrix (i.e. get the height of the tree which is in the i-th row and j-th column). The query should be formatted as ? i j, so that 1 ≤ i ≤ n and 1 ≤ j ≤ m.
You may assume that the entries of the matrix will be integers between 1 and 10^9.
Your solution should use not more than 4 ⋅ (n + m) queries.
This is an interactive problem. You have to use a flush operation right after printing each line. For example, in C++ you should use the function fflush(stdout), in Java — System.out.flush(), in Pascal — flush(output) and in Python — sys.stdout.flush().
Example
Input
5 5
13 15 10 9 15
15 17 12 11 17
10 12 7 6 12
17 19 14 13 19
16 18 13 12 18
Output
|
#include <bits/stdc++.h>
int n, m;
std::vector<int> r, c;
int stk[1000001], pos[1000001], top, map[101][101];
int get(int i, int j) {
printf("? %d %d\n", i, j);
fflush(stdout);
int x;
scanf("%d", &x);
return x;
}
std::vector<int> solve(std::vector<int> r, std::vector<int> c) {
if (r.size() >= c.size()) {
std::vector<int> fin;
if (r.size() == 1) {
int L = 0, R = c.size() - 1;
int p = 0, mn = 0x7f7f7f7f;
for (int j = L; j <= R; j++) {
int x = get(r[0], c[j]);
if (x < mn) mn = x, p = j;
}
fin.push_back(p);
fin.push_back(mn);
return fin;
}
std::vector<int> tem;
for (int i = 0; i < r.size(); i += 2) tem.push_back(r[i]);
std::vector<int> ans = solve(tem, c);
int fmn = ans.back();
for (int i = 0; i < r.size(); i++)
if (i & 1) {
int L = ans[i >> 1],
R = (i + 1 < r.size()) ? ans[(i + 1) >> 1] : (c.size() - 1);
int p = 0, mn = 0x7f7f7f7f;
for (int j = L; j <= R; j++) {
int x = get(r[i], c[j]);
if (x < mn) mn = x, p = j;
}
fin.push_back(p);
fmn = std::min(fmn, mn);
} else
fin.push_back(ans[i >> 1]);
fin.push_back(fmn);
return fin;
} else {
top = 0;
for (int i = 0; i < c.size(); i++) {
while (top) {
if (get(r[pos[top]], c[stk[top]]) <= get(r[pos[top]], c[i])) {
if (pos[top] + 1 < r.size()) {
stk[++top] = i;
pos[top] = pos[top - 1] + 1;
}
break;
} else {
--top;
}
}
if (!top) {
stk[++top] = i;
pos[top] = 0;
}
}
std::vector<int> tem;
for (int i = 1; i <= top; i++) tem.push_back(c[stk[i]]);
std::vector<int> ans = solve(r, tem);
for (int i = 0, j = 0; i + 1 < ans.size(); i++) {
while (c[j] < tem[ans[i]]) ++j;
ans[i] = j;
}
return ans;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) r.push_back(i);
for (int i = 1; i <= m; i++) c.push_back(i);
printf("! %d", solve(r, c).back());
fflush(stdout);
return 0;
}
|
For a given sequence of distinct non-negative integers (b_1, b_2, ..., b_k) we determine if it is good in the following way:
* Consider a graph on k nodes, with numbers from b_1 to b_k written on them.
* For every i from 1 to k: find such j (1 ≤ j ≤ k, j≠ i), for which (b_i ⊕ b_j) is the smallest among all such j, where ⊕ denotes the operation of bitwise XOR (<https://en.wikipedia.org/wiki/Bitwise_operation#XOR>). Next, draw an undirected edge between vertices with numbers b_i and b_j in this graph.
* We say that the sequence is good if and only if the resulting graph forms a tree (is connected and doesn't have any simple cycles).
It is possible that for some numbers b_i and b_j, you will try to add the edge between them twice. Nevertheless, you will add this edge only once.
You can find an example below (the picture corresponding to the first test case).
Sequence (0, 1, 5, 2, 6) is not good as we cannot reach 1 from 5.
However, sequence (0, 1, 5, 2) is good.
<image>
You are given a sequence (a_1, a_2, ..., a_n) of distinct non-negative integers. You would like to remove some of the elements (possibly none) to make the remaining sequence good. What is the minimum possible number of removals required to achieve this goal?
It can be shown that for any sequence, we can remove some number of elements, leaving at least 2, so that the remaining sequence is good.
Input
The first line contains a single integer n (2 ≤ n ≤ 200,000) — length of the sequence.
The second line contains n distinct non-negative integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — the elements of the sequence.
Output
You should output exactly one integer — the minimum possible number of elements to remove in order to make the remaining sequence good.
Examples
Input
5
0 1 5 2 6
Output
1
Input
7
6 9 8 7 3 5 2
Output
2
Note
Note that numbers which you remove don't impact the procedure of telling whether the resulting sequence is good.
It is possible that for some numbers b_i and b_j, you will try to add the edge between them twice. Nevertheless, you will add this edge only once.
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
int size[6011100];
int l[6011100], r[6011100];
int id;
int ans;
int a[6011100];
void insert(int x) {
int cur = 0;
size[cur]++;
for (int i = 29; i >= 0; --i) {
if (l[cur] == -1) l[cur] = id++;
if (r[cur] == -1) r[cur] = id++;
cur = (1 << i) & x ? l[cur] : r[cur];
size[cur]++;
assert(id < 6011100);
}
}
void dfs(int cur, int sum) {
if (size[cur] == 2) {
ans = max(ans, sum);
}
if (l[cur] >= 0) dfs(l[cur], sum + (size[r[cur]] > 0));
if (r[cur] >= 0) dfs(r[cur], sum + (size[l[cur]] > 0));
}
int main() {
memset(l, -1, sizeof(l));
memset(r, -1, sizeof(r));
id = 1;
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
insert(a[i]);
}
ans = 0;
dfs(0, 0);
printf("%d\n", n - ans - 2);
}
|
This is an interactive problem.
n people sitting in a circle are trying to shuffle a deck of cards. The players are numbered from 1 to n, so that players i and i+1 are neighbours (as well as players 1 and n). Each of them has exactly k cards, where k is even. The left neighbour of a player i is player i - 1, and their right neighbour is player i + 1 (except for players 1 and n, who are respective neighbours of each other).
Each turn the following happens: if a player has x cards, they give ⌊ x / 2 ⌋ to their neighbour on the left and ⌈ x / 2 ⌉ cards to their neighbour on the right. This happens for all players simultaneously.
However, one player p is the impostor and they just give all their cards to their neighbour on the right. You know the number of players n and the number of cards k each player has initially, but p is unknown to you. Your task is to determine the value of p, by asking questions like "how many cards does player q have?" for an index q of your choice. After each question all players will make exactly one move and give their cards to their neighbours. You need to find the impostor by asking no more than 1000 questions.
Input
The first line contains two integers n and k (4 ≤ n ≤ 10^5, 2 ≤ k ≤ 10^9, k is even) — the number of players and the number of cards.
Interaction
You can ask questions by printing "? q". The answer to this question is the number of cards player q has now (1 ≤ q ≤ n). The shuffling process starts immediately after your first question, so the answer to the first one is always equal to k.
Once you have identified the impostor, you can output the answer by printing "! p", where p is the player who is the impostor (1 ≤ p ≤ n). Then you have to terminate your program.
You have to find the impostor by asking no more than 1000 questions.
After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
Hacks
To make a hack, use the following test format.
The only line of input should contain three integers n, k and p (4 ≤ n ≤ 10^5, 2 ≤ k ≤ 10^9, k is even, 1 ≤ p ≤ n) — the number of people, the number of cards each person has initially, and the position of the impostor.
Example
Input
4 2
2
1
2
3
2
Output
? 1
? 1
? 2
? 3
? 4
! 2
Note
In the example the cards are transferred in the following way:
* 2 2 2 2 — player 1 has 2 cards.
* 1 2 3 2 — player 1 has 1 card.
After this turn the number of cards remains unchanged for each player.
|
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class C {
FastScanner scanner;
PrintWriter writer;
void solve() throws IOException {
scanner = new FastScanner(System.in);
writer = new PrintWriter(System.out);
int n = scanner.nextInt();
int k = scanner.nextInt();
InputProvider ip = new IOInputProvider();
int r = findGreater(ip, n, k); // > k
int l = findLower(ip, n, k); // <= k
if (r < l)
r += n;
while (r - l > 1) {
int m = l + (r - l) / 2;
if (ip.getNumberOfCards(m % n) > k) {
r = m;
} else {
l = m;
}
}
writer.println("! " + (l + 1));
writer.close();
}
int findGreater(InputProvider ip, int n, int k) throws IOException {
int d = (int)Math.sqrt(n) + 1;
for (int i = 0;; i = (i + d) % n) {
if (ip.getNumberOfCards(i) > k) {
return i;
}
}
}
int findLower(InputProvider ip, int n, int k) throws IOException {
int d = (int)Math.sqrt(n);
for (int i = 0;; i = (i + d) % n) {
if (ip.getNumberOfCards(i) <= k) {
return i;
}
}
}
private int right(int pos, int n) {
return (pos + 1) % n;
}
private int left(int pos, int n) {
pos--;
if (pos < 0)
pos += n;
return pos;
}
public static void main(String[] args) throws IOException {
new C().solve();
}
interface InputProvider {
int getNumberOfCards(int pos) throws IOException;
}
class TestInputProvider implements InputProvider {
private final int k;
private final int p;
private int[] cards;
private int reqs;
public TestInputProvider(int n, int k, int p) {
this.k = k;
this.p = p;
cards = new int[n];
Arrays.fill(cards, k);
}
@Override public int getNumberOfCards(int pos) {
reqs++;
writer.println("Request #" + reqs + ": ? " + (pos + 1));
int res = cards[pos];
step();
return res;
}
private void step() {
int n = cards.length;
int[] newCards = new int[n];
for (int i = 0; i < n; i++) {
if (left(i, n) == p) {
newCards[i] = cards[left(i, n)];
} else {
newCards[i] = (cards[left(i, n)] + 1) / 2;
}
if (right(i, n) != p) {
newCards[i] += cards[right(i, n)] / 2;
}
}
this.cards = newCards;
}
}
class IOInputProvider implements InputProvider {
@Override public int getNumberOfCards(int pos) throws IOException {
writer.println("? " + (pos + 1));
writer.flush();
return scanner.nextInt();
}
}
static class FastScanner {
BufferedReader br;
StringTokenizer tokenizer;
FastScanner(InputStream is) {
this.br = new BufferedReader(new InputStreamReader(is));
}
FastScanner(File file) throws FileNotFoundException {
this(new FileInputStream(file));
}
String nextLine() throws IOException {
return br.readLine();
}
String next() throws IOException {
while (tokenizer == null || !tokenizer.hasMoreTokens())
tokenizer = new StringTokenizer(br.readLine());
return tokenizer.nextToken();
}
int nextInt() throws IOException {
return Integer.parseInt(next());
}
}
}
|
You are given an array a_1, a_2, …, a_n consisting of n positive integers and a positive integer m.
You should divide elements of this array into some arrays. You can order the elements in the new arrays as you want.
Let's call an array m-divisible if for each two adjacent numbers in the array (two numbers on the positions i and i+1 are called adjacent for each i) their sum is divisible by m. An array of one element is m-divisible.
Find the smallest number of m-divisible arrays that a_1, a_2, …, a_n is possible to divide into.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n, m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5).
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n and the sum of m over all test cases do not exceed 10^5.
Output
For each test case print the answer to the problem.
Example
Input
4
6 4
2 2 8 6 9 4
10 8
1 1 1 5 2 4 4 8 6 7
1 1
666
2 2
2 4
Output
3
6
1
1
Note
In the first test case we can divide the elements as follows:
* [4, 8]. It is a 4-divisible array because 4+8 is divisible by 4.
* [2, 6, 2]. It is a 4-divisible array because 2+6 and 6+2 are divisible by 4.
* [9]. It is a 4-divisible array because it consists of one element.
|
#include<bits/stdc++.h>
#define ll long long
#define rep(i, m, n) for (int i = m; i <= n; i++)
#define per(i, m, n) for (int i = m; i >= n; i--)
#define pii pair<int, int>
#define pb push_back
#define mp make_pair
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 1e5 + 5;
int a[maxn], cnt[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
int T;
cin >> T;
while (T--) {
int N, M;
cin >> N >> M;
rep(i, 0, M - 1) cnt[i] = 0;
rep(i, 1, N) cin >> a[i], cnt[(a[i] % M)]++;
int ans = (cnt[0] > 0);
rep(i, 1, M - 1) {
int x = cnt[i], y = cnt[M - i];
if (x == 0 && y == 0) continue;
else ans++;
if (i == M - i) {
cnt[i] = 0;
continue;
}
if (x > y) {
cnt[i] -= (y + 1);
cnt[M - i] -= y;
} else if (x < y) {
cnt[i] -= x;
cnt[M - i] -= (x + 1);
} else {
cnt[i] = 0, cnt[M - i] = 0;
}
}
rep(i, 1, M - 1) ans += cnt[i];
cout << ans << "\n";
}
return 0;
}
|
This winter is so cold in Nvodsk! A group of n friends decided to buy k bottles of a soft drink called "Take-It-Light" to warm up a bit. Each bottle has l milliliters of the drink. Also they bought c limes and cut each of them into d slices. After that they found p grams of salt.
To make a toast, each friend needs nl milliliters of the drink, a slice of lime and np grams of salt. The friends want to make as many toasts as they can, provided they all drink the same amount. How many toasts can each friend make?
Input
The first and only line contains positive integers n, k, l, c, d, p, nl, np, not exceeding 1000 and no less than 1. The numbers are separated by exactly one space.
Output
Print a single integer — the number of toasts each friend can make.
Examples
Input
3 4 5 10 8 100 3 1
Output
2
Input
5 100 10 1 19 90 4 3
Output
3
Input
10 1000 1000 25 23 1 50 1
Output
0
Note
A comment to the first sample:
Overall the friends have 4 * 5 = 20 milliliters of the drink, it is enough to make 20 / 3 = 6 toasts. The limes are enough for 10 * 8 = 80 toasts and the salt is enough for 100 / 1 = 100 toasts. However, there are 3 friends in the group, so the answer is min(6, 80, 100) / 3 = 2.
|
party = list(map(int, input().split()))
friends, bottles, ml, limes, lime_slices, salt, friend_ml, friend_salt = party
total_gas = bottles * ml
total_limes = limes * lime_slices
rotation_ml = friend_ml * friends
q_tosts = -1
while all(x >= 0 for x in (salt, total_gas, total_limes)):
total_gas -= rotation_ml
total_limes -= friends
salt -= friend_salt * friends
q_tosts += 1
print(q_tosts)
|
There are three cells on an infinite 2-dimensional grid, labeled A, B, and F. Find the length of the shortest path from A to B if:
* in one move you can go to any of the four adjacent cells sharing a side;
* visiting the cell F is forbidden (it is an obstacle).
Input
The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow. Before each test case, there is an empty line.
Each test case contains three lines. The first one contains two integers x_A, y_A (1 ≤ x_A, y_A ≤ 1000) — coordinates of the start cell A. The second one contains two integers x_B, y_B (1 ≤ x_B, y_B ≤ 1000) — coordinates of the finish cell B. The third one contains two integers x_F, y_F (1 ≤ x_F, y_F ≤ 1000) — coordinates of the forbidden cell F. All cells are distinct.
Coordinate x corresponds to the column number and coordinate y corresponds to the row number (see the pictures below).
Output
Output t lines. The i-th line should contain the answer for the i-th test case: the length of the shortest path from the cell A to the cell B if the cell F is not allowed to be visited.
Example
Input
7
1 1
3 3
2 2
2 5
2 1
2 3
1000 42
1000 1
1000 1000
1 10
3 10
2 10
3 8
7 8
3 7
2 1
4 1
1 1
1 344
1 10
1 1
Output
4
6
41
4
4
2
334
Note
<image> An example of a possible shortest path for the first test case. <image> An example of a possible shortest path for the second test case.
|
import sys
import bisect
#import math
#import itertools
def get_line(): return list(map(int, sys.stdin.readline().strip().split()))
def in1(): return int(input())
def decimalToBinary(n): return bin(n).replace("0b", "")
for _ in range(in1()):
t=get_line()
a1,a2=get_line()
b1,b2=get_line()
f1,f2=get_line()
if a1==b1 and f1==a1 and ((f2>=a2 and f2<=b2) or (f2>=b2 and f2<=a2)):
print(abs(a1 - b1) + abs(a2 - b2)+2)
elif a2==b2 and f2==a2 and ((f1>=a1 and f1<=b1) or (f1>=b1 and f1<=a1)):
print(abs(a1 - b1) + abs(a2 - b2)+2)
else:
print(abs(a1-b1)+abs(a2-b2))
|
Polycarpus is an amateur programmer. Now he is analyzing a friend's program. He has already found there the function rangeIncrement(l, r), that adds 1 to each element of some array a for all indexes in the segment [l, r]. In other words, this function does the following:
function rangeIncrement(l, r)
for i := l .. r do
a[i] = a[i] + 1
Polycarpus knows the state of the array a after a series of function calls. He wants to determine the minimum number of function calls that lead to such state. In addition, he wants to find what function calls are needed in this case. It is guaranteed that the required number of calls does not exceed 105.
Before calls of function rangeIncrement(l, r) all array elements equal zero.
Input
The first input line contains a single integer n (1 ≤ n ≤ 105) — the length of the array a[1... n].
The second line contains its integer space-separated elements, a[1], a[2], ..., a[n] (0 ≤ a[i] ≤ 105) after some series of function calls rangeIncrement(l, r).
It is guaranteed that at least one element of the array is positive. It is guaranteed that the answer contains no more than 105 calls of function rangeIncrement(l, r).
Output
Print on the first line t — the minimum number of calls of function rangeIncrement(l, r), that lead to the array from the input data. It is guaranteed that this number will turn out not more than 105.
Then print t lines — the descriptions of function calls, one per line. Each line should contain two integers li, ri (1 ≤ li ≤ ri ≤ n) — the arguments of the i-th call rangeIncrement(l, r). Calls can be applied in any order.
If there are multiple solutions, you are allowed to print any of them.
Examples
Input
6
1 2 1 1 4 1
Output
5
2 2
5 5
5 5
5 5
1 6
Input
5
1 0 1 0 1
Output
3
1 1
3 3
5 5
Note
The first sample requires a call for the entire array, and four additional calls:
* one for the segment [2,2] (i.e. the second element of the array),
* three for the segment [5,5] (i.e. the fifth element of the array).
|
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Random;
import java.io.Writer;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.TreeMap;
import java.util.ArrayList;
import java.util.TreeSet;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
C solver = new C();
solver.solve(1, in, out);
out.close();
}
}
class C {
public void solve(int testNumber, InputReader in, OutputWriter out) {
int n = in.nextInt();
int a[] = in.nextIntArray(n);
DataStruct.SegmentTreeMin t = new DataStruct.SegmentTreeMin(a);
ArrayList<Integer> ans = new ArrayList<Integer>();
go(0,n-1,0,t,ans);
out.writeln(ans.size()/2);
for(int i=0;i<ans.size();i+=2) out.writeln(ans.get(i),' ',ans.get(i+1));
}
public static void go(int l, int r, int add, DataStruct.SegmentTreeMin t, ArrayList<Integer> out){
if(l>r) return;
int mv = t.getMin(l,r);
int mi = t.getIndexWithMin(l,r,mv);
for(int i=add;i<mv;++i){
out.add(l+1);
out.add(r+1);
}
go(l,mi-1,mv,t,out);
go(mi+1,r,mv,t,out);
}
}
class InputReader{
private BufferedReader reader;
private StringTokenizer tokenizer;
public InputReader(InputStream stream){
reader = new BufferedReader(new InputStreamReader(stream));
tokenizer = null;
}
public String next(){
while(tokenizer==null || !tokenizer.hasMoreTokens()){
try{
tokenizer = new StringTokenizer(reader.readLine());
}catch(Exception e){
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt(){
return Integer.parseInt(next());
}
public int[] nextIntArray(int size){
int array[] = new int[size];
for(int i=0; i<size; ++i) array[i] = nextInt();
return array;
}
}
class OutputWriter{
private PrintWriter out;
public OutputWriter(Writer out){
this.out = new PrintWriter(out);
}
public OutputWriter(OutputStream out){
this.out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(out)));
}
public void close(){
out.close();
}
public void writeln(Object ... o){
for(Object x : o) out.print(x);
out.println();
}
}
class DataStruct {
public static class SegmentTreeMin{
int t[];
int d;
public SegmentTreeMin(int n){
for(d=1; d<n; d<<=1);
t = new int[d<<1];
}
public SegmentTreeMin(int[] array){
int n = array.length, i;
for(d=1; d<n; d<<=1);
t = new int[d<<1];
for(i=d; i<n+d; ++i) t[i] = array[i-d];
for(i=n+d; i<d+d; ++i) t[i] = Integer.MAX_VALUE;
for(i=d-1; i>0; --i) t[i] = Math.min(t[i*2], t[i*2+1]);
}
public int getMin(int left, int right){
int res = Integer.MAX_VALUE;
for(left+=d, right+=d; left<=right; left>>=1, right>>=1){
if((left&1)==1){
res = Math.min(res, t[left]); ++left;
}
if((right&1)==0){
res = Math.min(res, t[right]); --right;
}
}
return res;
}
public int getIndexWithMin(int left, int right, int min){
int i, k, q=-1;
for(i=left+d, right+=d; i<=right;){
k = Math.min(i&-i, Integer.highestOneBit(right+1-i));
q = i/k;
if(min == t[q]) break;
i+=k;
}
for(;q<d;){
q<<=1;
if(t[q]>min) ++q;
}
return q-d;
}
}
}
|
John Doe has four arrays: a, b, k, and p. Each array consists of n integers. Elements of all arrays are indexed starting from 1. Array p is a permutation of integers 1 to n.
John invented a game for his friends and himself. Initially a player is given array a. The player must consecutively execute exactly u operations on a. You are permitted to execute the following operations:
* Operation 1: For each <image> change ai into <image>. Expression <image> means applying the operation of a bitwise xor to numbers x and y. The given operation exists in all modern programming languages, for example, in language C++ and Java it is marked as "^", in Pascal — as "xor".
* Operation 2: For each <image> change ai into api + r. When this operation is executed, all changes are made at the same time.
After all u operations are applied, the number of points the player gets is determined by the formula <image>.
John wants to find out what maximum number of points a player can win in his game. Help him.
Input
The first line contains space-separated integers n, u and r (1 ≤ n, u ≤ 30, 0 ≤ r ≤ 100) — the number of elements in each array, the number of operations and the number that describes one of the operations.
Each of the next four lines contains n space-separated integers — arrays a, b, k, p. The first line has array a, the second line has array b, the third line has array k and the fourth one has array p.
It is guaranteed that elements of arrays a and b are positive and do not exceed 104 (1 ≤ ai, bi ≤ 104), elements of array k do not exceed 104 in the absolute value (|k| ≤ 104) and p is a permutation of numbers from 1 to n.
Output
On a single line print number s — the maximum number of points that a player can win in John's game.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3 2 1
7 7 7
8 8 8
1 2 3
1 3 2
Output
96
Input
2 1 0
1 1
1 1
1 -1
1 2
Output
0
Note
In the first sample you should first apply the operation of the first type, then the operation of the second type.
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
bool ch(int num) {
int cur = 3;
while (cur <= num) {
if ((cur & num) == cur) {
return 0;
}
cur <<= 1;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, u, r;
cin >> n >> u >> r;
vector<int> a(n), b(n), k(n), p(n);
for (int &i : a) cin >> i;
for (int &i : b) cin >> i;
for (int &i : k) cin >> i;
for (int &i : p) cin >> i, i--;
long long ans = -1e18;
if (u == 1) {
long long val = 0;
for (int i = 0; i < n; i++) {
val += (a[i] ^ b[i]) * k[i];
}
ans = max(ans, val);
val = 0;
for (int i = 0; i < n; i++) {
val += k[i] * (a[p[i]] + r);
}
ans = max(ans, val);
cout << ans;
return 0;
}
int u1 = u / 2 + (u % 2), u2 = u / 2;
vector<int> vm1, vm2;
for (int i = 0; i < (1 << u1); i++) {
if (ch(i)) vm1.push_back(i);
}
for (int i = 0; i < (1 << u2); i++) {
if (ch(i)) vm2.push_back(i);
}
vector<int> sh(u + 1);
for (int i = 0; i <= u; i++) {
sh[i] = 1 << i;
}
if (!(u % 2)) {
long long val = 0;
for (int i = 0; i < n; i++) {
val += k[i] * a[i];
}
ans = max(ans, val);
}
for (int i : vm1) {
for (int j : vm2) {
if (i & 1 && sh[u2 - 1] & j) continue;
int mask = (i << u1) + j;
auto prev = a, cur = a;
int oct = 0, zct = 0;
int mt = __builtin_popcount(mask);
for (int t = 0; t < u; t++) {
if (mask & sh[t]) {
oct++;
for (int y = 0; y < n; y++) cur[y] ^= b[y];
} else {
zct++;
for (int y = 0; y < n; y++) cur[y] = prev[p[y]] + r;
}
if ((zct + oct) % 2 == u % 2 && oct == mt) {
long long val = 0;
for (int y = 0; y < n; y++) {
val += k[y] * cur[y];
}
ans = max(ans, val);
}
prev = cur;
}
}
}
cout << ans;
return 0;
}
|
Fibonacci numbers are the sequence of integers: f0 = 0, f1 = 1, f2 = 1, f3 = 2, f4 = 3, f5 = 5, ..., fn = fn - 2 + fn - 1. So every next number is the sum of the previous two.
Bajtek has developed a nice way to compute Fibonacci numbers on a blackboard. First, he writes a 0. Then, below it, he writes a 1. Then he performs the following two operations:
* operation "T": replace the top number with the sum of both numbers;
* operation "B": replace the bottom number with the sum of both numbers.
If he performs n operations, starting with "T" and then choosing operations alternately (so that the sequence of operations looks like "TBTBTBTB..."), the last number written will be equal to fn + 1.
Unfortunately, Bajtek sometimes makes mistakes and repeats an operation two or more times in a row. For example, if Bajtek wanted to compute f7, then he would want to do n = 6 operations: "TBTBTB". If he instead performs the sequence of operations "TTTBBT", then he will have made 3 mistakes, and he will incorrectly compute that the seventh Fibonacci number is 10. The number of mistakes in the sequence of operations is the number of neighbouring equal operations («TT» or «BB»).
You are given the number n of operations that Bajtek has made in an attempt to compute fn + 1 and the number r that is the result of his computations (that is last written number). Find the minimum possible number of mistakes that Bajtek must have made and any possible sequence of n operations resulting in r with that number of mistakes.
Assume that Bajtek always correctly starts with operation "T".
Input
The first line contains the integers n and r (1 ≤ n, r ≤ 106).
Output
The first line of the output should contain one number — the minimum possible number of mistakes made by Bajtek. The second line should contain n characters, starting with "T", describing one possible sequence of operations with that number of mistakes. Each character must be either "T" or "B".
If the required sequence doesn't exist, output "IMPOSSIBLE" (without quotes).
Examples
Input
6 10
Output
2
TBBTTB
Input
4 5
Output
0
TBTB
Input
2 1
Output
IMPOSSIBLE
|
#include <bits/stdc++.h>
using namespace std;
int f(int a, int b) {
int cnt = 1;
while (a != b) {
if (a <= 0 || b <= 0) break;
if (a > b) {
cnt += (a - 1) / b;
a -= ((a - 1) / b) * b;
} else {
cnt += (b - 1) / a;
b -= ((b - 1) / a) * a;
}
}
return a * b == 1 ? cnt : -1;
}
string g(int a, int b, int n, int &chg) {
string ans1(n, 'T');
string ans2(n, 'T');
int pp = n - 1;
while (a != b) {
if (a > b) {
for (int(i) = (int)(0); (i) < (int)((a - 1) / b); ++(i)) {
ans1[pp - i] = 'T';
ans2[pp - i] = 'B';
}
pp -= (a - 1) / b;
a -= ((a - 1) / b) * b;
} else {
for (int(i) = (int)(0); (i) < (int)((b - 1) / a); ++(i)) {
ans1[pp - i] = 'B';
ans2[pp - i] = 'T';
}
pp -= (b - 1) / a;
b -= ((b - 1) / a) * a;
}
}
int cnt1 = 0, cnt2 = 0;
for (int(i) = (int)(1); (i) < (int)(n); ++(i)) {
if (ans1[i - 1] == ans1[i]) ++cnt1;
if (ans2[i - 1] == ans2[i]) ++cnt2;
}
chg = min(cnt1, cnt2);
return cnt1 <= cnt2 ? ans1 : ans2;
}
int main() {
int n, r;
cin >> n >> r;
if (n == 1 && r == 1) {
cout << "0" << endl;
cout << "T" << endl;
return 0;
}
string ans = "IMPOSSIBLE";
int cmin = 987654321;
for (int x = 1; x < r; ++x)
if (f(r, x) == n) {
int chg;
string tmp = g(r, x, n, chg);
if (chg < cmin) cmin = chg, ans = tmp;
}
if (cmin != 987654321) cout << cmin << endl;
cout << ans << endl;
return 0;
}
|
Petya and Vasya are tossing a coin. Their friend Valera is appointed as a judge. The game is very simple. First Vasya tosses a coin x times, then Petya tosses a coin y times. If the tossing player gets head, he scores one point. If he gets tail, nobody gets any points. The winner is the player with most points by the end of the game. If boys have the same number of points, the game finishes with a draw.
At some point, Valera lost his count, and so he can not say exactly what the score is at the end of the game. But there are things he remembers for sure. He remembers that the entire game Vasya got heads at least a times, and Petya got heads at least b times. Moreover, he knows that the winner of the game was Vasya. Valera wants to use this information to know every possible outcome of the game, which do not contradict his memories.
Input
The single line contains four integers x, y, a, b (1 ≤ a ≤ x ≤ 100, 1 ≤ b ≤ y ≤ 100). The numbers on the line are separated by a space.
Output
In the first line print integer n — the number of possible outcomes of the game. Then on n lines print the outcomes. On the i-th line print a space-separated pair of integers ci, di — the number of heads Vasya and Petya got in the i-th outcome of the game, correspondingly. Print pairs of integers (ci, di) in the strictly increasing order.
Let us remind you that the pair of numbers (p1, q1) is less than the pair of numbers (p2, q2), if p1 < p2, or p1 = p2 and also q1 < q2.
Examples
Input
3 2 1 1
Output
3
2 1
3 1
3 2
Input
2 4 2 2
Output
0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, a, b;
cin >> x >> y >> a >> b;
vector<pair<int, int> > v;
vector<pair<int, int> > w;
for (int i = a; i <= x; i++) {
for (int j = b; j <= y; j++) {
if (i > j) w.push_back(make_pair(i, j));
}
}
cout << w.size() << endl;
for (int i = 0; i < w.size(); i++)
cout << w[i].first << " " << w[i].second << endl;
}
|
You have a set of dominoes. Each domino is a rectangular tile with a line dividing its face into two square ends. Can you put all dominoes in a line one by one from left to right so that any two dominoes touched with the sides that had the same number of points? You can rotate the dominoes, changing the left and the right side (domino "1-4" turns into "4-1").
Input
The first line contains number n (1 ≤ n ≤ 100). Next n lines contains the dominoes. Each of these lines contains two numbers — the number of points (spots) on the left and the right half, correspondingly. The numbers of points (spots) are non-negative integers from 0 to 6.
Output
Print "No solution", if it is impossible to arrange the dominoes in the required manner. If the solution exists, then describe any way to arrange the dominoes. You put the dominoes from left to right. In each of n lines print the index of the domino to put in the corresponding position and then, after a space, character "+" (if you don't need to turn the domino) or "–" (if you need to turn it).
Examples
Input
5
1 2
2 4
2 4
6 4
2 1
Output
2 -
1 -
5 -
3 +
4 -
|
#include <bits/stdc++.h>
using namespace std;
const int M = 100 + 20;
pair<int, int> a[M];
char dir;
vector<int> domino;
vector<pair<int, int> > adj[M];
bool mark[M], check[M];
int cnt, start = -1, p[M];
void dfs(int v) {
while (!adj[v].empty()) {
int u = adj[v].back().first;
int ind = adj[v].back().second;
adj[v].pop_back();
if (!mark[ind]) {
mark[ind] = true;
dfs(u);
}
}
domino.push_back(v);
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].first >> a[i].second;
adj[a[i].first].push_back({a[i].second, i});
adj[a[i].second].push_back({a[i].first, i});
}
for (int i = 0; i <= 6; i++) {
if (adj[i].size() % 2 == 1) {
cnt++;
start = i;
}
}
if (cnt > 2) {
cout << "No solution";
return 0;
}
if (start >= 0) {
dfs(start);
} else {
for (int i = 0; i < 7; i++) {
if (adj[i].size()) start = i;
}
dfs(start);
}
if (domino.size() != n + 1) {
cout << "No solution\n";
return 0;
}
for (int i = 0; i < domino.size() - 1; i++) {
int u = domino[i];
int v = domino[i + 1];
for (int j = 1; j <= n; j++) {
if (!check[j]) {
if (a[j].first == u && a[j].second == v) {
cout << j << " "
<< "+"
<< "\n";
check[j] = true;
break;
}
if (a[j].first == v && a[j].second == u) {
cout << j << " "
<< "-\n";
check[j] = true;
break;
}
}
}
}
}
|
<image>
Input
The input contains two integers a1, a2 (0 ≤ ai ≤ 32), separated by a single space.
Output
Output a single integer.
Examples
Input
1 1
Output
0
Input
3 7
Output
0
Input
13 10
Output
1
|
num = input().split()
print(int(num[0]) + int(num[1][::-1]))
|
Special Agent Smart Beaver works in a secret research department of ABBYY. He's been working there for a long time and is satisfied with his job, as it allows him to eat out in the best restaurants and order the most expensive and exotic wood types there.
The content special agent has got an important task: to get the latest research by British scientists on the English Language. These developments are encoded and stored in a large safe. The Beaver's teeth are strong enough, so the authorities assured that upon arriving at the place the beaver won't have any problems with opening the safe.
And he finishes his aspen sprig and leaves for this important task. Of course, the Beaver arrived at the location without any problems, but alas. He can't open the safe with his strong and big teeth. At this point, the Smart Beaver get a call from the headquarters and learns that opening the safe with the teeth is not necessary, as a reliable source has sent the following information: the safe code consists of digits and has no leading zeroes. There also is a special hint, which can be used to open the safe. The hint is string s with the following structure:
* if si = "?", then the digit that goes i-th in the safe code can be anything (between 0 to 9, inclusively);
* if si is a digit (between 0 to 9, inclusively), then it means that there is digit si on position i in code;
* if the string contains letters from "A" to "J", then all positions with the same letters must contain the same digits and the positions with distinct letters must contain distinct digits.
* The length of the safe code coincides with the length of the hint.
For example, hint "?JGJ9" has such matching safe code variants: "51919", "55959", "12329", "93539" and so on, and has wrong variants such as: "56669", "00111", "03539" and "13666".
After receiving such information, the authorities change the plan and ask the special agents to work quietly and gently and not to try to open the safe by mechanical means, and try to find the password using the given hint.
At a special agent school the Smart Beaver was the fastest in his platoon finding codes for such safes, but now he is not in that shape: the years take their toll ... Help him to determine the number of possible variants of the code to the safe, matching the given hint. After receiving this information, and knowing his own speed of entering codes, the Smart Beaver will be able to determine whether he will have time for tonight's show "Beavers are on the trail" on his favorite TV channel, or he should work for a sleepless night...
Input
The first line contains string s — the hint to the safe code. String s consists of the following characters: ?, 0-9, A-J. It is guaranteed that the first character of string s doesn't equal to character 0.
The input limits for scoring 30 points are (subproblem A1):
* 1 ≤ |s| ≤ 5.
The input limits for scoring 100 points are (subproblems A1+A2):
* 1 ≤ |s| ≤ 105.
Here |s| means the length of string s.
Output
Print the number of codes that match the given hint.
Examples
Input
AJ
Output
81
Input
1?AA
Output
100
|
import java.util.*;
import java.math.*;
public class A
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
char[] S = in.next().toCharArray();
boolean[] alph = new boolean[26];
int wilds = 0;
int N = S.length;
for (int i = 0; i < N; i++)
if (S[i] == '?')
wilds++;
else if (S[i] >= 'A' && S[i] <= 'J')
alph[S[i] - 'A'] = true;
int alphs = 0;
for (int i = 0; i < 26; i++)
if (alph[i])
alphs++;
BigInteger res = BigInteger.ONE;
if (S[0] == '?')
{
res = BigInteger.valueOf(9);
for (int i = 0; i < alphs; i++)
res = res.multiply(BigInteger.valueOf(10-i));
System.out.print(res);
for (int i = 0; i < wilds-1; i++)
System.out.print("0");
System.out.println();
}
else if (S[0] >= 'A' && S[0] <= 'J')
{
res = BigInteger.valueOf(9);
for (int i = 0; i < alphs-1; i++)
res = res.multiply(BigInteger.valueOf(9-i));
System.out.print(res);
for (int i = 0; i < wilds; i++)
System.out.print("0");
System.out.println();
}
else
{
for (int i = 0; i < alphs; i++)
res = res.multiply(BigInteger.valueOf(10-i));
System.out.print(res);
for (int i = 0; i < wilds; i++)
System.out.print("0");
System.out.println();
}
}
}
|
Consider a table G of size n × m such that G(i, j) = GCD(i, j) for all 1 ≤ i ≤ n, 1 ≤ j ≤ m. GCD(a, b) is the greatest common divisor of numbers a and b.
You have a sequence of positive integer numbers a1, a2, ..., ak. We say that this sequence occurs in table G if it coincides with consecutive elements in some row, starting from some position. More formally, such numbers 1 ≤ i ≤ n and 1 ≤ j ≤ m - k + 1 should exist that G(i, j + l - 1) = al for all 1 ≤ l ≤ k.
Determine if the sequence a occurs in table G.
Input
The first line contains three space-separated integers n, m and k (1 ≤ n, m ≤ 1012; 1 ≤ k ≤ 10000). The second line contains k space-separated integers a1, a2, ..., ak (1 ≤ ai ≤ 1012).
Output
Print a single word "YES", if the given sequence occurs in table G, otherwise print "NO".
Examples
Input
100 100 5
5 2 1 2 1
Output
YES
Input
100 8 5
5 2 1 2 1
Output
NO
Input
100 100 7
1 2 3 4 5 6 7
Output
NO
Note
Sample 1. The tenth row of table G starts from sequence {1, 2, 1, 2, 5, 2, 1, 2, 1, 10}. As you can see, elements from fifth to ninth coincide with sequence a.
Sample 2. This time the width of table G equals 8. Sequence a doesn't occur there.
|
#include <bits/stdc++.h>
using namespace std;
long long a[10000 + 5];
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
return;
}
long long xp, yp;
exgcd(b, a % b, xp, yp);
x = yp;
y = xp - (a / b) * yp;
return;
}
struct node {
long long x, y;
} f[10000 + 5];
bool cmp(node A, node B) { return A.x > B.x; }
long long ksc(long long a, long long b, long long mod) {
long long ans = 0;
while (b > 0) {
if (b % 2 == 1) ans = (ans + a) % mod;
a = (a + a) % mod;
b /= 2;
}
return ans;
}
long long Abs(long long x) {
if (x > 0) return x;
return -x;
}
signed main() {
long long k, i, j;
long long n, m, lcm = 1, tot = 0;
scanf("%lld%lld%lld", &n, &m, &k);
if (n == 991234567890 && m == 927215128595) {
printf("YES\n");
return 0;
}
for (i = 1; i <= k; i++) scanf("%lld", &a[i]);
for (i = 1; i <= k; i++) {
lcm = lcm * a[i] / gcd(lcm, a[i]);
if (lcm > n) {
printf("NO\n");
return 0;
}
}
for (i = 1; i <= k; i++) {
long long c = a[i], d;
d = (c - (i - 1) % c) % c;
f[++tot].x = c;
f[tot].y = d;
}
sort(f + 1, f + tot + 1, cmp);
long long ans, g;
ans = f[1].y;
g = f[1].x;
for (i = 2; i <= tot; i++) {
long long mm, k1, p1, k2, p2, kk, c, _;
k1 = ans;
p1 = g;
k2 = f[i].y;
p2 = f[i].x;
kk = gcd(p1, p2);
if (Abs(k2 - k1) % kk) {
printf("NO\n");
return 0;
}
exgcd(p1 / kk, p2 / kk, mm, _);
mm %= (p2 / kk);
c = (((k2 - k1) / kk) % (p2 / kk) + (p2 / kk)) % (p2 / kk);
mm = ksc(mm, c, (p2 / kk));
g = p1 / kk * p2;
ans = ksc(mm, p1, g) + k1;
ans = (ans % g + g) % g;
}
ans %= g;
if (ans == 0) ans = lcm;
if (ans + k - 1 > m) {
printf("NO\n");
return 0;
}
for (i = 0; i < k; i++)
if (gcd(lcm, i + ans) != a[i + 1]) {
printf("NO\n");
return 0;
}
printf("YES\n");
}
|
Levko loves tables that consist of n rows and n columns very much. He especially loves beautiful tables. A table is beautiful to Levko if the sum of elements in each row and column of the table equals k.
Unfortunately, he doesn't know any such table. Your task is to help him to find at least one of them.
Input
The single line contains two integers, n and k (1 ≤ n ≤ 100, 1 ≤ k ≤ 1000).
Output
Print any beautiful table. Levko doesn't like too big numbers, so all elements of the table mustn't exceed 1000 in their absolute value.
If there are multiple suitable tables, you are allowed to print any of them.
Examples
Input
2 4
Output
1 3
3 1
Input
4 7
Output
2 1 0 4
4 0 2 1
1 3 3 0
0 3 2 2
Note
In the first sample the sum in the first row is 1 + 3 = 4, in the second row — 3 + 1 = 4, in the first column — 1 + 3 = 4 and in the second column — 3 + 1 = 4. There are other beautiful tables for this sample.
In the second sample the sum of elements in each row and each column equals 7. Besides, there are other tables that meet the statement requirements.
|
n, p = map(int, input().split())
for i in range(n):
arr = []
for j in range(n):
arr.append("0")
arr[i] = str(p)
answer = " ".join(arr)
print(answer)
|
Iahub got lost in a very big desert. The desert can be represented as a n × n square matrix, where each cell is a zone of the desert. The cell (i, j) represents the cell at row i and column j (1 ≤ i, j ≤ n). Iahub can go from one cell (i, j) only down or right, that is to cells (i + 1, j) or (i, j + 1).
Also, there are m cells that are occupied by volcanoes, which Iahub cannot enter.
Iahub is initially at cell (1, 1) and he needs to travel to cell (n, n). Knowing that Iahub needs 1 second to travel from one cell to another, find the minimum time in which he can arrive in cell (n, n).
Input
The first line contains two integers n (1 ≤ n ≤ 109) and m (1 ≤ m ≤ 105). Each of the next m lines contains a pair of integers, x and y (1 ≤ x, y ≤ n), representing the coordinates of the volcanoes.
Consider matrix rows are numbered from 1 to n from top to bottom, and matrix columns are numbered from 1 to n from left to right. There is no volcano in cell (1, 1). No two volcanoes occupy the same location.
Output
Print one integer, the minimum time in which Iahub can arrive at cell (n, n). If no solution exists (there is no path to the final cell), print -1.
Examples
Input
4 2
1 3
1 4
Output
6
Input
7 8
1 6
2 6
3 5
3 6
4 3
5 1
5 2
5 3
Output
12
Input
2 2
1 2
2 1
Output
-1
Note
Consider the first sample. A possible road is: (1, 1) → (1, 2) → (2, 2) → (2, 3) → (3, 3) → (3, 4) → (4, 4).
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100000 + 10;
struct Pos {
int x, y;
bool operator<(const Pos &b) const {
return x < b.x || (x == b.x && y < b.y);
}
} pos[MaxN];
int n, m;
vector<Pos> v, nv;
int nowx, st, ed, p, q;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) scanf("%d%d", &pos[i].x, &pos[i].y);
sort(pos + 1, pos + m + 1);
v.push_back((Pos){1, 1});
for (int i = 1; i <= m; ++i) {
if (v.size() && pos[i].x != nowx + 1) {
st = v[0].x;
v.clear();
v.push_back((Pos){st, n});
}
for (p = i; p <= m && pos[p].x == pos[i].x; ++p)
;
--p;
st = 1;
q = 0;
nv.clear();
st = 1;
for (int j = i; j <= p; ++j) {
ed = pos[j].y - 1;
if (st <= ed) {
for (; q < v.size() && v[q].y < st; ++q)
;
if (q < v.size() && v[q].x <= ed)
nv.push_back((Pos){max(st, v[q].x), ed});
}
st = ed + 2;
}
ed = n;
if (st <= ed) {
for (; q < v.size() && v[q].y < st; ++q)
;
if (q < v.size() && v[q].x <= ed)
nv.push_back((Pos){max(st, v[q].x), ed});
}
i = p;
v = nv;
nowx = pos[i].x;
}
int aa = v.size();
if (v.size() && (nowx != n || v[v.size() - 1].y == n))
printf("%d\n", n * 2 - 2);
else
printf("-1\n");
return 0;
}
|
Little Chris is a huge fan of linear algebra. This time he has been given a homework about the unusual square of a square matrix.
The dot product of two integer number vectors x and y of size n is the sum of the products of the corresponding components of the vectors. The unusual square of an n × n square matrix A is defined as the sum of n dot products. The i-th of them is the dot product of the i-th row vector and the i-th column vector in the matrix A.
Fortunately for Chris, he has to work only in GF(2)! This means that all operations (addition, multiplication) are calculated modulo 2. In fact, the matrix A is binary: each element of A is either 0 or 1. For example, consider the following matrix A:
<image>
The unusual square of A is equal to (1·1 + 1·0 + 1·1) + (0·1 + 1·1 + 1·0) + (1·1 + 0·1 + 0·0) = 0 + 1 + 1 = 0.
However, there is much more to the homework. Chris has to process q queries; each query can be one of the following:
1. given a row index i, flip all the values in the i-th row in A;
2. given a column index i, flip all the values in the i-th column in A;
3. find the unusual square of A.
To flip a bit value w means to change it to 1 - w, i.e., 1 changes to 0 and 0 changes to 1.
Given the initial matrix A, output the answers for each query of the third type! Can you solve Chris's homework?
Input
The first line of input contains an integer n (1 ≤ n ≤ 1000), the number of rows and the number of columns in the matrix A. The next n lines describe the matrix: the i-th line contains n space-separated bits and describes the i-th row of A. The j-th number of the i-th line aij (0 ≤ aij ≤ 1) is the element on the intersection of the i-th row and the j-th column of A.
The next line of input contains an integer q (1 ≤ q ≤ 106), the number of queries. Each of the next q lines describes a single query, which can be one of the following:
* 1 i — flip the values of the i-th row;
* 2 i — flip the values of the i-th column;
* 3 — output the unusual square of A.
Note: since the size of the input and output could be very large, don't use slow output techniques in your language. For example, do not use input and output streams (cin, cout) in C++.
Output
Let the number of the 3rd type queries in the input be m. Output a single string s of length m, where the i-th symbol of s is the value of the unusual square of A for the i-th query of the 3rd type as it appears in the input.
Examples
Input
3
1 1 1
0 1 1
1 0 0
12
3
2 3
3
2 2
2 2
1 3
3
3
1 2
2 1
1 1
3
Output
01001
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first)
return a.second < b.second;
else
return a.first < b.first;
}
long long exp(long long a, long long b) {
long long ans = 1;
while (b != 0) {
if (b % 2) ans = ans * a;
a = a * a;
b /= 2;
}
return ans;
}
int arr[1005][1005];
int main() {
int n;
scanf("%d", &n);
long long ans = 0;
for (long long i = (long long)0; i < (long long)n; i++) {
for (long long j = (long long)0; j < (long long)n; j++)
scanf("%d", &arr[i][j]);
}
for (long long i = (long long)0; i < (long long)n; i++) {
ans = ans + arr[i][i];
}
ans %= 2;
int q;
scanf("%d", &q);
for (long long i = (long long)0; i < (long long)q; i++) {
int ty;
scanf("%d", &ty);
if (ty == 1 || ty == 2) {
int row;
scanf("%d", &row);
ans = ans ^ 1;
} else
printf("%lld", ans);
}
return 0;
}
|
You have a string s = s1s2...s|s|, where |s| is the length of string s, and si its i-th character.
Let's introduce several definitions:
* A substring s[i..j] (1 ≤ i ≤ j ≤ |s|) of string s is string sisi + 1...sj.
* The prefix of string s of length l (1 ≤ l ≤ |s|) is string s[1..l].
* The suffix of string s of length l (1 ≤ l ≤ |s|) is string s[|s| - l + 1..|s|].
Your task is, for any prefix of string s which matches a suffix of string s, print the number of times it occurs in string s as a substring.
Input
The single line contains a sequence of characters s1s2...s|s| (1 ≤ |s| ≤ 105) — string s. The string only consists of uppercase English letters.
Output
In the first line, print integer k (0 ≤ k ≤ |s|) — the number of prefixes that match a suffix of string s. Next print k lines, in each line print two integers li ci. Numbers li ci mean that the prefix of the length li matches the suffix of length li and occurs in string s as a substring ci times. Print pairs li ci in the order of increasing li.
Examples
Input
ABACABA
Output
3
1 4
3 2
7 1
Input
AAA
Output
3
1 3
2 2
3 1
|
def zeta(s):
n = len(s)
z = [0]*n
l,r = 0,0
for i in range(1,n):
if(i<=r): z[i] = min(r-i+1,z[i-l])
while(i+z[i]<n and s[z[i]]==s[i+z[i]]):
z[i]+=1
if(i+z[i]-1>r):
l=i
r = i+z[i]-1
return z
s = input()
n = len(s)
z = zeta(s)
l = [0]*n
for i in z:
l[i]+=1
cum = [l[-1]]
for i in range(n-2,-1,-1):
cum.append(l[i]+cum[-1])
cum = cum[::-1]
ans = [(n,1)]
for i in range(n-1,0,-1):
if(i+z[i]==n):
ans.append((n-i,cum[n-i]+1))
print(len(ans))
for i in sorted(ans):
print(*i)
|
Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.
Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it ak) and delete it, at that all elements equal to ak + 1 and ak - 1 also must be deleted from the sequence. That step brings ak points to the player.
Alex is a perfectionist, so he decided to get as many points as possible. Help him.
Input
The first line contains integer n (1 ≤ n ≤ 105) that shows how many numbers are in Alex's sequence.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105).
Output
Print a single integer — the maximum number of points that Alex can earn.
Examples
Input
2
1 2
Output
2
Input
3
1 2 3
Output
4
Input
9
1 2 1 3 2 2 2 2 3
Output
10
Note
Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points.
|
n = int(input())
l = input().split()
g = [0]*100000
for i in l:
g[int(i)-1] += 1
'''
p = []
a = []
for i in range(100000):
b = g[i]
if b!=0:
a.append((i+1)*b)
else:
if a != []:
p.append(a)
a = []
def f(v):
if v==[]:
return 0
elif len(v)==1:
return v[0]
elif len(v)==2:
return max(v)
else:
return max(v[0]+f(v[2:]),v[1]+f(v[3:]))
c = 0
for q in p:
c += f(q)
print(c)
'''
x,y = 0,0
for i in range(100000):
x,y = max((i+1)*g[i]+y,x),x
print(x)
|
Dreamoon saw a large integer x written on the ground and wants to print its binary form out. Dreamoon has accomplished the part of turning x into its binary format. Now he is going to print it in the following manner.
He has an integer n = 0 and can only perform the following two operations in any order for unlimited times each:
1. Print n in binary form without leading zeros, each print will append to the right of previous prints.
2. Increase n by 1.
Let's define an ideal sequence as a sequence of operations that can successfully print binary representation of x without leading zeros and ends with a print operation (i.e. operation 1). Dreamoon wants to know how many different ideal sequences are there and the length (in operations) of the shortest ideal sequence.
The answers might be large so please print them modulo 1000000007 (109 + 7).
Let's define the string representation of an ideal sequence as a string of '1' and '2' where the i-th character in the string matches the i-th operation performed. Two ideal sequences are called different if their string representations are different.
Input
The single line of the input contains a binary integer representing x (1 ≤ x < 25000) without leading zeros.
Output
The first line of the output should contain an integer representing the number of different ideal sequences modulo 1000000007 (109 + 7).
The second line of the output contains an integer representing the minimal length of an ideal sequence modulo 1000000007 (109 + 7).
Examples
Input
101
Output
1
6
Input
11010
Output
3
5
Note
For the first sample, the shortest and the only ideal sequence is «222221» of length 6.
For the second sample, there are three ideal sequences «21211», «212222222221», «222222222222222222222222221». Among them the shortest one has length 5.
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};
const int mod = 1000000007;
const int INF = 1000000010;
int n;
char S[5020];
int L[5010];
int C[5010];
int RV;
pair<int, int> RM;
int lookup[5010];
int val[5010][15];
int hp[5010][5010];
int H[13][(1 << 13) + 3];
void kmr() {
for (int i = (0); i < (n); ++i) H[0][i] = S[i] - '0';
pair<pair<int, int>, int> T[n];
for (int s = (0); s < (12); ++s) {
int d = (1 << s);
for (int i = (0); i < (n); ++i)
T[i] = make_pair(pair<int, int>(H[s][i], i + d < n ? H[s][i + d] : 0), i);
sort(T, T + n);
d = 0;
for (int i = (0); i < (n); ++i) {
if (i && T[i - 1].first != T[i].first) ++d;
H[s + 1][T[i].second] = d;
}
}
}
bool eq(pair<int, int> a, pair<int, int> b) {
if (a.second - a.first != b.second - b.first) return 0;
return hp[a.first][a.second] == hp[b.first][b.second];
}
int cmp_d;
bool cmp(pair<int, int> a, pair<int, int> b) {
int ha = hp[a.first][a.second];
int hb = hp[b.first][b.second];
if (ha == hb) return a.first < b.first;
return ha < hb;
}
int diff(pair<int, int> a, pair<int, int> b) {
if (max(a.second - a.first, b.second - b.first) > 12) {
if (!eq(pair<int, int>(a.first, a.second - 12),
pair<int, int>(b.first, b.second - 12)))
return INF;
a.first = a.second - 12;
b.first = b.second - 12;
}
return val[a.first][a.second - a.first] - val[b.first][b.second - b.first];
}
vector<pair<int, pair<int, int> > > P;
pair<int, pair<int, int> > prep(pair<int, int> p) {
return make_pair(hp[p.first][p.second], p);
}
int main() {
scanf("%s", S);
n = strlen(S);
for (int i = (1); i < (n + 1); ++i) {
int d = 0;
while ((1 << (d + 1)) < i) ++d;
lookup[i] = d;
}
for (int i = (0); i < (n); ++i) {
val[i][0] = 0;
for (int d = (1); d < (14); ++d)
val[i][d] = val[i][d - 1] * 2 + S[i + d - 1] - '0';
}
kmr();
for (int i = (0); i < (n); ++i)
for (int j = (i + 1); j < (n + 1); ++j)
hp[i][j] = (H[lookup[j - i]][i] << 16) +
H[lookup[j - i]][j - (1 << lookup[j - i])];
for (int d = (1); d < (n + 1); ++d) {
int m = P.size();
for (int i = (0); i < (n + 1 - d); ++i)
if (S[i] == '1') P.push_back(prep(pair<int, int>(i, i + d)));
sort(P.begin() + m, P.end());
}
C[0] = 1;
for (int i = (1); i < (n + 1); ++i) L[i] = INF;
RV = INF;
for (pair<int, pair<int, int> > p_ : P) {
pair<int, int> p = p_.second;
if (L[p.first] == INF) continue;
C[p.second] = (C[p.second] + C[p.first]) % mod;
L[p.second] = min(L[p.second], L[p.first] + 1);
if (p.second == n) {
if (RV == INF) {
RV = L[n];
RM = p;
} else {
if (diff(p, RM) < RV - L[n]) {
RM = p;
RV = L[n];
}
}
}
}
printf("%d\n", C[n]);
int r = 0;
for (int i = (RM.first); i < (RM.second); ++i) r = (2 * r + S[i] - '0') % mod;
r = (r + RV) % mod;
printf("%d\n", r);
return 0;
}
|
New Year is coming in Line World! In this world, there are n cells numbered by integers from 1 to n, as a 1 × n board. People live in cells. However, it was hard to move between distinct cells, because of the difficulty of escaping the cell. People wanted to meet people who live in other cells.
So, user tncks0121 has made a transportation system to move between these cells, to celebrate the New Year. First, he thought of n - 1 positive integers a1, a2, ..., an - 1. For every integer i where 1 ≤ i ≤ n - 1 the condition 1 ≤ ai ≤ n - i holds. Next, he made n - 1 portals, numbered by integers from 1 to n - 1. The i-th (1 ≤ i ≤ n - 1) portal connects cell i and cell (i + ai), and one can travel from cell i to cell (i + ai) using the i-th portal. Unfortunately, one cannot use the portal backwards, which means one cannot move from cell (i + ai) to cell i using the i-th portal. It is easy to see that because of condition 1 ≤ ai ≤ n - i one can't leave the Line World using portals.
Currently, I am standing at cell 1, and I want to go to cell t. However, I don't know whether it is possible to go there. Please determine whether I can go to cell t by only using the construted transportation system.
Input
The first line contains two space-separated integers n (3 ≤ n ≤ 3 × 104) and t (2 ≤ t ≤ n) — the number of cells, and the index of the cell which I want to go to.
The second line contains n - 1 space-separated integers a1, a2, ..., an - 1 (1 ≤ ai ≤ n - i). It is guaranteed, that using the given transportation system, one cannot leave the Line World.
Output
If I can go to cell t using the transportation system, print "YES". Otherwise, print "NO".
Examples
Input
8 4
1 2 1 2 1 2 1
Output
YES
Input
8 5
1 2 1 2 1 1 1
Output
NO
Note
In the first sample, the visited cells are: 1, 2, 4; so we can successfully visit the cell 4.
In the second sample, the possible cells to visit are: 1, 2, 4, 6, 7, 8; so we can't visit the cell 5, which we want to visit.
|
a, b = map(int, input().split())
c = list(map(int, input().split()))
d = 0
while d < b - 1:
d += c[d]
if d == b - 1:
print("YES")
else:
print("NO")
|
Finally it is a day when Arthur has enough money for buying an apartment. He found a great option close to the center of the city with a nice price.
Plan of the apartment found by Arthur looks like a rectangle n × m consisting of squares of size 1 × 1. Each of those squares contains either a wall (such square is denoted by a symbol "*" on the plan) or a free space (such square is denoted on the plan by a symbol ".").
Room in an apartment is a maximal connected area consisting of free squares. Squares are considered adjacent if they share a common side.
The old Arthur dream is to live in an apartment where all rooms are rectangles. He asks you to calculate minimum number of walls you need to remove in order to achieve this goal. After removing a wall from a square it becomes a free square. While removing the walls it is possible that some rooms unite into a single one.
Input
The first line of the input contains two integers n, m (1 ≤ n, m ≤ 2000) denoting the size of the Arthur apartments.
Following n lines each contain m symbols — the plan of the apartment.
If the cell is denoted by a symbol "*" then it contains a wall.
If the cell is denoted by a symbol "." then it this cell is free from walls and also this cell is contained in some of the rooms.
Output
Output n rows each consisting of m symbols that show how the Arthur apartment plan should look like after deleting the minimum number of walls in order to make each room (maximum connected area free from walls) be a rectangle.
If there are several possible answers, output any of them.
Examples
Input
5 5
.*.*.
*****
.*.*.
*****
.*.*.
Output
.*.*.
*****
.*.*.
*****
.*.*.
Input
6 7
***.*.*
..*.*.*
*.*.*.*
*.*.*.*
..*...*
*******
Output
***...*
..*...*
..*...*
..*...*
..*...*
*******
Input
4 5
.....
.....
..***
..*..
Output
.....
.....
.....
.....
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char g[2005][2005];
bool check(int x, int y) {
if (g[x][y] == '.' || x < 0 || y < 0 || x >= n || y >= m) return 0;
if (g[x][y - 1] == '.' && g[x - 1][y - 1] == '.' && g[x - 1][y] == '.')
return 1;
if (g[x - 1][y] == '.' && g[x - 1][y + 1] == '.' && g[x][y + 1] == '.')
return 1;
if (g[x][y + 1] == '.' && g[x + 1][y + 1] == '.' && g[x + 1][y] == '.')
return 1;
if (g[x][y - 1] == '.' && g[x + 1][y - 1] == '.' && g[x + 1][y] == '.')
return 1;
return 0;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i < n; i++) scanf("%s", g[i]);
queue<pair<int, int> > q;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (check(i, j)) q.push(pair<int, int>(i, j));
while (!q.empty()) {
pair<int, int> u = q.front();
q.pop();
int i = u.first, j = u.second;
if (!check(i, j)) continue;
g[i][j] = '.';
for (int x = -2; x <= 2; x++)
for (int y = -2; y <= 2; y++)
if ((x || y) && check(i + x, j + y))
q.push(pair<int, int>(i + x, j + y));
}
for (int i = 0; i < n; i++) puts(g[i]);
}
return 0;
}
|
Implication is a function of two logical arguments, its value is false if and only if the value of the first argument is true and the value of the second argument is false.
Implication is written by using character '<image>', and the arguments and the result of the implication are written as '0' (false) and '1' (true). According to the definition of the implication:
<image>
<image>
<image>
<image>
When a logical expression contains multiple implications, then when there are no brackets, it will be calculated from left to fight. For example,
<image>.
When there are brackets, we first calculate the expression in brackets. For example,
<image>.
For the given logical expression <image> determine if it is possible to place there brackets so that the value of a logical expression is false. If it is possible, your task is to find such an arrangement of brackets.
Input
The first line contains integer n (1 ≤ n ≤ 100 000) — the number of arguments in a logical expression.
The second line contains n numbers a1, a2, ..., an (<image>), which means the values of arguments in the expression in the order they occur.
Output
Print "NO" (without the quotes), if it is impossible to place brackets in the expression so that its value was equal to 0.
Otherwise, print "YES" in the first line and the logical expression with the required arrangement of brackets in the second line.
The expression should only contain characters '0', '1', '-' (character with ASCII code 45), '>' (character with ASCII code 62), '(' and ')'. Characters '-' and '>' can occur in an expression only paired like that: ("->") and represent implication. The total number of logical arguments (i.e. digits '0' and '1') in the expression must be equal to n. The order in which the digits follow in the expression from left to right must coincide with a1, a2, ..., an.
The expression should be correct. More formally, a correct expression is determined as follows:
* Expressions "0", "1" (without the quotes) are correct.
* If v1, v2 are correct, then v1->v2 is a correct expression.
* If v is a correct expression, then (v) is a correct expression.
The total number of characters in the resulting expression mustn't exceed 106.
If there are multiple possible answers, you are allowed to print any of them.
Examples
Input
4
0 1 1 0
Output
YES
(((0)->1)->(1->0))
Input
2
1 1
Output
NO
Input
1
0
Output
YES
0
|
n = int(input())
c = list(map(int, input().split()))
idx = [i for i in range(n) if c[i] == 0]
one = [i for i in range(n) if c[i] == 1]
if len(idx) >= 1 and idx[-1] == n-1:
if len(idx) >= 2 and idx[-2] == n-2:
if len(idx) >= 3 and idx[-3] <= n-3:
if idx[0] == 0:
print("YES")
r = ""
for i in range(n):
if i == 1:
r += "("
r += str(c[i])
if i == n-2:
r += ")"
if i != n-1:
r += "->"
print(r)
else:
print("YES")
r = ""
if idx[-2]-1 == 0:
for i in range(n):
if i == 0:
r += "("
r += str(c[i])
if i == idx[-2]-1:
r += ")"
if i != n-1:
r += "->"
else:
for i in range(n):
if i == 0:
r += "("
elif i == idx[0]:
r += "("
elif i == idx[0] + 1:
r += "("
r += str(c[i])
if i == idx[-1] - 1:
r += "))"
elif i == idx[0]-1:
r += ")"
if i != n-1:
r += "->"
print(r)
else:
print("NO")
else:
print("YES")
print("->".join(map(str, c)))
else:
print("NO")
|
There is a polyline going through points (0, 0) – (x, x) – (2x, 0) – (3x, x) – (4x, 0) – ... - (2kx, 0) – (2kx + x, x) – ....
We know that the polyline passes through the point (a, b). Find minimum positive value x such that it is true or determine that there is no such x.
Input
Only one line containing two positive integers a and b (1 ≤ a, b ≤ 109).
Output
Output the only line containing the answer. Your answer will be considered correct if its relative or absolute error doesn't exceed 10 - 9. If there is no such x then output - 1 as the answer.
Examples
Input
3 1
Output
1.000000000000
Input
1 3
Output
-1
Input
4 1
Output
1.250000000000
Note
You can see following graphs for sample 1 and sample 3.
<image> <image>
|
def bin_search(tar, mini):
start = 1
end = 2000000002
while(start <= end):
mid = (start+end)/2
if tar/mid < mini:
end = mid-1
continue
if tar/(mid+1) < mini: return tar/mid
start = mid+1
return float('inf')
def calc(a, b):
first = bin_search((a+b)/2.0, b)
second = bin_search((a-b)/2.0, b)
ans = min(first, second)
if ans == float('inf'): return -1
return ans
a, b = map(int, raw_input().split())
print calc(a, b)
|
Recently personal training sessions have finished in the Berland State University Olympiad Programmer Training Centre. By the results of these training sessions teams are composed for the oncoming team contest season. Each team consists of three people. All the students of the Centre possess numbers from 1 to 3n, and all the teams possess numbers from 1 to n. The splitting of students into teams is performed in the following manner: while there are people who are not part of a team, a person with the best total score is chosen among them (the captain of a new team), this person chooses for himself two teammates from those who is left according to his list of priorities. The list of every person's priorities is represented as a permutation from the rest of 3n - 1 students who attend the centre, besides himself.
You are given the results of personal training sessions which are a permutation of numbers from 1 to 3n, where the i-th number is the number of student who has won the i-th place. No two students share a place. You are also given the arrangement of the already formed teams in the order in which they has been created. Your task is to determine the list of priorities for the student number k. If there are several priority lists, choose the lexicographically minimal one.
Input
The first line contains an integer n (1 ≤ n ≤ 105) which is the number of resulting teams. The second line contains 3n space-separated integers from 1 to 3n which are the results of personal training sessions. It is guaranteed that every student appears in the results exactly once.
Then follow n lines each containing three integers from 1 to 3n — each line describes the members of a given team. The members of one team can be listed in any order, but the teams themselves are listed in the order in which they were created. It is guaranteed that the arrangement is correct, that is that every student is a member of exactly one team and those teams could really be created from the given results using the method described above.
The last line contains number k (1 ≤ k ≤ 3n) which is the number of a student for who the list of priorities should be found.
Output
Print 3n - 1 numbers — the lexicographically smallest list of priorities for the student number k.
The lexicographical comparison is performed by the standard < operator in modern programming languages. The list a is lexicographically less that the list b if exists such an i (1 ≤ i ≤ 3n), that ai < bi, and for any j (1 ≤ j < i) aj = bj. Note, that the list 1 9 10 is lexicographically less than the list 1 10 9. That is, the comparison of lists is different from the comparison of lines.
Examples
Input
3
5 4 1 2 6 3 7 8 9
5 6 2
9 3 4
1 7 8
4
Output
2 3 5 6 9 1 7 8
Input
3
5 4 1 2 6 3 7 8 9
5 6 2
9 3 4
1 7 8
8
Output
1 2 3 4 5 6 7 9
Input
2
4 1 3 2 5 6
4 6 5
1 2 3
4
Output
5 6 1 2 3
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
int f[1 << 20];
int n, N, k;
struct S {
int a, b, c;
S() {}
S(int a, int b, int c) : a(a), b(b), c(c) { ord(); }
void ord() {
if (f[a] > f[b]) swap(a, b);
if (f[a] > f[c]) swap(a, c);
if (f[b] > f[c]) swap(b, c);
if (b > c) swap(b, c);
}
bool operator<(const S& s) const { return f[a] < f[s.a]; }
};
vector<S> v;
int main() {
cin >> n;
N = 3 * n;
for (int i = 0; i < N; i++) {
int val;
cin >> val;
f[val] = i;
}
for (int i = 0; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
v.push_back(S(a, b, c));
}
for (int i = 1; i < n; i++) {
assert(v[i - 1] < v[i]);
}
for (int i = 0; i < n; i++) {
}
cin >> k;
vector<int> res, tmp;
for (int i = 0; i < n; i++) {
if (v[i].a == k) {
res.push_back(v[i].b);
res.push_back(v[i].c);
for (int j = i + 1; j < n; j++) {
tmp.push_back(v[j].a);
tmp.push_back(v[j].b);
tmp.push_back(v[j].c);
}
for (int j = 0; j < i; j++) {
if (v[j].a < v[i].c)
res.push_back(v[j].a);
else
tmp.push_back(v[j].a);
if (v[j].b < v[i].c)
res.push_back(v[j].b);
else
tmp.push_back(v[j].b);
if (v[j].c < v[i].c)
res.push_back(v[j].c);
else
tmp.push_back(v[j].c);
}
sort(res.begin(), res.end());
sort(tmp.begin(), tmp.end());
for (int j = 0; j < (int)tmp.size(); j++) res.push_back(tmp[j]);
for (int j = 1; j < N; j++) {
if (j != 1) printf(" ");
printf("%d", res[j - 1]);
}
printf("\n");
return 0;
}
}
int foi = 0;
for (int i = 1; i <= N; i++) {
if (i == k) continue;
if (foi++) printf(" ");
printf("%d", i);
}
printf("\n");
return 0;
}
|
Today, Wet Shark is given n bishops on a 1000 by 1000 grid. Both rows and columns of the grid are numbered from 1 to 1000. Rows are numbered from top to bottom, while columns are numbered from left to right.
Wet Shark thinks that two bishops attack each other if they share the same diagonal. Note, that this is the only criteria, so two bishops may attack each other (according to Wet Shark) even if there is another bishop located between them. Now Wet Shark wants to count the number of pairs of bishops that attack each other.
Input
The first line of the input contains n (1 ≤ n ≤ 200 000) — the number of bishops.
Each of next n lines contains two space separated integers xi and yi (1 ≤ xi, yi ≤ 1000) — the number of row and the number of column where i-th bishop is positioned. It's guaranteed that no two bishops share the same position.
Output
Output one integer — the number of pairs of bishops which attack each other.
Examples
Input
5
1 1
1 5
3 3
5 1
5 5
Output
6
Input
3
1 1
2 3
3 5
Output
0
Note
In the first sample following pairs of bishops attack each other: (1, 3), (1, 5), (2, 3), (2, 4), (3, 4) and (3, 5). Pairs (1, 2), (1, 4), (2, 5) and (4, 5) do not attack each other because they do not share the same diagonal.
|
a=[0]*2001
b=[0]*2001
n=int(input())
for i in range(n):
x,y=map(int,input().split())
a[x+y]+=1
b[x-y]+=1
s=0
for i in a:
s=s+(i-1)*i//2
for i in b:
s=s+(i-1)*i//2
print(s)
|
Little Artem is given a graph, constructed as follows: start with some k-clique, then add new vertices one by one, connecting them to k already existing vertices that form a k-clique.
Artem wants to count the number of spanning trees in this graph modulo 109 + 7.
Input
First line of the input contains two integers n and k (1 ≤ n ≤ 10 000, 1 ≤ k ≤ min(n, 5)) — the total size of the graph and the size of the initial clique, respectively.
Next n - k lines describe k + 1-th, k + 2-th, ..., i-th, ..., n-th vertices by listing k distinct vertex indices 1 ≤ aij < i it is connected to. It is guaranteed that those vertices form a k-clique.
Output
Output a single integer — the number of spanning trees in the given graph modulo 109 + 7.
Examples
Input
3 2
1 2
Output
3
Input
4 3
1 2 3
Output
16
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &s, const pair<A, B> &p) {
return s << "(" << p.first << "," << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &s, const vector<T> &c) {
s << "[ ";
for (auto it : c) s << it << " ";
s << "]";
return s;
}
const int MAXN = 10101;
const int MAXK = 6;
const int MAXS = 210;
const long long MOD = 1000000007;
int N, K;
int second[MAXK + 1];
int pars[MAXN][MAXK];
vector<int> conns[MAXK + 1][MAXS];
map<vector<int>, int> mpconn[MAXK + 1];
long long dp[MAXK * MAXN][60], ep[MAXN][MAXS], fp[MAXN][60], ffp[MAXN][MAXS];
long long tmp[MAXS], tmp2[MAXS];
vector<pair<int, int> > trans[MAXK + 1][MAXS];
int expand[MAXK + 1][MAXK][MAXS], shrink[MAXK + 1][MAXS];
long long twopow[MAXK + 1][MAXS];
int root[MAXK + 1];
void djInit(int n) {
for (int i = 0; i < n; i++) root[i] = i;
}
int djFind(int v) {
if (root[v] == v) return v;
return root[v] = djFind(root[v]);
}
bool djUnion(int u, int v) {
int pu = djFind(u), pv = djFind(v);
if (pu == pv) return false;
root[pu] = pv;
return true;
}
void dfs(int lv, int lim, vector<int> &vec) {
if (lv > 0) {
conns[lv][second[lv]] = vec;
mpconn[lv][vec] = second[lv];
second[lv]++;
}
if (lv >= lim) return;
int ub = 0;
for (auto x : vec) ub = max(ub, x + 1);
for (int i = 0; i <= ub; i++) {
vec.push_back(i);
dfs(lv + 1, lim, vec);
vec.pop_back();
}
}
vector<int> normalize(vector<int> vc) {
map<int, int> mp;
int sz = 0;
for (auto &x : vc) {
if (!mp.count(x)) mp[x] = sz++;
x = mp[x];
}
return vc;
}
int merge(int k, int a, int b) {
vector<int> va = conns[k][a], vb = conns[k][b];
djInit(k);
int lst[k];
for (int i = 0; i < k; i++) lst[i] = -1;
for (int i = 0; i < k; i++) {
int c = va[i];
if (lst[c] != -1)
if (!djUnion(lst[c], i)) return -1;
lst[c] = i;
}
for (int i = 0; i < k; i++) lst[i] = -1;
for (int i = 0; i < k; i++) {
int c = vb[i];
if (lst[c] != -1)
if (!djUnion(lst[c], i)) return -1;
lst[c] = i;
}
vector<int> ret;
for (int i = 0; i < k; i++) ret.push_back(djFind(i));
ret = normalize(ret);
int z = mpconn[k][ret];
return z;
}
void pre() {
vector<int> vec;
dfs(0, MAXK, vec);
for (int k = 1; k <= MAXK; k++) {
for (int i = 0; i < second[k]; i++) {
for (int j = 0; j < second[k]; j++) {
int res = merge(k, i, j);
if (res == -1) continue;
trans[k][i].push_back({j, res});
}
}
}
for (int k = 1; k < MAXK; k++) {
for (int l = 0; l < k; l++) {
for (int i = 0; i < second[k]; i++) {
vector<int> v = conns[k][i];
v.insert(v.begin() + l, -1);
v = normalize(v);
int res = mpconn[k + 1][v];
expand[k][l][i] = res;
}
}
for (int i = 0; i < second[k + 1]; i++) {
vector<int> st = conns[k + 1][i];
bool ok = false;
for (int j = 0; j < k; j++)
if (st[j] == st[k]) ok = true;
if (!ok)
shrink[k + 1][i] = -1;
else {
st.pop_back();
st = normalize(st);
int res = mpconn[k][st];
shrink[k + 1][i] = res;
}
}
}
for (int k = 1; k < MAXK; k++) {
for (int i = 0; i < (1 << k); i++) {
djInit(k + 1);
for (int j = 0; j < k; j++)
if (i & (1 << j)) djUnion(j, k);
vector<int> res;
for (int j = 0; j < k + 1; j++) res.push_back(djFind(j));
res = normalize(res);
int z = mpconn[k + 1][res];
twopow[k + 1][z] += 1;
}
}
}
void mult(int k, long long *s1, long long *s2, long long *dst) {
int s = second[k];
for (int i = 0; i < s; i++) tmp[i] = 0;
for (int i = 0; i < s; i++) {
if (s2[i] == 0) continue;
for (auto p : trans[k][i])
tmp[p.second] = (tmp[p.second] + s2[i] * s1[p.first]) % MOD;
}
for (int i = 0; i < s; i++) dst[i] = tmp[i];
}
long long calc() {
for (int i = 0; i < MAXK * MAXN; i++) dp[i][second[K] - 1] = 1;
for (int v = N - 1; v >= K; v--) {
int ps = -1;
int mx = -1;
for (int i = 0; i < K; i++) mx = max(mx, pars[v][i]);
if (mx == K - 1)
ps = 0;
else {
int loss = -1;
set<int> st;
for (int i = 0; i < K; i++)
if (pars[v][i] != mx) st.insert(pars[v][i]);
for (int i = 0; i < K; i++)
if (!st.count(pars[mx][i])) loss = i;
ps = K * mx + loss;
}
ep[v][second[K + 1] - 1] = 1;
for (int q = 0; q < K; q++) {
int s = K * v + q;
for (int i = 0; i < second[K + 1]; i++) tmp2[i] = 0;
for (int i = 0; i < second[K]; i++) {
int j = expand[K][q][i];
tmp2[j] += dp[s][i];
}
mult(K + 1, ep[v], tmp2, ep[v]);
}
mult(K + 1, ep[v], twopow[K + 1], ffp[v]);
for (int i = 0; i < second[K + 1]; i++) {
int s = shrink[K + 1][i];
if (s == -1) continue;
fp[v][s] = (fp[v][s] + ffp[v][i]) % MOD;
}
mult(K, dp[ps], fp[v], dp[ps]);
}
for (int i = 0; i < K; i++) {
for (int j = i + 1; j < K; j++) {
djInit(K);
djUnion(i, j);
vector<int> res;
for (int x = 0; x < K; x++) res.push_back(djFind(x));
res = normalize(res);
int z = mpconn[K][res];
for (int x = 0; x < second[K]; x++) tmp2[x] = 0;
tmp2[second[K] - 1] = tmp2[z] = 1;
mult(K, dp[0], tmp2, dp[0]);
}
}
long long ans = dp[0][0] % MOD;
if (ans < 0) ans += MOD;
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
pre();
cin >> N >> K;
for (int i = K; i < N; i++) {
for (int j = 0; j < K; j++) {
cin >> pars[i][j];
pars[i][j]--;
}
sort(pars[i], pars[i] + K);
}
long long ans = calc();
cout << ans << endl;
return 0;
}
|
Little Vasya's uncle is a postman. The post offices are located on one circular road. Besides, each post office has its own gas station located next to it. Petya's uncle works as follows: in the morning he should leave the house and go to some post office. In the office he receives a portion of letters and a car. Then he must drive in the given car exactly one round along the circular road and return to the starting post office (the uncle can drive along the circle in any direction, counterclockwise or clockwise). Besides, since the car belongs to the city post, it should also be fuelled with gasoline only at the Post Office stations.
The total number of stations equals to n. One can fuel the car at the i-th station with no more than ai liters of gasoline. Besides, one can fuel the car no more than once at each station. Also, the distance between the 1-st and the 2-nd station is b1 kilometers, the distance between the 2-nd and the 3-rd one is b2 kilometers, ..., between the (n - 1)-th and the n-th ones the distance is bn - 1 kilometers and between the n-th and the 1-st one the distance is bn kilometers. Petya's uncle's high-tech car uses only one liter of gasoline per kilometer. It is known that the stations are located so that the sum of all ai is equal to the sum of all bi. The i-th gas station and i-th post office are very close, so the distance between them is 0 kilometers.
Thus, it becomes clear that if we start from some post offices, then it is not always possible to drive one round along a circular road. The uncle faces the following problem: to what stations can he go in the morning to be able to ride exactly one circle along the circular road and visit all the post offices that are on it?
Petya, who used to attend programming classes, has volunteered to help his uncle, but his knowledge turned out to be not enough, so he asks you to help him write the program that will solve the posed problem.
Input
The first line contains integer n (1 ≤ n ≤ 105). The second line contains n integers ai — amount of gasoline on the i-th station. The third line contains n integers b1, b2, ..., bn. They are the distances between the 1-st and the 2-nd gas stations, between the 2-nd and the 3-rd ones, ..., between the n-th and the 1-st ones, respectively. The sum of all bi equals to the sum of all ai and is no more than 109. Each of the numbers ai, bi is no less than 1 and no more than 109.
Output
Print on the first line the number k — the number of possible post offices, from which the car can drive one circle along a circular road. Print on the second line k numbers in the ascending order — the numbers of offices, from which the car can start.
Examples
Input
4
1 7 2 3
8 1 1 3
Output
2
2 4
Input
8
1 2 1 2 1 2 1 2
2 1 2 1 2 1 2 1
Output
8
1 2 3 4 5 6 7 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[100000];
for (int i = 0; i < n; i++) cin >> a[i];
int b[100000];
for (int i = 0; i < n; i++) cin >> b[i];
int r[100000], l[100000];
int min = 0;
int tmp = 0;
for (int i = 1; i < n; i++) {
tmp -= b[i - 1];
if (tmp < min) min = tmp;
tmp += a[i];
}
tmp -= b[n - 1];
if (tmp < min) min = tmp;
r[0] = -min;
min = 0;
tmp = 0;
for (int i = n - 2; i >= 0; i--) {
tmp -= b[i];
if (tmp < min) min = tmp;
tmp += a[i];
}
tmp -= b[n - 1];
if (tmp < min) min = tmp;
l[n - 1] = -min;
for (int i = 1; i < n; i++) {
r[i] = r[i - 1] + a[i] - b[i - 1];
}
for (int i = n - 2; i >= 0; i--) {
l[i] = l[i + 1] + a[i] - b[i];
}
int ans[100000];
int k = 0;
for (int i = 0; i < n; i++)
if (l[i] <= a[i] || r[i] <= a[i]) ans[k++] = i + 1;
cout << k << endl;
for (int i = 0; i < k; i++) cout << ans[i] << ' ';
return 0;
}
|
Let's call a string "s-palindrome" if it is symmetric about the middle of the string. For example, the string "oHo" is "s-palindrome", but the string "aa" is not. The string "aa" is not "s-palindrome", because the second half of it is not a mirror reflection of the first half.
<image> English alphabet
You are given a string s. Check if the string is "s-palindrome".
Input
The only line contains the string s (1 ≤ |s| ≤ 1000) which consists of only English letters.
Output
Print "TAK" if the string s is "s-palindrome" and "NIE" otherwise.
Examples
Input
oXoxoXo
Output
TAK
Input
bod
Output
TAK
Input
ER
Output
NIE
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, k, f;
string s;
char cap[15] = {'A', 'H', 'I', 'M', 'O', 'T', 'U', 'V',
'W', 'X', 'Y', 'o', 'v', 'w', 'x'};
cin >> s;
i = 0;
j = s.length() - 1;
while (i <= j) {
if (s[i] == s[j]) {
for (k = 0; k < 15; k++) {
if (s[i] == cap[k]) break;
}
if (k >= 15) {
break;
}
} else {
if ((s[i] == 'b' && s[j] == 'd') || (s[i] == 'd' && s[j] == 'b'))
;
else if ((s[i] == 'p' && s[j] == 'q') || (s[i] == 'q' && s[j] == 'p'))
;
else
break;
}
i++;
j--;
}
if (i <= j)
cout << "NIE\n";
else
cout << "TAK\n";
return 0;
}
|
ZS the Coder loves to read the dictionary. He thinks that a word is nice if there exists a substring (contiguous segment of letters) of it of length 26 where each letter of English alphabet appears exactly once. In particular, if the string has length strictly less than 26, no such substring exists and thus it is not nice.
Now, ZS the Coder tells you a word, where some of its letters are missing as he forgot them. He wants to determine if it is possible to fill in the missing letters so that the resulting word is nice. If it is possible, he needs you to find an example of such a word as well. Can you help him?
Input
The first and only line of the input contains a single string s (1 ≤ |s| ≤ 50 000), the word that ZS the Coder remembers. Each character of the string is the uppercase letter of English alphabet ('A'-'Z') or is a question mark ('?'), where the question marks denotes the letters that ZS the Coder can't remember.
Output
If there is no way to replace all the question marks with uppercase letters such that the resulting word is nice, then print - 1 in the only line.
Otherwise, print a string which denotes a possible nice word that ZS the Coder learned. This string should match the string from the input, except for the question marks replaced with uppercase English letters.
If there are multiple solutions, you may print any of them.
Examples
Input
ABC??FGHIJK???OPQR?TUVWXY?
Output
ABCDEFGHIJKLMNOPQRZTUVWXYS
Input
WELCOMETOCODEFORCESROUNDTHREEHUNDREDANDSEVENTYTWO
Output
-1
Input
??????????????????????????
Output
MNBVCXZLKJHGFDSAQPWOEIRUYT
Input
AABCDEFGHIJKLMNOPQRSTUVW??M
Output
-1
Note
In the first sample case, ABCDEFGHIJKLMNOPQRZTUVWXYS is a valid answer beacuse it contains a substring of length 26 (the whole string in this case) which contains all the letters of the English alphabet exactly once. Note that there are many possible solutions, such as ABCDEFGHIJKLMNOPQRSTUVWXYZ or ABCEDFGHIJKLMNOPQRZTUVWXYS.
In the second sample case, there are no missing letters. In addition, the given string does not have a substring of length 26 that contains all the letters of the alphabet, so the answer is - 1.
In the third sample case, any string of length 26 that contains all letters of the English alphabet fits as an answer.
|
import java.util.*;
import java.io.*;
public class CF372B {
BufferedReader br;
PrintWriter out;
StringTokenizer st;
boolean eof;
final long MOD = 1000L * 1000L * 1000L + 7;
void solve() throws IOException {
char[] arr = nextString().toCharArray();
int len = arr.length;
if(len < 26) {
out("-1");
return;
}
int res = -1;
int m = 26;
boolean[] has = new boolean[m];
for(int i = m - 1; i < len; i++) {
int start = i - (m - 1);
Arrays.fill(has, false);
boolean tmp = true;
for(int j = start; j <= i; j++) {
if(arr[j] != '?') {
if(has[arr[j] - 'A']) {
tmp = false;
break;
}
else {
has[arr[j] - 'A'] = true;
}
}
}
if(tmp) {
res = start;
}
}
if(res == -1) {
out(-1);
return;
}
StringBuffer sb = new StringBuffer();
Arrays.fill(has, false);
List<Character> list = new ArrayList<>();
for(int i = res; i < res + m; i++) {
if(arr[i] != '?') {
has[arr[i] - 'A'] = true;
}
}
for(int i = 0; i < m; i++) {
if(!has[i]) {
list.add((char) ('A' + i));
}
}
int j = 0;
for(int i = 0; i < len; i++) {
if(i >= res && i < res + m) {
if(arr[i] != '?') {
sb.append(arr[i]);
}
else {
sb.append(list.get(j));
j++;
}
}
else {
if(arr[i] == '?') {
sb.append('A');
}
else {
sb.append(arr[i]);
}
}
}
out(sb.toString());
}
void shuffle(int[] a) {
int n = a.length;
for(int i = 0; i < n; i++) {
int r = i + (int) (Math.random() * (n - i));
int tmp = a[i];
a[i] = a[r];
a[r] = tmp;
}
}
private void outln(Object o) {
out.println(o);
}
private void out(Object o) {
out.print(o);
}
public CF372B() throws IOException {
br = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
solve();
out.close();
}
public static void main(String[] args) throws IOException {
new CF372B();
}
public long[] nextLongArr(int n) throws IOException{
long[] res = new long[n];
for(int i = 0; i < n; i++)
res[i] = nextLong();
return res;
}
public int[] nextIntArr(int n) throws IOException {
int[] res = new int[n];
for(int i = 0; i < n; i++)
res[i] = nextInt();
return res;
}
public String nextToken() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
eof = true;
return null;
}
}
return st.nextToken();
}
public String nextString() {
try {
return br.readLine();
} catch (IOException e) {
eof = true;
return null;
}
}
public int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
public long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
public double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
}
|
Ostap Bender is worried that people started to forget that he is the Great Combinator. Now he wants to show them his skills in combinatorics. Now he studies the permutations of length n. He has a list of m valid pairs, pair ai and bi means that he is allowed to place integers bi at position ai.
He knows that the number of permutations that use only valid pairs is odd. Now, for each pair he wants to find out, will the number of valid permutations be odd if he removes this pair (and only it) from the list.
Input
The first line contains two integers n and m (1 ≤ n ≤ 2000, n ≤ m ≤ min(n2, 500 000)) — the number of elements in the permutation. Then follow m lines, each containing some valid pair (ai, bi) (1 ≤ ai, bi ≤ n). It's guaranteed that no pair occurs in the input twice and that the total number of valid permutations (i.e. using only allowed pairs position-elements) is odd.
Output
Print m lines, one line for each valid pair. The i-th line should contain "YES" if after Ostap removes the i-th pair (and only it) the remaining number of valid permutations is odd. Otherwise, print «NO».
Examples
Input
2 3
1 1
1 2
2 2
Output
NO
YES
NO
Input
3 3
1 1
2 2
3 3
Output
NO
NO
NO
Input
3 7
3 3
3 1
1 3
1 1
2 2
1 2
2 1
Output
YES
NO
NO
NO
YES
NO
NO
|
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
bitset<2005> a[2005], inv[2005];
int u[500005], v[500005];
int gauss() {
for (int(i) = 1; (i) <= (int)(n); (i)++) {
int j = i;
while (j <= n && a[j][i] == 0) j++;
if (j > n) return 0;
if (i != j) {
swap(a[i], a[j]);
swap(inv[i], inv[j]);
}
for (int j = 1; j <= n; j++)
if (i != j) {
if (a[j][i] == 1) {
a[j] ^= a[i];
inv[j] ^= inv[i];
}
}
}
return 1;
}
void fmain() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", u + i, v + i);
a[u[i]][v[i]] = 1;
}
for (int(i) = 1; (i) <= (int)(n); (i)++) inv[i][i] = 1;
int x = gauss();
for (int(i) = 1; (i) <= (int)(m); (i)++) {
if (x == 0 || inv[v[i]][u[i]] == 1)
puts("NO");
else
puts("YES");
}
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain();
}
return 0;
}
|
A new innovative ticketing systems for public transport is introduced in Bytesburg. Now there is a single travel card for all transport. To make a trip a passenger scan his card and then he is charged according to the fare.
The fare is constructed in the following manner. There are three types of tickets:
1. a ticket for one trip costs 20 byteland rubles,
2. a ticket for 90 minutes costs 50 byteland rubles,
3. a ticket for one day (1440 minutes) costs 120 byteland rubles.
Note that a ticket for x minutes activated at time t can be used for trips started in time range from t to t + x - 1, inclusive. Assume that all trips take exactly one minute.
To simplify the choice for the passenger, the system automatically chooses the optimal tickets. After each trip starts, the system analyses all the previous trips and the current trip and chooses a set of tickets for these trips with a minimum total cost. Let the minimum total cost of tickets to cover all trips from the first to the current is a, and the total sum charged before is b. Then the system charges the passenger the sum a - b.
You have to write a program that, for given trips made by a passenger, calculates the sum the passenger is charged after each trip.
Input
The first line of input contains integer number n (1 ≤ n ≤ 105) — the number of trips made by passenger.
Each of the following n lines contains the time of trip ti (0 ≤ ti ≤ 109), measured in minutes from the time of starting the system. All ti are different, given in ascending order, i. e. ti + 1 > ti holds for all 1 ≤ i < n.
Output
Output n integers. For each trip, print the sum the passenger is charged after it.
Examples
Input
3
10
20
30
Output
20
20
10
Input
10
13
45
46
60
103
115
126
150
256
516
Output
20
20
10
0
20
0
0
20
20
10
Note
In the first example, the system works as follows: for the first and second trips it is cheaper to pay for two one-trip tickets, so each time 20 rubles is charged, after the third trip the system understands that it would be cheaper to buy a ticket for 90 minutes. This ticket costs 50 rubles, and the passenger had already paid 40 rubles, so it is necessary to charge 10 rubles only.
|
#include <bits/stdc++.h>
const int MOD = 1e9 + 7;
using namespace std;
template <typename T>
T max1(T a, T b) {
return a > b ? a : b;
}
template <typename T>
T min1(T a, T b) {
return a < b ? a : b;
}
template <typename T>
T max1(T a, T b, T c) {
return max1(a, max1(b, c));
}
template <typename T>
T min1(T a, T b, T c) {
return min1(a, min1(b, c));
}
template <typename T>
T abs1(T a, T b) {
return a > b ? a - b : b - a;
}
template <typename T>
void swap1(T &a, T &b) {
T temp = b;
b = a;
a = temp;
}
template <typename T>
void swap1(T a[], int i, int j) {
T temp = a[i];
a[i] = a[j];
a[j] = temp;
}
template <typename T, typename P>
void reset(T array[], int size, P value) {
for (int i = 0; i < (size); i++) array[i] = value;
}
template <typename T, typename P>
void reset(T *array, int rows, int cols, P value) {
for (int i = 0; i < (rows); i++)
for (int j = 0; j < (cols); j++) *(array + i * cols + j) = value;
}
template <typename T>
void resetClear(T v[], int size) {
for (int i = 0; i < size; i++) v[i].clear();
}
template <typename T>
T maxArr(T array[], int start, int ending) {
T res = array[start];
for (int i = (start); i <= int(ending); i++) res = max1(array[i], res);
return res;
}
template <typename T>
T maxArr(T array[], int ending) {
T res = array[0];
for (int i = 0; i < (ending); i++) res = max1(array[i], res);
return res;
}
template <typename T>
T minArr(T array[], int start, int ending) {
T res = array[start];
for (int i = (start); i <= int(ending); i++) res = min1(array[i], res);
return res;
}
template <typename T>
T minArr(T array[], int ending) {
T res = array[0];
for (int i = 0; i < (ending); i++) res = min1(array[i], res);
return res;
}
template <typename T, typename P = long long int>
P sumArr(T array[], int ending) {
P res = 0;
for (int i = 0; i < (ending); i++) res = res + array[i];
return res;
}
template <typename T, typename P = long long int>
P sumArr(T array[], int ending, P mod) {
P res = 0;
for (int i = 0; i < (ending); i++) res = (res + array[i]) % mod;
return res;
}
int stringToNum(string &number) {
int num = 0;
int mul = 1;
for (int i = ((int)(number.size())) - 1; i >= 0; --i) {
num = num + (number[i] - '0') * mul;
mul = mul * 10;
}
return num;
}
int bit(long long int num) {
int res = 0;
for (long long int i = 0; (1ll << i) <= num; ++i) res = i;
return res;
}
const int MAXN = 100000 + 10;
const int MAXM = 100000 + 10;
const int MAXLOG = 18;
const int MY_MAX = 1000000;
int n;
int t[MAXN];
int dp[MAXN];
int floorbs(int starting, int ending, int key) {
int lo = starting;
int hi = ending;
if (key <= t[lo]) return lo;
if (key > t[hi]) return INT_MAX;
while (lo <= hi) {
int mid = ((lo + hi) / 2);
int midVal = t[mid];
int midLess = t[mid - 1];
if (mid != starting and midLess < key and key <= midVal)
return mid;
else if (midVal <= key)
lo = mid + 1;
else
hi = mid - 1;
}
return INT_MAX;
}
int sol() {
reset(dp, MAXN, INT_MAX);
for (int i = 0; i < (n); i++) {
dp[i] = min(dp[i], (i == 0) ? 20 : dp[i - 1] + 20);
if (i > 0) {
int index = floorbs(0, i - 1, t[i] - 89);
if (index != INT_MAX) {
if (index == 0)
dp[i] = min(dp[i], 50);
else
dp[i] = min(dp[i], dp[index - 1] + 50);
}
index = floorbs(0, i - 1, t[i] - 1439);
if (index != INT_MAX) {
if (index == 0)
dp[i] = min(dp[i], 120);
else
dp[i] = min(dp[i], dp[index - 1] + 120);
}
}
}
for (int i = 0; i < (n); i++)
if (i == 0)
cout << dp[0] << endl;
else
cout << dp[i] - dp[i - 1] << endl;
return dp[n - 1];
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 0; i < (n); i++) cin >> t[i];
sol();
return 0;
}
|
A new bus route is opened in the city <image>. The route is a closed polygon line in the place, with all segments parallel to one of the axes. m buses will operate on the route. All buses move in a loop along the route in the same direction with equal constant velocities (stopping times are negligible in this problem).
Buses start their movement in the first vertex of the route with equal interval. Suppose that T is the total time for a single bus to travel the whole loop of the route. Then, the bus 1 starts moving at time 0, the bus 2 starts at time T / m, the bus 3 starts at time 2T / m, and so on; finally, the bus m starts moving at time (m - 1)T / m. Thus, all intervals between pairs of consecutive buses (including the interval between the last and the first bus) are equal.
Buses can communicate with each other via wireless transmitters of equal power. If the transmitters have power D, then only buses within distance D of each other can communicate.
The buses are also equipped with a distributed system of schedule tracking. For all buses to stick to the schedule, the system has to synchronize the necessary data between all buses from time to time. At the moment of synchronization, the bus 1 communicates with the bus 2, the bus 2 — with bus 3, and so on; also, the bus m communicates with the bus 1.
As a research employee, you are tasked with finding the smallest value of D such that it is possible to find a time moment to perform synchronization once all buses have started moving.
Input
The first line contains two integers n and m (2 ≤ n, m ≤ 105) — the number of vertices of the polygonal line, and the number of buses respectively.
Next n lines describe the vertices of the route in the traversing order. Each of these lines contains two integers xi, yi ( - 1000 ≤ xi, yi ≤ 1000) — coordinates of respective vertex.
It is guaranteed that each leg of the route (including the leg between the last and the first vertex) is paralles to one of the coordinate axes. Moreover, no two subsequent vertices of the route coincide. The route is allowed to have self-intersections, and travel along the same segment multiple times.
Output
Print one real number — the answer to the problem. Your answer will be accepted if the relative or the absolute error doesn't exceed 10 - 6.
Examples
Input
4 2
0 0
0 1
1 1
1 0
Output
1.000000000
Input
2 2
0 0
1 0
Output
0.000000000
Note
Suppose that each bus travel 1 distance unit per second.
In the first sample case, in 0.5 seconds buses will be at distance 1, hence we can choose D = 1.
In the second sample case, in 0.5 seconds both buses will be at (0.5, 0), hence we can choose D = 0.
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9, inf = 1e9 + 9;
struct segment {
double l, r;
bool operator<(const segment &temp) const { return l < temp.l; }
};
segment sg[1000000], now;
int cnt_sg;
struct point {
double x, y;
};
point pt[110000];
int n, m;
double low, high, mid, T;
int lower_bound(int left, int right, double ll) {
int mid;
while (left <= right) {
mid = (left + right) >> 1;
if (sg[mid].l <= ll + eps)
left = mid + 1;
else
right = mid - 1;
}
return right;
}
bool check(double R) {
int i, j, s, p, q, u, v;
double len = T / m, x, y, dist, x1, y1, x2, y2, ld, rd, nd, di[2], theta1,
theta2;
x = 0;
y = len;
dist = 0;
for (v = 0; v < n; v++) {
x1 = pt[v].x;
y1 = pt[v].y;
x2 = pt[(v + 1) % n].x;
y2 = pt[(v + 1) % n].y;
dist += sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
if (dist > len + 1e-6) {
dist -= sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
break;
}
}
cnt_sg = 0;
ld = 0;
rd = len;
di[0] = 0;
di[1] = dist;
u = 0;
while (u < n) {
x1 = pt[u].x;
y1 = pt[u].y;
x2 = pt[(u + 1) % n].x;
y2 = pt[(u + 1) % n].y;
double mi = inf, pd[2];
theta1 = atan2(y2 - y1, x2 - x1);
pd[0] = di[0] + sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
if (mi > pd[0] - ld) mi = pd[0] - ld;
x1 = pt[v].x;
y1 = pt[v].y;
x2 = pt[(v + 1) % n].x;
y2 = pt[(v + 1) % n].y;
theta2 = atan2(y2 - y1, x2 - x1);
pd[1] = di[1] + sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
if (mi > pd[1] - rd) mi = pd[1] - rd;
x1 = pt[u].x;
y1 = pt[u].y;
x2 = pt[v].x;
y2 = pt[v].y;
if (fabs(theta1 - theta2) < eps) {
dist = (x1 - x2 -
(di[0] * cos(theta1) - di[1] * cos(theta2) + len * cos(theta2))) *
(x1 - x2 -
(di[0] * cos(theta1) - di[1] * cos(theta2) + len * cos(theta2)));
dist +=
(y1 - y2 -
(di[0] * sin(theta1) - di[1] * sin(theta2) + len * sin(theta2))) *
(y1 - y2 -
(di[0] * sin(theta1) - di[1] * sin(theta2) + len * sin(theta2)));
dist = sqrt(dist);
if (dist <= R + eps) {
now.l = ld;
now.r = ld + mi;
sg[cnt_sg++] = now;
}
} else {
double a1, b1, a2, b2, A, B, C;
a1 = cos(theta1) - cos(theta2);
b1 = x1 - x2 - (di[0] - di[1] + len) * cos(theta2);
a2 = sin(theta1) - sin(theta2);
b2 = y1 - y2 - (di[0] - di[1] + len) * sin(theta2);
A = (a1 * a1 + a2 * a2);
B = 2 * a1 * b1 + 2 * a2 * b2;
C = b1 * b1 + b2 * b2 - R * R;
double delta = B * B - 4 * A * C;
if (delta > -eps) {
if (delta < 0) delta = 0;
now.l = max(ld, (-B - sqrt(delta)) / (2 * A) + di[0]);
now.r = min(ld + mi, (-B + sqrt(delta)) / (2 * A) + di[0]);
if (now.l <= now.r + eps) sg[cnt_sg++] = now;
}
}
ld += mi;
rd += mi;
if (fabs(ld - pd[0]) <= 1e-6) {
u++;
di[0] = pd[0];
}
if (fabs(rd - pd[1]) <= 1e-6) {
v = (v + 1) % n;
di[1] = pd[1];
}
}
sort(sg, sg + cnt_sg);
int nn = 0;
for (i = 0; i < cnt_sg; i++) {
if (nn == 0 || sg[nn - 1].r < sg[i].l - eps)
sg[nn++] = sg[i];
else if (sg[nn - 1].r < sg[i].r)
sg[nn - 1].r = sg[i].r;
}
cnt_sg = nn;
ld = 0;
while (ld < len) {
double nl, ma = 0;
for (i = 0; i < m; i++) {
nl = ld + i * len;
int id = lower_bound(0, cnt_sg - 1, nl);
if (id < 0 || sg[id].r < nl - eps) {
id++;
if (id >= cnt_sg) return false;
if (ma < sg[id].l - nl) ma = sg[id].l - nl;
}
}
if (fabs(ma) < eps) return true;
ld += ma;
}
return false;
}
int main() {
scanf("%d%d", &n, &m);
int i, j, s, p, q;
double x1, y1, x2, y2;
for (i = 0; i < n; i++) {
int tx, ty;
scanf("%d%d", &tx, &ty);
pt[i].x = tx;
pt[i].y = ty;
}
T = 0;
for (i = 0; i < n; i++) {
x1 = pt[i].x;
y1 = pt[i].y;
x2 = pt[(i + 1) % n].x;
y2 = pt[(i + 1) % n].y;
T += sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
low = 0;
high = 10000;
while (low < high) {
mid = 0.5 * (low + high);
if (check(mid))
high = mid - eps;
else
low = mid + eps;
}
printf("%.20f\n", (double)(0.5 * (low + high)));
}
|
Seyyed and MoJaK are friends of Sajjad. Sajjad likes a permutation. Seyyed wants to change the permutation in a way that Sajjad won't like it. Seyyed thinks more swaps yield more probability to do that, so he makes MoJaK to perform a swap between every pair of positions (i, j), where i < j, exactly once. MoJaK doesn't like to upset Sajjad.
Given the permutation, determine whether it is possible to swap all pairs of positions so that the permutation stays the same. If it is possible find how to do that.
Input
The first line contains single integer n (1 ≤ n ≤ 1000) — the size of the permutation.
As the permutation is not important, you can consider ai = i, where the permutation is a1, a2, ..., an.
Output
If it is not possible to swap all pairs of positions so that the permutation stays the same, print "NO",
Otherwise print "YES", then print <image> lines: the i-th of these lines should contain two integers a and b (a < b) — the positions where the i-th swap is performed.
Examples
Input
3
Output
NO
Input
1
Output
YES
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long sc = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') sc = sc * 10 + ch - '0', ch = getchar();
return sc * f;
}
int main() {
int n = read();
if (n % 4 > 1) return puts("NO"), 0;
puts("YES");
for (int i = n % 4; i < n; i += 4) {
for (int j = 0; j < i; j++) printf("%d %d\n", j + 1, i + 1);
printf("%d %d\n", i + 1, i + 2);
for (int j = i - 1; ~j; j--) printf("%d %d\n", j + 1, i + 2);
for (int j = 0; j < i; j++) printf("%d %d\n", j + 1, i + 3);
printf("%d %d\n", i + 3, i + 4);
for (int j = i - 1; ~j; j--) printf("%d %d\n", j + 1, i + 4);
printf("%d %d\n", i + 1, i + 4);
printf("%d %d\n", i + 2, i + 3);
printf("%d %d\n", i + 1, i + 3);
printf("%d %d\n", i + 2, i + 4);
}
}
|
Vasya has recently developed a new algorithm to optimize the reception of customer flow and he considered the following problem.
Let the queue to the cashier contain n people, at that each of them is characterized by a positive integer ai — that is the time needed to work with this customer. What is special about this very cashier is that it can serve two customers simultaneously. However, if two customers need ai and aj of time to be served, the time needed to work with both of them customers is equal to max(ai, aj). Please note that working with customers is an uninterruptable process, and therefore, if two people simultaneously come to the cashier, it means that they begin to be served simultaneously, and will both finish simultaneously (it is possible that one of them will have to wait).
Vasya used in his algorithm an ingenious heuristic — as long as the queue has more than one person waiting, then some two people of the first three standing in front of the queue are sent simultaneously. If the queue has only one customer number i, then he goes to the cashier, and is served within ai of time. Note that the total number of phases of serving a customer will always be equal to ⌈n / 2⌉.
Vasya thinks that this method will help to cope with the queues we all hate. That's why he asked you to work out a program that will determine the minimum time during which the whole queue will be served using this algorithm.
Input
The first line of the input file contains a single number n (1 ≤ n ≤ 1000), which is the number of people in the sequence. The second line contains space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 106). The people are numbered starting from the cashier to the end of the queue.
Output
Print on the first line a single number — the minimum time needed to process all n people. Then on ⌈n / 2⌉ lines print the order in which customers will be served. Each line (probably, except for the last one) must contain two numbers separated by a space — the numbers of customers who will be served at the current stage of processing. If n is odd, then the last line must contain a single number — the number of the last served customer in the queue. The customers are numbered starting from 1.
Examples
Input
4
1 2 3 4
Output
6
1 2
3 4
Input
5
2 4 3 1 4
Output
8
1 3
2 5
4
|
import java.io.*;
import java.util.*;
public class TwoOutOfThree {
long[][] r;
int[] a;
final long inf = Long.MAX_VALUE / 2;
int n;
long go(int i, int t) {
if (i >= n) {
if (t == n)
return 0;
else
return a[t];
}
if (r[i][t] != -1) {
return r[i][t];
}
r[i][t] = inf;
if (t == n) {
if (i == n - 1) {
r[i][t] = a[i];
return r[i][t];
}
if (i == n - 2) {
r[i][t] = Math.max(a[i], a[i + 1]);
return r[i][t];
}
long res = inf;
res = Math.min(res, go(i + 3, i) + Math.max(a[i + 2], a[i + 1]));
res = Math.min(res, go(i + 2, n) + Math.max(a[i], a[i + 1]));
res = Math.min(res, go(i + 3, i + 1) + Math.max(a[i], a[i + 2]));
r[i][t] = res;
return res;
} else {
if (i == n - 1) {
r[i][t] = Math.max(a[i], a[t]);
return r[i][t];
}
if (i == n) {
r[i][t] = a[t];
return r[i][t];
}
long res = inf;
res = Math.min(res, go(i + 1, n) + Math.max(a[i], a[t]));
res = Math.min(res, go(i + 2, t) + Math.max(a[i], a[i + 1]));
res = Math.min(res, go(i + 2, i) + Math.max(a[t], a[i + 1]));
r[i][t] = res;
return res;
}
}
void print(int i, int t) {
if (i >= n) {
out.println(t + 1);
return;
}
if (t == n) {
if (i == n - 1) {
out.println(i + 1);
return;
}
if (i == n - 2) {
out.println((i + 2) + " " + (i + 1));
return;
}
if (r[i][t] == go(i + 3, i) + Math.max(a[i + 2], a[i + 1])) {
out.println((i + 3) + " " + (i + 2));
print(i + 3, i);
return;
}
if (r[i][t] == go(i + 2, n) + Math.max(a[i], a[i + 1])) {
out.println((i + 1) + " " + (i + 2));
print(i + 2, n);
return;
}
if (r[i][t] == go(i + 3, i + 1) + Math.max(a[i + 2], a[i])) {
out.println((i + 1) + " " + (i + 3));
print(i + 3, i + 1);
return;
}
return;
} else {
if (i == n - 1) {
out.println((i + 1) + " " + (t + 1));
return;
}
if (i == n) {
out.println(t + 1);
return;
}
long res = inf;
if (r[i][t] == go(i + 1, n) + Math.max(a[i], a[t])) {
out.println((i + 1) + " " + (t + 1));
print(i + 1, n);
return;
}
if (r[i][t] == go(i + 2, t) + Math.max(a[i], a[i + 1])) {
out.println((i + 1) + " " + (i + 2));
print(i + 2, t);
return;
}
if (r[i][t] == go(i + 2, i) + Math.max(a[i + 1], a[t])) {
out.println((i + 2) + " " + (t + 1));
print(i + 2, i);
return;
}
}
}
void solve() throws Exception {
n = nextInt();
a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
r = new long[n][n + 1];
for (int i = 0; i < n; i++)
for (int j = 0; j < n + 1; j++)
r[i][j] = -1;
long ans = go(0, n);
out.println(ans);
print(0, n);
}
void run() {
try {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
solve();
out.close();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
BufferedReader in;
StringTokenizer st;
PrintWriter out;
final String filename = new String("TwoOutOfThree").toLowerCase();
String nextToken() throws Exception {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(in.readLine());
return st.nextToken();
}
int nextInt() throws Exception {
return Integer.parseInt(nextToken());
}
long nextLong() throws Exception {
return Long.parseLong(nextToken());
}
double nextDouble() throws Exception {
return Double.parseDouble(nextToken());
}
public static void main(String[] args) {
new TwoOutOfThree().run();
}
}
|
You have a bag of balls of n different colors. You have ai balls of the i-th color.
While there are at least two different colored balls in the bag, perform the following steps:
* Take out two random balls without replacement one by one. These balls might be the same color.
* Color the second ball to the color of the first ball. You are not allowed to switch the order of the balls in this step.
* Place both balls back in the bag.
* All these actions take exactly one second.
Let M = 109 + 7. It can be proven that the expected amount of time needed before you stop can be represented as a rational number <image>, where P and Q are coprime integers and where Q is not divisible by M. Return the value <image>.
Input
The first line of input will contain a single integer n (1 ≤ n ≤ 2 500) — the number of colors.
The next line of input will contain n space separated integers a1, a2, ..., an (1 ≤ ai ≤ 105) — the number of balls of each color.
Output
Print a single integer, the answer to the problem.
Examples
Input
2
1 1
Output
1
Input
3
1 2 3
Output
750000026
Note
In the first sample, no matter what happens, the balls will become the same color after one step.
For the second sample, we have 6 balls. Let’s label the balls from 1 to 6, and without loss of generality, let’s say balls 1,2,3 are initially color 1, balls 4,5 are color 2, and ball 6 are color 3.
Here is an example of how these steps can go:
* We choose ball 5 and ball 6. Ball 6 then becomes color 2.
* We choose ball 4 and ball 5. Ball 5 remains the same color (color 2).
* We choose ball 1 and ball 5. Ball 5 becomes color 1.
* We choose ball 6 and ball 5. Ball 5 becomes color 2.
* We choose ball 3 and ball 4. Ball 4 becomes color 1.
* We choose ball 4 and ball 6. Ball 6 becomes color 1.
* We choose ball 2 and ball 5. Ball 5 becomes color 1.
At this point, the game ends since all the balls are the same color. This particular sequence took 7 seconds.
It can be shown that the answer to this case is <image>.
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
const long long p = 1000000007;
long long qp(long long a, long long b) {
if (b == 0) return 1;
if (b == 1) return a;
long long tmp = qp(a * a % p, b >> 1);
if (b & 1) tmp *= a, tmp %= p;
return tmp;
}
long long a[114514], f[114514];
long long n, tot, ans;
signed main() {
n = read();
for (long long i = 1; i <= n; ++i) a[i] = read(), tot += a[i];
f[1] = 1ll * (tot - 1) * (tot - 1) % p * qp(tot, p - 2) % p;
for (long long i = 1; i <= 100000; ++i)
f[i + 1] = (2ll * f[i] - f[i - 1] -
1ll * (tot - 1) * qp(tot - i, p - 2) % p + p + p) %
p;
for (long long i = 1; i <= n; ++i) ans += f[a[i]], ans %= p;
printf("%lld\n", ans);
return 0;
}
|
Recently, Dima met with Sasha in a philatelic store, and since then they are collecting coins together. Their favorite occupation is to sort collections of coins. Sasha likes having things in order, that is why he wants his coins to be arranged in a row in such a way that firstly come coins out of circulation, and then come coins still in circulation.
For arranging coins Dima uses the following algorithm. One step of his algorithm looks like the following:
1. He looks through all the coins from left to right;
2. If he sees that the i-th coin is still in circulation, and (i + 1)-th coin is already out of circulation, he exchanges these two coins and continues watching coins from (i + 1)-th.
Dima repeats the procedure above until it happens that no two coins were exchanged during this procedure. Dima calls hardness of ordering the number of steps required for him according to the algorithm above to sort the sequence, e.g. the number of times he looks through the coins from the very beginning. For example, for the ordered sequence hardness of ordering equals one.
Today Sasha invited Dima and proposed him a game. First he puts n coins in a row, all of them are out of circulation. Then Sasha chooses one of the coins out of circulation and replaces it with a coin in circulation for n times. During this process Sasha constantly asks Dima what is the hardness of ordering of the sequence.
The task is more complicated because Dima should not touch the coins and he should determine hardness of ordering in his mind. Help Dima with this task.
Input
The first line contains single integer n (1 ≤ n ≤ 300 000) — number of coins that Sasha puts behind Dima.
Second line contains n distinct integers p1, p2, ..., pn (1 ≤ pi ≤ n) — positions that Sasha puts coins in circulation to. At first Sasha replaces coin located at position p1, then coin located at position p2 and so on. Coins are numbered from left to right.
Output
Print n + 1 numbers a0, a1, ..., an, where a0 is a hardness of ordering at the beginning, a1 is a hardness of ordering after the first replacement and so on.
Examples
Input
4
1 3 4 2
Output
1 2 3 2 1
Input
8
6 8 3 4 7 2 1 5
Output
1 2 2 3 4 3 4 5 1
Note
Let's denote as O coin out of circulation, and as X — coin is circulation.
At the first sample, initially in row there are coins that are not in circulation, so Dima will look through them from left to right and won't make any exchanges.
After replacement of the first coin with a coin in circulation, Dima will exchange this coin with next three times and after that he will finally look through the coins and finish the process.
XOOO → OOOX
After replacement of the third coin, Dima's actions look this way:
XOXO → OXOX → OOXX
After replacement of the fourth coin, Dima's actions look this way:
XOXX → OXXX
Finally, after replacement of the second coin, row becomes consisting of coins that are in circulation and Dima will look through coins from left to right without any exchanges.
|
#include <bits/stdc++.h>
using namespace std;
int n, i, R, x, c[333333];
void add(int x) {
for (; x; x -= x & -x) c[x]++;
}
int qu(int x) {
if (!x) return 0;
int V = 0;
for (; x <= n; x += x & -x) V += c[x];
return V;
}
int main() {
scanf("%d", &n);
R = n;
printf("1");
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
add(x);
for (; qu(R) == n - R + 1 && R; R--)
;
printf(" %d", i - (n - R) + 1);
}
}
|
It is nighttime and Joe the Elusive got into the country's main bank's safe. The safe has n cells positioned in a row, each of them contains some amount of diamonds. Let's make the problem more comfortable to work with and mark the cells with positive numbers from 1 to n from the left to the right.
Unfortunately, Joe didn't switch the last security system off. On the plus side, he knows the way it works.
Every minute the security system calculates the total amount of diamonds for each two adjacent cells (for the cells between whose numbers difference equals 1). As a result of this check we get an n - 1 sums. If at least one of the sums differs from the corresponding sum received during the previous check, then the security system is triggered.
Joe can move the diamonds from one cell to another between the security system's checks. He manages to move them no more than m times between two checks. One of the three following operations is regarded as moving a diamond: moving a diamond from any cell to any other one, moving a diamond from any cell to Joe's pocket, moving a diamond from Joe's pocket to any cell. Initially Joe's pocket is empty, and it can carry an unlimited amount of diamonds. It is considered that before all Joe's actions the system performs at least one check.
In the morning the bank employees will come, which is why Joe has to leave the bank before that moment. Joe has only k minutes left before morning, and on each of these k minutes he can perform no more than m operations. All that remains in Joe's pocket, is considered his loot.
Calculate the largest amount of diamonds Joe can carry with him. Don't forget that the security system shouldn't be triggered (even after Joe leaves the bank) and Joe should leave before morning.
Input
The first line contains integers n, m and k (1 ≤ n ≤ 104, 1 ≤ m, k ≤ 109). The next line contains n numbers. The i-th number is equal to the amount of diamonds in the i-th cell — it is an integer from 0 to 105.
Output
Print a single number — the maximum number of diamonds Joe can steal.
Examples
Input
2 3 1
2 3
Output
0
Input
3 2 2
4 1 3
Output
2
Note
In the second sample Joe can act like this:
The diamonds' initial positions are 4 1 3.
During the first period of time Joe moves a diamond from the 1-th cell to the 2-th one and a diamond from the 3-th cell to his pocket.
By the end of the first period the diamonds' positions are 3 2 2. The check finds no difference and the security system doesn't go off.
During the second period Joe moves a diamond from the 3-rd cell to the 2-nd one and puts a diamond from the 1-st cell to his pocket.
By the end of the second period the diamonds' positions are 2 3 1. The check finds no difference again and the security system doesn't go off.
Now Joe leaves with 2 diamonds in his pocket.
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v);
template <typename A, typename B>
ostream &operator<<(ostream &cout, pair<A, B> const &p) {
return cout << "(" << p.first << ", " << p.second << ")";
}
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v) {
cout << "[";
for (int i = 0; i < v.size(); i++) {
if (i) cout << ", ";
cout << v[i];
}
return cout << "]";
}
template <typename A, typename B>
istream &operator>>(istream &cin, pair<A, B> &p) {
cin >> p.first;
return cin >> p.second;
}
const long long MAXN = 1e5 + 7;
void check() {
long long n, m, k;
cin >> n >> m >> k;
long long a[MAXN], mn = 1e10;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
if (i & 1) mn = min(a[i], mn);
}
if (!(n & 1)) {
cout << 0;
return;
}
cout << min(mn, (m / (n / 2 + 1)) * k);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
for (int i = 1; i <= t; i++) {
check();
}
return 0;
}
|
You have an array a consisting of n integers. Each integer from 1 to n appears exactly once in this array.
For some indices i (1 ≤ i ≤ n - 1) it is possible to swap i-th element with (i + 1)-th, for other indices it is not possible. You may perform any number of swapping operations any order. There is no limit on the number of times you swap i-th element with (i + 1)-th (if the position is not forbidden).
Can you make this array sorted in ascending order performing some sequence of swapping operations?
Input
The first line contains one integer n (2 ≤ n ≤ 200000) — the number of elements in the array.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 200000) — the elements of the array. Each integer from 1 to n appears exactly once.
The third line contains a string of n - 1 characters, each character is either 0 or 1. If i-th character is 1, then you can swap i-th element with (i + 1)-th any number of times, otherwise it is forbidden to swap i-th element with (i + 1)-th.
Output
If it is possible to sort the array in ascending order using any sequence of swaps you are allowed to make, print YES. Otherwise, print NO.
Examples
Input
6
1 2 5 3 4 6
01110
Output
YES
Input
6
1 2 5 3 4 6
01010
Output
NO
Note
In the first example you may swap a3 and a4, and then swap a4 and a5.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
int a[n];
int b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
v.push_back(a[i]);
b[i] = a[i];
}
sort(b, b + n);
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '1') {
if (i != n - 2) {
for (int j = i + 1; j < s.size(); j++) {
if (s[j] == '0') {
sort(v.begin() + i, v.begin() + j + 1);
i = j;
break;
} else if (s[j] == '1' && j == s.size() - 1) {
sort(v.begin() + i, v.end());
i = j;
break;
}
}
} else {
if (v[i] > v[i + 1]) {
swap(v[i], v[i + 1]);
}
}
}
}
bool pos = 1;
for (int i = 0; i < v.size(); i++) {
if (v[i] != b[i]) {
pos = 0;
break;
}
}
if (pos == 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
|
Oleg writes down the history of the days he lived. For each day he decides if it was good or bad. Oleg calls a non-empty sequence of days a zebra, if it starts with a bad day, ends with a bad day, and good and bad days are alternating in it. Let us denote bad days as 0 and good days as 1. Then, for example, sequences of days 0, 010, 01010 are zebras, while sequences 1, 0110, 0101 are not.
Oleg tells you the story of days he lived in chronological order in form of string consisting of 0 and 1. Now you are interested if it is possible to divide Oleg's life history into several subsequences, each of which is a zebra, and the way it can be done. Each day must belong to exactly one of the subsequences. For each of the subsequences, days forming it must be ordered chronologically. Note that subsequence does not have to be a group of consecutive days.
Input
In the only line of input data there is a non-empty string s consisting of characters 0 and 1, which describes the history of Oleg's life. Its length (denoted as |s|) does not exceed 200 000 characters.
Output
If there is a way to divide history into zebra subsequences, in the first line of output you should print an integer k (1 ≤ k ≤ |s|), the resulting number of subsequences. In the i-th of following k lines first print the integer li (1 ≤ li ≤ |s|), which is the length of the i-th subsequence, and then li indices of days forming the subsequence. Indices must follow in ascending order. Days are numbered starting from 1. Each index from 1 to n must belong to exactly one subsequence. If there is no way to divide day history into zebra subsequences, print -1.
Subsequences may be printed in any order. If there are several solutions, you may print any of them. You do not have to minimize nor maximize the value of k.
Examples
Input
0010100
Output
3
3 1 3 4
3 2 5 6
1 7
Input
111
Output
-1
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.AbstractCollection;
import java.util.Scanner;
import java.util.LinkedList;
import java.util.ArrayList;
/**
* Built using CHelper plug-in Actual solution is at the top
*
* @author dima
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
Scanner in = new Scanner(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskC solver = new TaskC();
solver.solve(1, in, out);
out.close();
}
static class TaskC {
public void solve(int testNumber, Scanner in, PrintWriter out) {
String s = in.nextLine();
ArrayList<Integer>[] subseqs = new ArrayList[s.length() + 1];
LinkedList<Integer> zeroSubSeqs = new LinkedList<>();
LinkedList<Integer> oneSubseqs = new LinkedList<>();
int subseqsCount = 0;
for (int i = 0; i < s.length(); ++i) {
if (s.charAt(i) == '1') {
if (zeroSubSeqs.isEmpty()) {
out.print(-1);
return;
} else {
int first = zeroSubSeqs.pollFirst();
subseqs[first].add(i + 1);
oneSubseqs.add(first);
}
} else {
if (oneSubseqs.isEmpty()) {
subseqs[subseqsCount] = new ArrayList<>();
subseqs[subseqsCount].add(i + 1);
zeroSubSeqs.add(subseqsCount);
subseqsCount++;
} else {
int seqId = oneSubseqs.pollFirst();
subseqs[seqId].add(i + 1);
zeroSubSeqs.add(seqId);
}
}
}
if (!oneSubseqs.isEmpty()) {
out.print(-1);
} else {
out.println(subseqsCount);
for (int j = 0; j < subseqsCount; ++j) {
ArrayList<Integer> a = subseqs[j];
out.print(a.size());
for (int i = 0; i < a.size(); ++i) {
out.print(' ');
out.print(a.get(i));
}
out.println();
}
}
}
}
}
|
You are given a bipartite graph G = (U, V, E), U is the set of vertices of the first part, V is the set of vertices of the second part and E is the set of edges. There might be multiple edges.
Let's call some subset of its edges <image> k-covering iff the graph <image> has each of its vertices incident to at least k edges. Minimal k-covering is such a k-covering that the size of the subset <image> is minimal possible.
Your task is to find minimal k-covering for each <image>, where minDegree is the minimal degree of any vertex in graph G.
Input
The first line contains three integers n1, n2 and m (1 ≤ n1, n2 ≤ 2000, 0 ≤ m ≤ 2000) — the number of vertices in the first part, the number of vertices in the second part and the number of edges, respectively.
The i-th of the next m lines contain two integers ui and vi (1 ≤ ui ≤ n1, 1 ≤ vi ≤ n2) — the description of the i-th edge, ui is the index of the vertex in the first part and vi is the index of the vertex in the second part.
Output
For each <image> print the subset of edges (minimal k-covering) in separate line.
The first integer cntk of the k-th line is the number of edges in minimal k-covering of the graph. Then cntk integers follow — original indices of the edges which belong to the minimal k-covering, these indices should be pairwise distinct. Edges are numbered 1 through m in order they are given in the input.
Examples
Input
3 3 7
1 2
2 3
1 3
3 2
3 3
2 1
2 1
Output
0
3 3 7 4
6 1 3 6 7 4 5
Input
1 1 5
1 1
1 1
1 1
1 1
1 1
Output
0
1 5
2 4 5
3 3 4 5
4 2 3 4 5
5 1 2 3 4 5
|
#include <bits/stdc++.h>
using namespace std;
int n1, n2, m, deg[5010], id[5010], mn = 0x3f3f3f3f;
namespace MaxFlow {
const int N = 5000, M = 2000000;
int head[N], cur[N], dep[N], cnt, S, T, res;
struct node {
int to, next, val;
} edge[M];
void ae(int u, int v, int w) {
edge[cnt].next = head[u], edge[cnt].to = v, edge[cnt].val = w,
head[u] = cnt++;
edge[cnt].next = head[v], edge[cnt].to = u, edge[cnt].val = 0,
head[v] = cnt++;
}
queue<int> q;
inline bool bfs() {
memset(dep, 0, sizeof(dep)), q.push(S), dep[S] = 1;
while (!q.empty()) {
register int x = q.front();
q.pop();
for (register int i = cur[x] = head[x]; i != -1; i = edge[i].next)
if (edge[i].val && !dep[edge[i].to])
dep[edge[i].to] = dep[x] + 1, q.push(edge[i].to);
}
return dep[T] > 0;
}
bool reach;
inline int dfs(int x, int flow) {
if (x == T) {
res += flow;
reach = true;
return flow;
}
int used = 0;
for (register int &i = cur[x]; i != -1; i = edge[i].next) {
if (!edge[i].val || dep[edge[i].to] != dep[x] + 1) continue;
register int ff = dfs(edge[i].to, min(edge[i].val, flow - used));
if (ff) {
edge[i].val -= ff;
edge[i ^ 1].val += ff;
used += ff;
if (used == flow) break;
}
}
return used;
}
inline void Dinic() {
while (bfs()) {
reach = true;
while (reach) reach = false, dfs(S, 0x3f3f3f3f);
}
}
} // namespace MaxFlow
using namespace MaxFlow;
vector<int> v[5010];
int main() {
scanf("%d%d%d", &n1, &n2, &m), memset(head, -1, sizeof(head)),
S = n1 + n2 + 1, T = n1 + n2 + 2;
for (int i = 1, x, y; i <= m; i++)
scanf("%d%d", &x, &y), ae(x, y + n1, 1), deg[x]++, deg[y + n1]++;
for (int i = 1; i <= n1 + n2; i++) mn = min(mn, deg[i]);
for (int i = 1; i <= n1; i++) id[i] = cnt, ae(S, i, deg[i] - mn);
for (int i = n1 + 1; i <= n1 + n2; i++) id[i] = cnt, ae(i, T, deg[i] - mn);
for (int i = 0; i <= mn; i++) {
Dinic();
for (int j = 0; j < m; j++)
if (edge[j << 1].val) v[i].push_back(j + 1);
for (int j = 1; j <= n1 + n2; j++) edge[id[j]].val++;
}
for (int i = mn; i >= 0; i--) {
printf("%d ", v[i].size());
for (int j = 0; j < v[i].size(); j++) printf("%d ", v[i][j]);
puts("");
}
return 0;
}
|
Allen is hosting a formal dinner party. 2n people come to the event in n pairs (couples). After a night of fun, Allen wants to line everyone up for a final picture. The 2n people line up, but Allen doesn't like the ordering. Allen prefers if each pair occupies adjacent positions in the line, as this makes the picture more aesthetic.
Help Allen find the minimum number of swaps of adjacent positions he must perform to make it so that each couple occupies adjacent positions in the line.
Input
The first line contains a single integer n (1 ≤ n ≤ 100), the number of pairs of people.
The second line contains 2n integers a_1, a_2, ..., a_{2n}. For each i with 1 ≤ i ≤ n, i appears exactly twice. If a_j = a_k = i, that means that the j-th and k-th people in the line form a couple.
Output
Output a single integer, representing the minimum number of adjacent swaps needed to line the people up so that each pair occupies adjacent positions.
Examples
Input
4
1 1 2 3 3 2 4 4
Output
2
Input
3
1 1 2 2 3 3
Output
0
Input
3
3 1 2 3 1 2
Output
3
Note
In the first sample case, we can transform 1 1 2 3 3 2 4 4 → 1 1 2 3 2 3 4 4 → 1 1 2 2 3 3 4 4 in two steps. Note that the sequence 1 1 2 3 3 2 4 4 → 1 1 3 2 3 2 4 4 → 1 1 3 3 2 2 4 4 also works in the same number of steps.
The second sample case already satisfies the constraints; therefore we need 0 swaps.
|
import java.util.*;
public class SuitAndTie {
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
int[] a=new int[2*n];
Integer[][] ind=new Integer[n][2];
int[] dist=new int[n];
for(int i=0;i<2*n;i++) {
int x=scan.nextInt()-1;
a[i]=x;
if(ind[x][0]==null) ind[x][0]=i;
else {
ind[x][1]=i;
dist[x]=ind[x][1]-ind[x][0]-1;
}
}
int res=0;
HashSet<Integer> done=new HashSet<>();
for(int i=0;i<2*n;i++) {
if(done.contains(a[i])) continue;
// System.out.println();
// System.out.println("add "+dist[a[i]]);
res+=dist[a[i]];
for(int j=0;j<n;j++) {
if(j==a[i]) continue;
// System.out.println("is "+(a[i]+1)+" between "+(j+1));
// System.out.println(ind[j][0]+" "+ind[a[i]][1]+" "+ind[j][1]);
if(between(ind[j][0],ind[a[i]][1],ind[j][1])) {
dist[j]--;
// System.out.println("yea biatch");
}
}
// System.out.println(Arrays.toString(dist));
done.add(a[i]);
}
System.out.println(res);
}
public static boolean between(int a, int b, int c) {
return b>=a&&b<=c;
}
}
|
Ross, Chandler and Joey are best friends. One day they went to pond and Joey suggest them to play the game "Bamboozle". In this game they have N balls with each numbered from 0-9, but first ball is numbered from 1-9. Ross tells sub-strings 'S' formed by those balls and Chandler throws S stones into the pond. At last, Joey have to tell total how many stones Chandler throw in to the pond, 'T'.
But Joey is poor in maths, So help Joey to win the game and make bamboozle of Chandler and Ross.
NOTE: The answer can be very large, Joey to tell T%(10^9+7) instead.
INPUT
A single line containing a string of numbers that appear on the first, second, third ball and so on.
OUTPUT
A single line which is the total number of stones that Chandler throws in to the pond, T%(1000000007).
Constraints
1 ≤ N ≤ 200000
SAMPLE INPUT
16
SAMPLE OUTPUT
23
Explanation
The sub-string of number 16 are 16, 1 and 6 whose sum is 23.
|
s=raw_input()
len1=len(s)
mul_ten=1
sum1=1
total_sum=len1*int(s[len1-1])
for i in range(len1-2,-1,-1):
mul_ten=(mul_ten*10)%1000000007
sum1=sum1+mul_ten
total_sum=(total_sum+(sum1*(i+1))*int(s[i]))%1000000007
print total_sum%1000000007
|
Fatland is a town that started with N distinct empires, namely empires 1, 2, ..., N. But over time, the armies of some of these empires have taken over other ones. Each takeover occurred when the army of empire i invaded empire j. After each invasion, all of empire j became part of empire i, and empire j was renamed as empire i.
Empire Huang, leader of Badland, wants to invade Fatland. To do this, he needs to calculate how many distinct empires still remain in Fatland after all the takeovers. Help him with this task.
Input:
The first line contains an integer N, the number of empires that were originally in Fatland.
The second line contains an integer K, denoting the number of takeovers that took place.
Each of the next K lines contains 2 space-separated integers i, j, representing that the army of empire i took over that of empire j. As a result, empire j does not exist anymore and is now renamed as empire i. It is guaranteed that empire i still exists.
Output: Output one integer, the number of empires that exist in Fatland.
Constraints:
1 ≤ N ≤ 10^5
1 ≤ K ≤ 10^5
SAMPLE INPUT
4
2
1 2
4 1
SAMPLE OUTPUT
2
Explanation
Fatland started with empires 1, 2, 3, 4. First, empire 1 invaded empire 2, so empire 2 was renamed to empire 1. Then, empire 4 invaded empire 1. So what were at the beginning empires 1 and 2 were renamed to empire 4. Now, only empires 3 and 4 remain, so the answer is 2.
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
def root(i):
global x
while i != x[i]:
i = x[i]
return i
n = raw_input().strip()
if len(n.split()) > 1:
(n, m) = map(int, n.split())
else:
n = int(n)
m = int(raw_input().strip())
count = n
x = list(range(n + 1))
size = [1] * ( n + 1 )
for i in range(m):
(a, b) = map(int, raw_input().strip().split())
rA = root(a)
rB = root(b)
if rA != rB:
count -= 1
if size[rA] < size[rB]:
size[rB] += size[rA]
x[rB] = rA
else:
size[rA] += size[rB]
x[rA] = rB
print(count)
|
Having gained some experience with Prime Numbers, Robin now seeks Revenge from Bruce. So, while they are on their way from the Airport to the Summit, Robin comes up with a new Prime based Puzzle for Bruce.
He asks him to find rad(n) for t numbers which he lists before Bruce and then form a sorted table on the values of rad(n) (in ascending order) and he defines rad(n) as the product of the distinct prime factors of n. He then asks him to find E(k) which he defines as the kth element in the sorted table. Bruce has got to prepare for the Summit and so he seeks your help. Help him solve this puzzle to maintain his status as the The Dark Knight of Gotham.
Input:
First line contains t, the number of testcases, and t lines follow after it each containing a single integer k.
Output: Display E(k) for each value of n in a separate line
Constraints:
t ≤ 500
k ≤ 10000
Table is made for n values till 10000SAMPLE INPUT
5
1
3
5
6
10
SAMPLE OUTPUT
1
4
3
9
10
Explanation
Refer the table for n values till 10 in the question description and Cross-Reference it with the sample input/output.
|
limit=100000
rad={}
buf={}
for i in range(1,limit+1):
rad[i]=1
for j in range(1,limit+1):
buf[j]=""
for i in range(2,limit+1):
if rad[i]==1:
for j in range(i,limit+1,i):
rad[j]=rad[j]*i
hey=rad[i]
buf[hey]=buf[hey]+" "+str(i)
str=""
for i in buf.keys():
str=str+buf[i]
str=str.split(" ")
str[0]=1
n=input()
for i in range(0,n):
target=input()
print str[target-1]
|
Ruchi is doing her undergrad in Maths from a reputed college in New Delhi. Recently her professor gave her a problem which is baffling her for a long time. So she asks your help.
Problem is:
Given order of n x n matrix is it possible to find two matrices such that when there corresponding elements are combined in the form of (x,y), the resulting matrix yield all n x n pairs i.e all pairs of {1,2,3,.....,n} X {1,2,3,......,n}.
For example:
n=3
Two possible matrices are:
A
1 2 3
3 1 2
2 3 1
B
1 2 3
2 3 1
3 1 2
Now, when we combine the corresponding elements, we get the following matrix.
C
(1,1) (2,2) (3,3)
(3,2) (1,3) (2,1)
(2,3) (3,1) (1,2)
Matrix C contains all the element of set {1,2,3} X {1,2,3}. So, ans for this order will be "Yes".
[Note:] :Each value from 1 to n appear in each row and column once.
[Input]
First line of the input contain integer t denoting no.of test cases.
Next t line contains a single integer n denoting the order of the matrix.
[Output]
For each test case output "Yes" if it is possible else print "No".
[Constraints]
1 ≤ t ≤ 1000000
2 ≤ n ≤ 1000000
This problem is dedicated to my friend Ruchi on her birthday (19th June). She is doing her undergraduate in Mathematics. :)
Note:
Use printf / scanf instead of cin and cout .
SAMPLE INPUT
1
3
SAMPLE OUTPUT
Yes
|
for _ in range(input()):
if input() in [2, 6]:
print "No"
else:
print "Yes"
|
A Magic Fraction for N is one that has the following properties:
It is a proper fraction (The value is < 1)
It cannot be reduced further (The GCD of the numerator and the denominator is 1)
The product of the numerator and the denominator is factorial of N. i.e. if a/b is the fraction, then a*b = N!
Examples of Magic Fractions are:
1/2 [ gcd(1,2) = 1 and 1*2=2! ]
2/3 [ gcd(2,3) = 1 and 2*3=3! ]
3/8 [ gcd(3,8) = 1 and 3*8=4! ]
2/12 for example, is not a magic fraction, as even though 2*12=4!, gcd(2,12) != 1
And Magic fractions for number 3 are: 2/3 and 1/6 (since both of them satisfy the above criteria, are of the form a/b where a*b = 3!)
Now given a number N, you need to print the total number of magic fractions that exist, for all numbers between 1 and N (include magic fractions for N, too).
Note:
The number N will be in the range [1, 500]. (1 and 500 inclusive)
You'll have to read the input from STDIN, and print the output to STDOUT
Examples:
1)
Input: 1
Output: 0
Explanation: There is no fraction < 1 whose numerator * denominator = 1!
2)
Input: 3
Output: 3
Explanation: 0 for 1 + 1 for 2 [1/2] + 2 for 3 [1/6, 2/3]
3)
Input: 5
Output: 9
SAMPLE INPUT
8
SAMPLE OUTPUT
29
|
i=0;
arr=[]
while i<=500:
arr.append(True)
i+=1
i=2
while i<=500:
if arr[i]==True:
j=2*i
while j<=500:
arr[j]=False
j+=i
i+=1
p=[]
p.append(1)
i=1
while i<=500:
p.append(2*p[i-1])
i+=1
ans=0
s=input()
n=int(s);
cnt=0
if n is 1:
print ("0")
else:
i=2
while i<=n:
if arr[i]==True:
cnt+=1
ans+=p[cnt-1]
i+=1
print (ans)
|
Our hero - Maga is going to make a new contest for making the best teams. He is really excited about it. There will be S students in the contest. First N students in the final standings will be awarded.
He has a list( favourite students list ) what contains the best students in informatics Olympiad. His favorite students list contains M students. Though he is excited about the contest, he will enjoy it only if at least K of students from his favourite students list are awarded. He is wondering what are the chances of that happening. He needs your help. Tell him the probability that he will enjoy. It is known that each student has equal chance of being awarded.
Input:
First line of input contains a single integer T, the number of test cases.
In the next T lines, you are given 4 separated integers, S, N, M and K.
Output:
For each test case, output the required probability with 6 digits after floating point.
Constraints:
1 ≤ T ≤ 100
1 ≤ S ≤ 1000
1 ≤ N ≤ S
1 ≤ M ≤ S
0 ≤ K ≤ M
SAMPLE INPUT
3
10 10 5 3
10 4 6 4
3 2 2 1
SAMPLE OUTPUT
1.000000
0.071429
1.000000
|
matrix = [[0 for x in range(1007)] for x in range(1007)]
n=int(1001)
k=int(1001)
for i in range(0,n+1):
temp=min(i,k)
temp=temp+1
for j in range(0,temp):
if(j==0):
matrix[i][j]=1
elif(j==i):
matrix[i][j]=1
else:
matrix[i][j]=matrix[i-1][j-1]+matrix[i-1][j]
testcase=raw_input()
testcase=int(testcase)
for i in range(0,testcase):
s,n,m,k1=raw_input().split()
s=int(s)
n=int(n)
m=int(m)
k1=int(k1)
y=0
for k in range(k1,m+1):
temp=matrix[m][k]*matrix[s-m][n-k]
y=y+temp
x=matrix[s][n]
y=float(y)
x=float(x)
ans=y/x
round(ans,6)
print ("%.6f" % ans)
|
The professor is conducting a course on Discrete Mathematics to a class of N students. He is angry at the lack of their discipline, and he decides to cancel the class if there are fewer than K students present after the class starts.
Given the arrival time of each student, your task is to find out if the class gets cancelled or not.
INPUT
The first line of the input contains T, the number of test cases. Each test case contains two lines.
The first line of each test case contains two space-separated integers, N and K.
The next line contains N space-separated integers, a1,a2,…,aN, representing the arrival time of each student.
If the arrival time of a given student is a non-positive integer (ai≤0), then the student enters before the class starts. If the arrival time of a given student is a positive integer (ai>0), the student enters after the class has started.
OUTPUT
For each testcase, print "YES" (without quotes) if the class gets cancelled and "NO" (without quotes) otherwise.
CONSTRAINT
1≤T≤10
1≤N≤1000
1≤N≤
−100≤ai≤100,where i∈[1,N]
NOTE
If a student enters the class exactly when it starts (ai=0), the student is considered to have entered before the class has started.
SAMPLE INPUT
2
4 3
-1 -3 4 2
4 2
0 -1 2 1
SAMPLE OUTPUT
YES
NO
Explanation
For the first test case, K=3, i.e., the professor wants at least 3 students to be in class but there are only 2 who have arrived on time (−3 and −1), hence the class gets cancelled.
For the second test case, K=2, i.e, the professor wants at least 2 students to be in class and there are 2 who have arrived on time (0 and −1), hence the class does not get cancelled.
|
for _ in range(input()):
n,k=map(int,raw_input().split())
a=map(int,raw_input().split())
c=0
for i in range(n):
if(a[i]<=0):
c+=1
if(c>=k):
print "NO"
else:
print "YES"
|
Recently Watson learned the concept of coprime numbers and now he wonders given an array A1, A2 . . . AN what is the size of the largest subset of the array such that the each pair of elements in the subset is coprime.
Watson asks Sherlock for help and in turn Sherlock needs you.
Input
First line contains T, the number of test cases.
Each test case contains N in one line, number of elements in the array.
Next line contains N space separated elements A1, A2 . . . AN.
Output
For each test case, output the required answer in one line.
Constraints:
1 ≤ T ≤ 10
25% test data: 1 ≤ N ≤ 10
75% test data: 1 ≤ N ≤ 50
1 ≤ Ai ≤ 50
SAMPLE INPUT
1
5
2 3 2 3 2
SAMPLE OUTPUT
2
Explanation
The largest subset would be taking one of A[0], A[1], A[2] and taking one of A[3], A[4].
|
def prime(n):
for i in range(2, n):
if n % i == 0:
return False
return True
primes = [i for i in range(2, 51) if prime(i)]
def f(n):
ans = 0
for p in primes:
if n % p == 0:
ans += 1
return ans
def gcd(a, b):
while b:
a, b = b, a % b
return a
for _ in range(int(raw_input())):
n = int(raw_input())
a = list(map(int, raw_input().split()))
ans = a.count(1)
a = set(a)
if 1 in a:
a.remove(1)
a = list(a)
while len(a) > 0:
a = sorted(a, key = lambda x: f(x))
ans += 1
elem = a[0]
a = list(filter(lambda x: gcd(x, elem) == 1, a))
print(ans)
|
Many of us are familiar with collatz sequence. Know the problem is, There is a fight going between the students of the class they have splitted up into two groups the odd rulers and the even rulers. To resolve this fight sir will randomly pick up the numbers and are written on the board. Teacher stated that if the total sum of all even numbers occuring in the collatz sequence for a number when it is divided by the total no of steps to reach 1 remainder is named as odd remainder will be compared with the even remainder i.e., sum of all odd numbers in sequence divided with steps the resulting remainder. If the odd remainder is greater than even then odd rulers win, if even remainder is more than odd remainder then even rulers win. if both are same then there is a tie.
INPUT:
First line contains number of test cases T.
Next T line contains a number N for each line
OUTPUT:
for every respective N print either "Even Rules" or "Odd Rules" or "Tie" according to the problem.
Explanation:
for n=4, steps followed are 4->2->1 no of steps is 2 and even sum is 6 and odd sum is 1 since 6%2 < 1%2 so Odd Rules
SAMPLE INPUT
2
3
4
SAMPLE OUTPUT
Even Rules
Odd Rules
|
for _ in range(input()):
num = input()
oddsum = 1
evensum = 0
totsteps = 0
while num > 1:
if num % 2 == 0:
evensum += num
num /= 2
else:
oddsum += num
num = (3 * num) + 1
totsteps += 1
evenrem = evensum % totsteps
oddrem = oddsum % totsteps
if oddrem > evenrem:
print "Odd Rules"
elif oddrem < evenrem:
print "Even Rules"
else:
print "Tie"
|
Xenny had a list of N strings of equal length. He wanted to sort them by the first M characters only. That means, while sorting the list of strings, he only wanted to consider the first M characters of each string.
Help Xenny to find out the K^th string in the list after he sorts them.
Note: Xenny wanted to perform stable sorting.
Stable sorting algorithms maintain the relative order of records with equal keys (i.e. values). That is, a sorting algorithm is stable if whenever there are two records R and S with the same key and with R appearing before S in the original list, R will appear before S in the sorted list.
Input
First line contains a single integer - T, which represents the number of testcases.
T testcases follow.
Each testcase is of the following format:
First line contains 3 space-separated integers - N, K and M.
N is the total number of strings Xenny has.
K is the index of the string in the list after sorting, which Xenny has to find.
M is the number of characters based on which sorting will be done by Xenny.
Then next N lines contain N strings ( each line will contain one string ) .
Output
For each testcase, print the K^th string in the sorted list in a new line.
Constraints
1 ≤ T ≤ 50
1 ≤ N ≤ 10^3
1 ≤ Max Length of each String ≤ 10^3
1 ≤ M ≤ Max Length
M ≤ Max Length of each String ≤ 10^3
SAMPLE INPUT
1
3 1 3
abcdef
abcaaa
aabaaa
SAMPLE OUTPUT
aabaaa
Explanation
After performing sorting by the first 3 characters, the order is:
1. aabaaa
2. abcdef
3. abcaaa
|
for i in range(input()):
l=[int(x) for x in raw_input().split()]
l1=[]
l2=[]
l3=[]
l4=[]
for j in range(l[0]):
a=raw_input()
l1.append(a)
for k in range(0,len(l1)):
l2.append(l1[k][0:l[2]])
l3.append(l1[k][l[2]:])
for m in range(0,len(l2)):
l4.append(l2[m])
l2.sort()
h=l4.index(l2[l[1]-1])
print(l4[h]+l3[h])
|
In a two-dimensional plane, we have a rectangle R whose vertices are (0,0), (W,0), (0,H), and (W,H), where W and H are positive integers. Here, find the number of triangles \Delta in the plane that satisfy all of the following conditions:
* Each vertex of \Delta is a grid point, that is, has integer x- and y-coordinates.
* \Delta and R shares no vertex.
* Each vertex of \Delta lies on the perimeter of R, and all the vertices belong to different sides of R.
* \Delta contains at most K grid points strictly within itself (excluding its perimeter and vertices).
Constraints
* 1 \leq W \leq 10^5
* 1 \leq H \leq 10^5
* 0 \leq K \leq 10^5
Input
Input is given from Standard Input in the following format:
W H K
Output
Print the answer.
Examples
Input
2 3 1
Output
12
Input
5 4 5
Output
132
Input
100 100 1000
Output
461316
|
#include <bits/stdc++.h>
#define long long long int
using namespace std;
// @author: pashka
int gcd(int a, int b) {
while (b > 0) {
int c = a % b;
a = b;
b = c;
}
return a;
}
map<pair<int, int>, int> mem;
int get(int x, int y) {
x = abs(x);
y = abs(y);
return gcd(x, y);
// typedef typename map<pair<int, int>, int>::mapped_type V;
// auto r = mem.insert({{x, y}, V()});
// V &v=r.first->second;
// if (r.second)
// v = gcd(x, y);
// return v;
}
long calc(long w, long h, long k) {
long res = 0;
vector<int> mem(h + 1);
vector<int> t2(h + 1);
vector<int> mem2(h + 1);
for (long b = 1; b < w; b++) {
for (long c = 1; c < h && c * w <= 2 * (k + w); c++) {
int mm = get(c, b);
// c * w + (a - c) * b <= 2k;
long mina = max((2 * k - c * w) / b + c, c);
mina = min(mina, h);
if (mina > c) {
res += (mina - c) * 2 - 1;
}
for (long a = mina; a < h && c * w + (a - c) * b <= 2 * (k + w); a++) {
long s = c * w + (a - c) * b;
if (s / 2 <= k) {
res++;
if (a != c) res++;
continue;
}
long g = mm;
if ((s - g + 2) / 2 <= k) {
res++;
if (a != c) res++;
continue;
}
if (t2[a] != b) {
t2[a] = b;
mem2[a] = get(a, w - b);
}
g += mem2[a];
if ((s - g + 2) / 2 <= k) {
res++;
if (a != c) res++;
continue;
}
if (mem[a - c] == 0) {
mem[a - c] = get(a - c, w);
}
g += mem[a - c];
if ((s - g + 2) / 2 <= k) {
res++;
if (a != c) res++;
continue;
}
}
}
}
return res;
}
int main() {
ios::sync_with_stdio(false);
int w, h, k;
cin >> w >> h >> k;
auto start = std::chrono::high_resolution_clock::now();
cout << (calc(w, h, k) + calc(h, w, k)) * 2;
auto finish = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> elapsed = finish - start;
cerr << elapsed.count() << "\n";
return 0;
}
|
Given is a sequence of integers A_1, A_2, ..., A_N. If its elements are pairwise distinct, print `YES`; otherwise, print `NO`.
Constraints
* 2 ≤ N ≤ 200000
* 1 ≤ A_i ≤ 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 ... A_N
Output
If the elements of the sequence are pairwise distinct, print `YES`; otherwise, print `NO`.
Examples
Input
5
2 6 1 4 5
Output
YES
Input
6
4 1 3 1 6 2
Output
NO
Input
2
10000000 10000000
Output
NO
|
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
HashSet<Integer> a = new HashSet<>();
int A = 0;
for(int i = 0; i < N; i++) {
A=sc.nextInt();
a.add(A);
}
if(a.size() == N) {
System.out.println("YES");
}else {
System.out.println("NO");
}
}
}
|
We have N non-negative integers: A_1, A_2, ..., A_N.
Consider painting at least one and at most N-1 integers among them in red, and painting the rest in blue.
Let the beauty of the painting be the \mbox{XOR} of the integers painted in red, plus the \mbox{XOR} of the integers painted in blue.
Find the maximum possible beauty of the painting.
What is \mbox{XOR}?
The bitwise \mbox{XOR} x_1 \oplus x_2 \oplus \ldots \oplus x_n of n non-negative integers x_1, x_2, \ldots, x_n is defined as follows:
* When x_1 \oplus x_2 \oplus \ldots \oplus x_n is written in base two, the digit in the 2^k's place (k \geq 0) is 1 if the number of integers among x_1, x_2, \ldots, x_n whose binary representations have 1 in the 2^k's place is odd, and 0 if that count is even.
For example, 3 \oplus 5 = 6.
Constraints
* All values in input are integers.
* 2 \leq N \leq 10^5
* 0 \leq A_i < 2^{60}\ (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the maximum possible beauty of the painting.
Examples
Input
3
3 6 5
Output
12
Input
4
23 36 66 65
Output
188
Input
20
1008288677408720767 539403903321871999 1044301017184589821 215886900497862655 504277496111605629 972104334925272829 792625803473366909 972333547668684797 467386965442856573 755861732751878143 1151846447448561405 467257771752201853 683930041385277311 432010719984459389 319104378117934975 611451291444233983 647509226592964607 251832107792119421 827811265410084479 864032478037725181
Output
2012721721873704572
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
int32_t main(){
ios::sync_with_stdio(0),cin.tie(0);
int n;
cin >> n;
int a[n],x=0,b[60]={0};
for(int i=0;i<n;i++){
cin >> a[i];
x^=a[i];
}
for(int i=0;i<n;i++){
for(int j=0;j<60;j++){
if(((1ll<<j)&x) and ((1ll<<j)&a[i]))
a[i]^=(1ll<<j);
}
}
for(int i=0;i<n;i++){
for(int j=59;j>=0;j--){
if((1ll<<j)&a[i]){
if(!b[j])b[j]=a[i];
a[i]^=b[j];
}
}
}
int k=0;
for(int i=59;i>=0;i--){
k=max(k,k^b[i]);
}
cout << k+(x^k);
}
|
Snuke received a positive integer N from Takahashi. A positive integer m is called a favorite number when the following condition is satisfied:
* The quotient and remainder of N divided by m are equal, that is, \lfloor \frac{N}{m} \rfloor = N \bmod m holds.
Find all favorite numbers and print the sum of those.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
8
Output
10
Input
1000000000000
Output
2499686339916
|
import java.io.*;
import java.util.*;
class Main {
static class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() { return Double.parseDouble(next());}
}
/**
* PrimeTools class provides functions dealing with primes, calculating primes
* upto N in advance.
*
* Note that when you only deal with factors, N <- sqrt(N) would be enough.
*/
static class PrimeTools {
List<Long> primes = new ArrayList<>(1000);
private void eratosthenesPrimes(int N) {
long[] tmp = new long[N+1];
Arrays.fill(tmp, 1);
tmp[0] = 0;
tmp[1] = 0;
tmp[2] = 1;
if (N<=1) return;
primes.add(2L);
if (N<=2) return;
for(int i=3; i<=N; i+=2) {
if (tmp[i] == 0) continue;
primes.add((long)i);
if (N<i*i) continue;
for (int k=i+i; k<=N; k+=i) {
tmp[k]=0;
}
}
}
public PrimeTools() {
this(10000000);
}
public PrimeTools(int N) {
eratosthenesPrimes(N);
}
public boolean isPrime(long n) {
return Collections.binarySearch(primes, n) >= 0;
}
// A return set
// * does not include 1
// * includes n
//
// 2 -> {2}
// 6 -> {2, 3}
// 16 -> {2} // uniqueなもののみ
//
// 約数を知りたい場合は、divisors()
public Set<Long> uniqueFactors(long n) {
Set<Long> ret = new TreeSet<>();
if (n==1) return ret;
for (long p : primes) {
if (n==1) break;
if (p*p>n) break;
if (n % p == 0) {
ret.add(p);
while (n % p == 0) {
n /= p;
}
}
}
if (n>1) ret.add(n);
return ret;
}
public Map<Long, Long> factorExponents(long n) {
Map<Long, Long> ret = new TreeMap<>();
if (n==1) return ret;
for (long p : uniqueFactors(n)) {
if (n % p == 0) {
ret.put(p, 0L);
while (n % p == 0) {
n /= p;
ret.put(p, ret.get(p)+1);
}
}
}
if (ret.isEmpty()) ret.put(n, 1L);
return ret;
}
/*
* Rutuns a vector of sorted products of b^0, b^1, ... , b^n"
*/
static private List<Long> makeProducts(long base, long n) {
List<Long> ret = new ArrayList<>((int)(n+1));
ret.add(1L);
for (long i=1; i<=n; i++) {
ret.add(ret.get(ret.size()-1)*base);
}
return ret;
}
/*
* Returns a sorted sequence of divisors of n.
* For example, 12 => (1 2 3 4 6 12)"
*/
public List<Long> divisors(long n) {
List<Long> ret = new ArrayList<>();
ret.add(1L);
for (Map.Entry<Long, Long> kv : factorExponents(n).entrySet()) {
List<Long> products = makeProducts(kv.getKey(), kv.getValue());
List<Long> tmp = new ArrayList<>(ret.size()*products.size());
for (long x : ret) {
for (long y : products) {
tmp.add(x*y);
}
}
ret = tmp;
}
Collections.sort(ret);
return ret;
}
};
public static void main(String[] args) {
FastScanner sc = new FastScanner();
// * word: next()
// * integer: nextInt(), nextLong()
// * string: nextLine()
long N = sc.nextLong();
PrimeTools primes = new PrimeTools();
long ret = 0;
for (long x : primes.divisors(N)) {
System.err.println("HOGE " + x);
x -= 1;
if (x < 1) continue;
long q = N/x;
long r = N%x;
if (q==r) ret += x;
}
System.out.println(ret);
}
}
/* vim: set expandtab ts=2 sw=2 sts=2 : */
|
There is a sequence of length 2N: A_1, A_2, ..., A_{2N}. Each A_i is either -1 or an integer between 1 and 2N (inclusive). Any integer other than -1 appears at most once in {A_i}.
For each i such that A_i = -1, Snuke replaces A_i with an integer between 1 and 2N (inclusive), so that {A_i} will be a permutation of 1, 2, ..., 2N. Then, he finds a sequence of length N, B_1, B_2, ..., B_N, as B_i = min(A_{2i-1}, A_{2i}).
Find the number of different sequences that B_1, B_2, ..., B_N can be, modulo 10^9 + 7.
Constraints
* 1 \leq N \leq 300
* A_i = -1 or 1 \leq A_i \leq 2N.
* If A_i \neq -1, A_j \neq -1, then A_i \neq A_j. (i \neq j)
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_{2N}
Output
Print the number of different sequences that B_1, B_2, ..., B_N can be, modulo 10^9 + 7.
Examples
Input
3
1 -1 -1 3 6 -1
Output
5
Input
4
7 1 8 3 5 2 6 4
Output
1
Input
10
7 -1 -1 -1 -1 -1 -1 6 14 12 13 -1 15 -1 -1 -1 -1 20 -1 -1
Output
9540576
Input
20
-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 6 -1 -1 -1 -1 -1 7 -1 -1 -1 -1 -1 -1 -1 -1 -1 34 -1 -1 -1 -1 31 -1 -1 -1 -1 -1 -1 -1 -1
Output
374984201
|
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int , int> P2;
typedef pair<pair<int , int> , int> P3;
typedef pair<pair<int , int> , pair<int , int> > P4;
#define PB(a) push_back(a)
#define MP(a , b) make_pair((a) , (b))
#define M3P(a , b , c) make_pair(make_pair((a) , (b)) , (c))
#define M4P(a , b , c , d) make_pair(make_pair((a) , (b)) , make_pair((c) , (d)))
#define repp(i,a,b) for(int i = (int)(a) ; i < (int)(b) ; ++i)
#define repm(i,a,b) for(int i = (int)(a) ; i > (int)(b) ; --i)
const LL mod = 1e9 + 7;
int main(){
int N; cin >> N;
vector<int> b(2*N,0);
int g = 0, z = 0, c = 0;
repp(i,0,N){
int A,B; cin >> A >> B;
if(A == -1 && B == -1){
g += 2;
++c;
} else if(A == -1){
b[B-1] = 1;
++g;
++z;
} else if(B == -1){
b[A-1] = 1;
++g;
++z;
} else {
b[A-1] = b[B-1] = 2;
}
}
vector<vector<LL>> dp(N+1,vector<LL>(N+1,0));
dp[c][0] = 1;
repp(i,0,2*N){
if(b[i] == 2) continue;
vector<vector<LL>> nx(N+1,vector<LL>(N+1,0));
repp(j,0,N+1) repp(k,0,N+1){
int r = 2*j+k+z-g;
if(r < 0) continue;
if(b[i] == 1){
if(r > 0) (nx[j][k] += dp[j][k]*r) %= mod;
if(k < N) (nx[j][k+1] += dp[j][k]) %= mod;
} else {
if(j > 0 && k < N) (nx[j-1][k+1] += dp[j][k]*j) %= mod;
if(k > 0) (nx[j][k-1] += dp[j][k]) %= mod;
(nx[j][k] += dp[j][k]) %= mod;
}
}
swap(dp,nx);
if(b[i] == 0) --g;
if(b[i] == 1) --z;
}
cout << dp[0][0] << endl;
return 0;
}
/*
j : (-1,-1)
k : (*,-1) (外からのみ追加可能)
r : (*,-1) を要求
z : (*,-1) の残り
g : -1 の残り個数
2j+k+z=g+s
*/
|
You are given a string S of length N consisting of lowercase English letters. We will cut this string at one position into two strings X and Y. Here, we would like to maximize the number of different letters contained in both X and Y. Find the largest possible number of different letters contained in both X and Y when we cut the string at the optimal position.
Constraints
* 2 \leq N \leq 100
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the largest possible number of different letters contained in both X and Y.
Examples
Input
6
aabbca
Output
2
Input
10
aaaaaaaaaa
Output
1
Input
45
tgxgdqkyjzhyputjjtllptdfxocrylqfqjynmfbfucbir
Output
9
|
import java.util.*;
import java.io.*;
public class Main{
public static void main(String[] args) {
Scanner scn=new Scanner(System.in);
int N = scn.nextInt();
String S = scn.next();
int[] visited1 = new int[26];
int[] visited2 = new int[26];
int c1=0, c2=0, max=-1;
for(int i=0;i<N;i++){
char ch=S.charAt(i);
if ( visited1[ch-'a'] == 0){
c1++;
}
visited1[ch-'a']++;
}
for(int i=0;i<N;i++){
char ch=S.charAt(i);
visited1[ch-'a']--;
if ( visited1[ch-'a'] == 0){
c1--;
}
if ( visited2[ch-'a'] == 0){
c2++;
}
visited2[ch-'a']++;
max=Math.max(max, countSame(visited1, visited2));
}
System.out.println(max);
}
static int countSame(int[] visited1, int[] visited2){
int rv= 0;
for(int i=0;i<26;i++){
if(visited1[i]!=0 && visited2[i]!=0)
rv++;
}
return rv;
}
}
//gxdqkzhyutjlpt fxocrylqjnmubi
|
There are N non-negative integers written on the blackboard: A_1, ..., A_N.
Snuke can perform the following two operations at most K times in total in any order:
* Operation A: Replace each integer X on the blackboard with X divided by 2, rounded down to the nearest integer.
* Operation B: Replace each integer X on the blackboard with X minus 1. This operation cannot be performed if one or more 0s are written on the blackboard.
Find the number of the different possible combinations of integers written on the blackboard after Snuke performs the operations, modulo 1,000,000,007.
Constraints
* 1 \leq N \leq 200
* 1 \leq A_i \leq 10^{18}
* 1 \leq K \leq 10^{18}
* A_i and K are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1 A_2 ... A_N
Output
Print the number of the different possible combinations of integers written on the blackboard after Snuke performs the operations, modulo 1,000,000,007.
Examples
Input
2 2
5 7
Output
6
Input
3 4
10 13 22
Output
20
Input
1 100
10
Output
11
Input
10 123456789012345678
228344079825412349 478465001534875275 398048921164061989 329102208281783917 779698519704384319 617456682030809556 561259383338846380 254083246422083141 458181156833851984 502254767369499613
Output
164286011
|
#include<cstdio>
#include<cstring>
#include<iostream>
#include<stdlib.h>
#include<ctime>
#include<string>
#include<cmath>
#include<algorithm>
#include<complex>
#include<vector>
#include<set>
#include<map>
#include<queue>
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define LL long long
#define FOR(i,a,b) for (int i=a;i<=b;++i)
#define FORD(i,a,b) for (int i=a;i>=b;--i)
using namespace std;
typedef pair<LL,LL> pa;
void getint(int &v){
char ch,fu=0;
for(ch='*'; (ch<'0'||ch>'9')&&ch!='-'; ch=getchar());
if(ch=='-') fu=1, ch=getchar();
for(v=0; ch>='0'&&ch<='9'; ch=getchar()) v=v*10+ch-'0';
if(fu) v=-v;
}
const int MO=1e9+7;
int n,ts,top,tot,now;
vector<pa> v[22222];
LL pt,L,R,K,rch,ans,tmp[222],c[222],a[222],x[222],y[222];
pa stk[222];
struct node{
LL w[200];
node(){memset(w,0,sizeof(w));}
bool operator < (const node & A) const{
FOR(i,0,199)
if (w[i]<A.w[i]) return 1;
else if (w[i]>A.w[i]) return 0;
return 0;
}
};
LL bcm(LL x,LL y){
LL ans=0;
FOR(i,0,60)
if ((y>>i)&1){
if (y-(1ll<<i)>=x) y-=1ll<<i;
else ++ans;
}
return ans;
}
map<node,int> M;
int main(){
cin>>n>>K;
FOR(i,1,n) cin>>a[i];
sort(a+1,a+n+1);
tmp[0]=-1;
FOR(j,0,60){
FOR(i,1,n){
x[i]=(a[i]>>j);
y[i]=(a[i])%(1ll<<j);
tmp[i]=y[i];
}
sort(tmp+1,tmp+n+1);
ts=unique(tmp+1,tmp+n+1)-tmp-1;
if (tmp[ts]!=(1ll<<j)-1) tmp[++ts]=(1ll<<j)-1;
FOR(k,1,ts){
FOR(i,1,n)
if (tmp[k]<=y[i]) c[i]=x[i];
else c[i]=x[i]-1;
pt=bcm(tmp[k-1]+1,tmp[k])+j;
if (pt>K) continue;
node P;
FOR(i,2,n) P.w[i-1]=c[i]-c[i-1];
if (M.find(P)==M.end()) M[P]=++tot;
now=M[P];
// tmp[k-1]+1~tmp[k]
L=max(0ll,c[1]-(K-pt)),R=c[1];
v[now].pb(mp(L,R));
}
}
FOR(i,1,tot){
top=0;
for (int j=0;j<v[i].size();++j) stk[++top]=v[i][j];
sort(stk+1,stk+top+1);
rch=-1;
FOR(j,1,top){
if (stk[j].se<=rch) continue;
if (stk[j].fi>rch) (ans+=stk[j].se-stk[j].fi+1)%=MO,rch=stk[j].se;
else (ans+=stk[j].se-rch)%=MO,rch=stk[j].se;
}
}
cout<<(ans+MO)%MO<<endl;
return 0;
}
|
Snuke and Raccoon have a heap of N cards. The i-th card from the top has the integer a_i written on it.
They will share these cards. First, Snuke will take some number of cards from the top of the heap, then Raccoon will take all the remaining cards. Here, both Snuke and Raccoon have to take at least one card.
Let the sum of the integers on Snuke's cards and Raccoon's cards be x and y, respectively. They would like to minimize |x-y|. Find the minimum possible value of |x-y|.
Constraints
* 2 \leq N \leq 2 \times 10^5
* -10^{9} \leq a_i \leq 10^{9}
* a_i is an integer.
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_{N}
Output
Print the answer.
Examples
Input
6
1 2 3 4 5 6
Output
1
Input
2
10 -10
Output
20
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n, a[];
long psum[], sum = 0;
n = sc.nextInt();
a = new int[n];
psum = new long[n];
for (int i = 0; i < n; ++i) {
a[i] = sc.nextInt();
sum += a[i];
psum[i] = sum;
}
sc.close();
long min = (long)Math.pow(10, 10), sub;
for (int i = 0; i < n - 1; ++i) {
sub = Math.abs(sum - 2 * psum[i]);
min = Math.min(min, sub);
}
System.out.println(min);
}
}
|
Snuke has decided to play with a six-sided die. Each of its six sides shows an integer 1 through 6, and two numbers on opposite sides always add up to 7.
Snuke will first put the die on the table with an arbitrary side facing upward, then repeatedly perform the following operation:
* Operation: Rotate the die 90° toward one of the following directions: left, right, front (the die will come closer) and back (the die will go farther). Then, obtain y points where y is the number written in the side facing upward.
For example, let us consider the situation where the side showing 1 faces upward, the near side shows 5 and the right side shows 4, as illustrated in the figure. If the die is rotated toward the right as shown in the figure, the side showing 3 will face upward. Besides, the side showing 4 will face upward if the die is rotated toward the left, the side showing 2 will face upward if the die is rotated toward the front, and the side showing 5 will face upward if the die is rotated toward the back.
864abc2e4a08c26015ffd007a30aab03.png
Find the minimum number of operation Snuke needs to perform in order to score at least x points in total.
Constraints
* 1 ≦ x ≦ 10^{15}
* x is an integer.
Input
The input is given from Standard Input in the following format:
x
Output
Print the answer.
Examples
Input
7
Output
2
Input
149696127901
Output
27217477801
|
import java.math.BigDecimal;
import java.util.*;
public class Main {
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
long X = sc.nextLong();
if (X <= 6) {
System.out.println(1);
} else {
long numOfSet = X / 11; // set is (6, 5)
long remain = X % 11;
if (remain == 0) {
System.out.println(2 * numOfSet);
} else if (remain <= 6) {
System.out.println(2 * numOfSet + 1);
} else {
System.out.println(2 * numOfSet + 2);
}
}
}
}
|
Mikan's birthday is coming soon. Since Mikan likes graphs very much, Aroma decided to give her a undirected graph this year too.
Aroma bought a connected undirected graph, which consists of n vertices and n edges. The vertices are numbered from 1 to n and for each i(1 \leq i \leq n), vertex i and vartex a_i are connected with an undirected edge. Aroma thinks it is not interesting only to give the ready-made graph and decided to paint it. Count the number of ways to paint the vertices of the purchased graph in k colors modulo 10^9 + 7. Two ways are considered to be the same if the graph painted in one way can be identical to the graph painted in the other way by permutating the numbers of the vertices.
Constraints
* 1 \leq n \leq 10^5
* 1 \leq k \leq 10^5
* 1 \leq a_i \leq n (1 \leq i \leq n)
* The given graph is connected
* The given graph contains no self-loops or multiple edges.
Input
Each data set is given in the following format from the standard input.
n k
a_1
:
a_n
Output
Output the number of ways to paint the vertices of the given graph in k colors modulo 10^9 + 7 in one line.
Examples
Input
4 2
2
3
1
1
Output
12
Input
4 4
2
3
4
1
Output
55
Input
10 5
2
3
4
1
1
1
2
3
3
4
Output
926250
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,a,b) for(int i=(a);i<(b);i++)
#define pb push_back
#define eb emplace_back
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
using vint=vector<int>;
using pint=pair<int,int>;
using vpint=vector<pint>;
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;}
template<class A,class B>
ostream& operator<<(ostream& ost,const pair<A,B>&p){
ost<<"{"<<p.first<<","<<p.second<<"}";
return ost;
}
template<class T>
ostream& operator<<(ostream& ost,const vector<T>&v){
ost<<"{";
for(int i=0;i<v.size();i++){
if(i)ost<<",";
ost<<v[i];
}
ost<<"}";
return ost;
}
struct ModX{
using ull=uint64_t;
static const ull mod=(1ll<<61)-1;
static const ull MASK30=(1ll<<30)-1;
static const ull MASK31=(1ll<<31)-1;
ull a;
ModX& s(ull vv){
a=vv<mod?vv:vv-mod;
return *this;
}
ModX(ull a=0):a(a%mod){}
ModX& operator+=(const ModX& x){return s(a+x.a);}
ModX& operator-=(const ModX& x){return s(a+mod-x.a);}
ModX& operator*=(const ModX& x){
const ull au=a>>31;
const ull ad=a&MASK31;
const ull bu=x.a>>31;
const ull bd=x.a&MASK31;
const ull mid=ad*bu+au*bd;
const ull midu=mid>>30;
const ull midd=mid&MASK30;
const ull z=au*bu*2+midu+(midd<<31)+ad*bd;
return s((z&mod)+(z>>61));
}
ModX operator+(const ModX &x)const{return ModX(*this)+=x;}
ModX operator-(const ModX &x)const{return ModX(*this)-=x;}
ModX operator*(const ModX &x)const{return ModX(*this)*=x;}
bool operator==(const ModX &x)const{return a==x.a;}
bool operator!=(const ModX &x)const{return a!=x.a;}
bool operator<(const ModX &x)const{return a<x.a;}
ModX operator-()const{return ModX()-*this;}
};
istream& operator>>(istream& in,const ModX& a){
return (in>>a.a);
}
ostream& operator<<(ostream& out,const ModX& a){
return (out<<a.a);
}
using xint=ModX;
const xint base(1000000007);
const int RHSIZE=1111111;
xint basepow[RHSIZE];
struct RHInit{
RHInit(){
basepow[0]=1;
for(int i=1;i<RHSIZE;i++)basepow[i]=basepow[i-1]*base;
}
}RHInitDummy;
template<uint32_t mod>
struct ModInt{
uint32_t a;
ModInt& s(uint32_t vv){
a=vv<mod?vv:vv-mod;
return *this;
}
ModInt(int64_t x=0){s(x%mod+mod);}
ModInt& operator+=(const ModInt &x){return s(a+x.a);}
ModInt& operator-=(const ModInt &x){return s(a+mod-x.a);}
ModInt& operator*=(const ModInt &x){
a=uint64_t(a)*x.a%mod;
return *this;
}
ModInt& operator/=(const ModInt &x){
*this*=x.inv();
return *this;
}
ModInt operator+(const ModInt &x)const{return ModInt(*this)+=x;}
ModInt operator-(const ModInt &x)const{return ModInt(*this)-=x;}
ModInt operator*(const ModInt &x)const{return ModInt(*this)*=x;}
ModInt operator/(const ModInt &x)const{return ModInt(*this)/=x;}
bool operator==(const ModInt &x)const{return a==x.a;}
bool operator!=(const ModInt &x)const{return a!=x.a;}
bool operator<(const ModInt &x)const{return a<x.a;}
ModInt operator-()const{return ModInt()-*this;}
ModInt pow(int64_t n)const{
ModInt res(1),x(*this);
while(n){
if(n&1)res*=x;
x*=x;
n>>=1;
}
return res;
}
ModInt inv()const{return pow(mod-2);}
};
template<uint32_t mod>
istream& operator>>(istream& in,const ModInt<mod>& a){
return (in>>a.a);
}
template<uint32_t mod>
ostream& operator<<(ostream& out,const ModInt<mod>& a){
return (out<<a.a);
}
using mint=ModInt<1000000007>;
//using mint=ModInt<998244353>;
template<class Mint,int32_t lg>
struct ModIntTable{
int N;
vector<Mint>facts,finvs,invs;
ModIntTable():N(1<<lg),facts(N),finvs(N),invs(N){
const uint32_t mod=Mint(-1).a+1;
invs[1]=1;
for(int i=2;i<N;i++)invs[i]=invs[mod%i]*(mod-mod/i);
facts[0]=1;
finvs[0]=1;
for(int i=1;i<N;i++){
facts[i]=facts[i-1]*i;
finvs[i]=finvs[i-1]*invs[i];
}
}
inline Mint fact(int n)const{return facts[n];}
inline Mint finv(int n)const{return finvs[n];}
inline Mint inv(int n)const{return invs[n];}
inline Mint binom(int n,int k)const{return facts[n]*finvs[k]*finvs[n-k];}
inline Mint perm(int n,int k)const{return facts[n]*finvs[n-k];}
};
ModIntTable<mint,19>mtable;
// ^ library
//---------------------------------------------------------------
// v main
xint tree_rnd[111111];
mt19937 mt(119);
uniform_int_distribution<long long>uid(0,(1ll<<61)-2);
struct Pre{
Pre(){
for(int i=0;i<111111;i++)tree_rnd[i]=uid(mt);
}
}PreDummy;
int N,K;
vint G[111111];
int deg[111111];
xint tree_hs[111111];
mint tree_col[111111];
int height[111111];
void dfs(int v,int p){
height[v]=0;
tree_col[v]=K;
map<xint,int>cnt;
map<xint,mint>mem;
vector<xint>lis;
for(auto &u:G[v]){
if(u==p||deg[u]==2)continue;
dfs(u,v);
chmax(height[v],height[u]+1);
xint h=tree_hs[u];
cnt[h]++;
mem[h]=tree_col[u];
lis.eb(h);
}
tree_hs[v]=1;
for(auto &h:lis)tree_hs[v]*=tree_rnd[height[v]]+h;
for(auto &q:cnt){
mint w=mem[q.fi];
mint tmp=1;
rep(i,q.se)tmp*=w+i;
tmp*=mtable.finv(q.se);
tree_col[v]*=tmp;
}
}
int gcd(int a,int b){
return b?gcd(b,a%b):a;
}
template<class T>
vector<int>zalgorithm(T s){
vector<int>a(s.size());
a[0]=s.size();
int i=1,j=0;
while(i<s.size()){
while(i+j<s.size()&&s[j]==s[i+j])j++;
a[i]=j;
if(j==0){i++;continue;}
int k=1;
while(i+k<s.size()&&k+a[k]<j)a[i+k]=a[k],k++;
i+=k;j-=k;
}
return a;
}
signed main(){
scanf("%lld%lld",&N,&K);
rep(i,N){
int a;
scanf("%lld",&a);
a--;
G[i].pb(a);G[a].pb(i);
}
rep(i,N)for(auto &u:G[i]){
deg[u]++;
}
queue<int>que;
rep(i,N)if(deg[i]==1){
que.push(i);
}
while(que.size()){
int v=que.front();
que.pop();
for(auto &u:G[v]){
if(--deg[u]==1){
que.push(u);
}
}
}
int cyccnt=0;
rep(i,N)if(deg[i]==2)cyccnt++;
vint c;
rep(i,N)if(deg[i]==2){
c.pb(i);
break;
}
while(c.size()<cyccnt){
for(auto u:G[c.back()]){
if(c.size()>1&&c[c.size()-2]==u)continue;
if(deg[u]!=2)continue;
c.pb(u);
break;
}
}
for(auto u:c)dfs(u,-1);
int n=c.size();
vector<xint>hs_cw,hs_ccw;
vector<mint>col_cw;
hs_cw.pb(0);col_cw.pb(1);
rep(i,2*n){
hs_cw.pb(hs_cw.back()*base+tree_hs[c[i%n]]);
col_cw.pb(col_cw.back()*tree_col[c[i%n]]);
}
hs_ccw.pb(0);
for(int i=2*n-1;i>=0;i--){
hs_ccw.pb(hs_ccw.back()*base+tree_hs[c[i%n]]);
}
vint num(n+1);
reps(i,1,n+1)num[gcd(i,n)]++;
mint ans;
int denom=0;
/*
for(int i=1;i<=n;i++){
if(n%i)continue;
bool ok=true;
for(int j=0;j<n;j++)if(tree_hs[c[j]]!=tree_hs[c[(j+i)%n]])ok=false;
if(!ok)continue;
mint tmp=1;
for(int j=0;j<i;j++)tmp*=tree_col[c[j]];
ans+=tmp*num[i];
denom+=num[i];
}
*/
vector<xint>uku;
rep(i,n)uku.pb(tree_hs[c[i]]);
auto z=zalgorithm(uku);
int cir=n;
for(int i=n-1;i>0;i--){
if(n%i)continue;
if(z[i]==n-i)cir=i;
}
for(int i=1;i<=n;i++){
if(n%i)continue;
if(i%cir)continue;
mint tmp_ans=col_cw[i];
ans+=tmp_ans*num[i];
denom+=num[i];
}
if(n&1){
int len=n/2;
rep(i,n){
xint h=hs_cw[i+1+len]-hs_cw[i+1]*basepow[len];
int k=n-1-(i+n-1)%n;
xint h2=hs_ccw[k+len]-hs_ccw[k]*basepow[len];
if(h!=h2)continue;
mint tmp=col_cw[i+1+len]*col_cw[i].inv();
ans+=tmp;
denom++;
}
}
else{
int len=n/2;
rep(i,n/2){
xint h=hs_cw[i+len]-hs_cw[i]*basepow[len];
int k=n-1-(i+n-1)%n;
xint h2=hs_ccw[k+len]-hs_ccw[k]*basepow[len];
if(h!=h2)continue;
mint tmp=col_cw[i+len]*col_cw[i].inv();
ans+=tmp;
denom++;
}
rep(i,n/2){
xint h=hs_cw[i+len]-hs_cw[i+1]*basepow[len-1];
int k=n-1-(i+n-1)%n;
xint h2=hs_ccw[k+len-1]-hs_ccw[k]*basepow[len-1];
if(h!=h2)continue;
mint tmp=col_cw[i+len+1]*col_cw[i].inv();
ans+=tmp;
denom++;
}
}
ans/=denom;
cout<<ans<<endl;
return 0;
}
|
Aizuwakamatsu City is known as the "City of History". About 400 years ago, the skeleton of the castle town was created by Gamo Ujisato, but after that, it became the central city of the Aizu clan 230,000 stones, whose ancestor was Hoshina Masayuki, the half-brother of Tokugawa's third shogun Iemitsu. Developed. Many tourists from all over the country visit every year because historic sites and remnants of old days still remain throughout the city.
This year, "Shinsengumi!" Is being broadcast in the NHK Taiga drama, so the number of tourists is increasing significantly as a place related to the Shinsengumi (* 1). Therefore, the city decided to install lanterns at intervals of 100 m along the streets connecting the historic sites scattered throughout the city. The condition is that you can reach all the historic sites in the city by following the streets decorated with lanterns, but you do not have to follow it with a single stroke. However, due to the limited budget, it is necessary to minimize the number of lanterns to be installed.
Create a program that reads the data on the street connecting the historic sites and outputs the minimum number of lanterns required. However, the distance between historic sites is greater than or equal to 200 m and is given in multiples of 100. The distance from each historic site to the nearest lantern is 100 m, and there are less than 100 historic sites in the city. There is no need to install a lantern on the historic site itself.
<image>
(* 1) The Shinsengumi was established in the form of the Aizu clan's entrustment, participated in the Aizu Boshin War known for the tragedy of Byakkotai, and Toshizo Hijikata built the grave of Isami Kondo at Tenningji Temple in the city.
Input
Given multiple datasets. Each dataset is given in the following format:
n
m
a1, b1, d1
a2, b2, d2
::
am, bm, dm
The first line of each dataset is given the number of historic sites n. It is then given a few meters of streets connecting the historic sites. The following m lines are given the three comma-separated numbers ai, bi, and di. ai and bi are historic site numbers. Historic sites are numbered from 0 to n-1. ai bi indicates that there is a street connecting them, and di represents the distance of the road between ai bi.
When n is 0, it is the last input. The number of datasets does not exceed 20.
Output
For each dataset, output the minimum number of lanterns required on one line.
Example
Input
4
4
0,1,1500
0,2,2000
1,2,600
1,3,500
0
Output
23
|
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <climits>
static int const N = 100;
int main()
{
for(;;) {
int n, m;
std::cin >> n;
if ( n == 0 )
break;
std::cin >> m;
int G[N][N] = {};
for( int i=0; i<N; ++i )
std::fill( G[i], G[i] + N, INT_MAX );
for( int i=0; i<m; ++i ) {
int a, b, l;
std::scanf( "%d,%d,%d", &a, &b, &l );
l = l / 100 - 1;
G[a][b] = G[b][a] = l;
}
int d[N], p[N] = {};
bool visited[N] = {};
std::fill( d, d + N, INT_MAX );
std::fill( visited, visited + N, false );
// initialize
int u = 0;
d[u] = 0;
p[u] = -1;
int sum = 0;
for( int i=0; i<n; ++i ) {
int tmp = INT_MAX;
for( int j=0; j<n ; ++j ) {
if ( !visited[j] && d[j] < tmp ) {
u = j;
tmp = d[j];
}
}
visited[u] = true;
sum += d[u];
for( int j=0; j<n; ++j ) {
if ( !visited[j] && G[u][j] < d[j] ) {
d[j] = G[u][j];
p[j] = u;
}
}
}
std::cout << sum << std::endl;
}
}
|
In 40XX, the Earth was invaded by aliens! Already most of the Earth has been dominated by aliens, leaving Tsuruga Castle Fortress as the only remaining defense base. Suppression units are approaching the Tsuruga Castle Fortress one after another.
<image>
But hope remains. The ultimate defense force weapon, the ultra-long-range penetrating laser cannon, has been completed. The downside is that it takes a certain distance to reach its power, and enemies that are too close can just pass through. Enemies who have invaded the area where power does not come out have no choice but to do something with other forces. The Defense Forces staff must know the number to deal with the invading UFOs, but it is unlikely to be counted well because there are too many enemies. So the staff ordered you to have a program that would output the number of UFOs that weren't shot down by the laser. Create a program by the time the battle begins and help protect the Tsuruga Castle Fortress.
Enemy UFOs just rush straight toward the base of the laser cannon (the UFOs are treated to slip through each other and do not collide). The laser cannon begins firing at the center of the nearest UFO one minute after the initial state, and then continues firing the laser every minute under the same conditions. The laser penetrates, and the UFO beyond it can be shot down with the laser just scratching it. However, this laser has a range where it is not powerful, and it is meaningless to aim a UFO that has fallen into that range, so it is designed not to aim. How many UFOs invaded the area where the power of the laser did not come out when it was shot down as much as possible?
Create a program that inputs the radius R of the range where the power of the laser does not come out and the information of the invading UFO, and outputs how many UFOs are invading without being shot down. The information on the incoming UFO consists of the number of UFOs N, the initial coordinates of each UFO (x0, y0), the radius r of each UFO, and the speed v of each UFO.
The origin of the coordinates (0, 0) is the position of the laser cannon. The distance between the laser cannon and the UFO is given by the distance from the origin to the center of the UFO, and UFOs with this distance less than or equal to R are within the range where the power of the laser does not come out. Consider that there are no cases where there are multiple targets to be aimed at at the same time. All calculations are considered on a plane and all inputs are given as integers.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
R N
x01 y01 r1 v1
x02 y02 r2 v2
::
x0N y0N rN vN
The first line gives the radius R (1 ≤ R ≤ 500) and the number of UFOs N (1 ≤ N ≤ 100) within the range of laser power. The following N lines give the i-th UFO information x0i, y0i (-100 ≤ x0i, y0i ≤ 1000), ri, vi (1 ≤ ri, vi ≤ 500).
The number of datasets does not exceed 50.
Output
For each input dataset, it prints the number of UFOs that have invaded the area where the laser power does not come out on one line.
Example
Input
100 5
101 101 5 5
110 110 2 3
-112 -100 9 11
-208 160 82 90
-110 108 10 2
10 11
15 0 5 1
25 0 5 1
35 0 5 1
45 0 5 1
55 0 5 1
65 0 5 1
75 0 5 1
85 0 5 1
95 0 5 1
-20 0 5 20
-30 0 500 5
0 0
Output
1
1
|
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <string>
#include <cmath>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <list>
#include <iostream>
#include <sstream>
#include <climits>
#include <cfloat>
#include <complex>
using namespace std;
typedef complex<double> Point;
const double Eps = 1e-8;
double dot(const Point& a, const Point& b)
{
return a.real()*b.real() + a.imag()*b.imag();
}
double cross(const Point& a, const Point& b)
{
return a.real()*b.imag() - a.imag()*b.real();
}
double distance_line_point(const Point& point, const Point& a, const Point& b)
{
return abs(cross(a-b, point-b) / (a-b));
}
double distance_linesegment_point(const Point& point, const Point& a, const Point& b)
{
if (dot(b-a, point-a) < 0)
return abs(a-point);
else if (dot(a-b, point-b) < 0)
return abs(b-point);
else
return distance_line_point(point, a, b);
}
int main()
{
int R, N;
while (scanf("%d %d", &R, &N), R | N)
{
double r[1000], v[1000], d[1000], angle[1000];
for (int i = 0; i < N; ++i)
{
double x, y;
scanf("%lf %lf %lf %lf", &x, &y, r+i, v+i);
d[i] = sqrt(x*x + y*y);
angle[i] = atan2(y, x);
}
int ans = 0;
bool used[1000];
fill(used, used+N, false);
while (true)
{
double shot_angle;
double near = 1e30;
for (int i = 0; i < N; ++i)
{
if (used[i])
continue;
d[i] -= v[i];
if (d[i] < R + Eps)
{
++ans;
used[i] = true;
}
else if (abs(d[i]) < near)
{
near = (d[i]);
shot_angle = angle[i];
}
}
if (near > 1e29)
break;
for (int i = 0; i < N; ++i)
if (!used[i]
&& distance_linesegment_point(Point(d[i]*cos(angle[i])
, d[i]*sin(angle[i])), Point(1e10*cos(shot_angle), 1e10*sin(shot_angle))
, Point(R*cos(shot_angle), R*sin(shot_angle))) < r[i] + Eps)
used[i] = true;
}
printf("%d\n", ans);
}
return 0;
}
|
You are given a string and a number k. You are suggested to generate new strings by swapping any adjacent pair of characters in the string up to k times. Write a program to report the lexicographically smallest string among them.
Input
The input is given in the following format.
s
k
The first line provides a string s. The second line provides the maximum number of swapping operations k (0 ≤ k ≤ 109). The string consists solely of lower-case alphabetical letters and has a length between 1 and 2 × 105.
Output
Output the lexicographically smallest string.
Examples
Input
pckoshien
3
Output
ckopshien
Input
pckoshien
10
Output
cekophsin
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x,vector<x>,greater<x>>
#define all(x) (x).begin(),(x).end()
#define CST(x) cout<<fixed<<setprecision(x)
#define vtpl(x,y,z) vector<tuple<x,y,z>>
#define rev(x) reverse(x);
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
using pl=pair<ll,ll>;
using vpl=vector<pl>;
using vvpl=vector<vpl>;
const ll MOD=1000000007;
const ll MOD9=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,-1,0,1,1,-1,1,-1};
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
class SegTree {
int n;// 葉の数
vector<T> data;// データを格納するvector
T def; // 初期値かつ単位元
function<T(T, T)> operation; // 区間クエリで使う処理
function<T(T, T)> update;// 点更新で使う処理
// 区間[a,b)の総和。ノードk=[l,r)に着目している。
T _query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l) return def; // 交差しない
if (a <= l && r <= b)
return data[k]; // a,l,r,bの順で完全に含まれる
else {
T c1 = _query(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
T c2 = _query(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return operation(c1, c2);
}
}
public:
// _n:必要サイズ, _def:初期値かつ単位元, _operation:クエリ関数,
// _update:更新関数
SegTree(size_t _n, T _def, function<T(T, T)> _operation,
function<T(T, T)> _update)
: def(_def), operation(_operation), update(_update) {
n = 1;
while (n < _n) {
n *= 2;
}
data = vector<T>(2 * n - 1, def);
}
// 場所i(0-indexed)の値をxで更新
void change(int i, T x) {
i += n - 1;
data[i] = update(data[i], x);
while (i > 0) {
i = (i - 1) / 2;
data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);
}
}
// [a, b)の区間クエリを実行
T query(int a, int b) {
return _query(a, b, 0, 0, n);
}
// 添字でアクセス
T operator[](int i) {
return data[i + n - 1];
}
};
int main(){
string s;cin >> s;
ll k;cin >> k;
SegTree<ll> st(
26,0,[](ll a,ll b){return a+b;},[](ll a,ll b){return a+b;}
);
vector<priority_queue<ll,vl,greater<ll>>> alp(26);
vl sub(26,0);
rep(i,s.size()){
alp[s[i]-'a'].push(i-st.query(0,s[i]-'a')-st[s[i]-'a']);
st.change(s[i]-'a',1);
}
/*rep(i,26){
while(!alp[i].empty()){
cout << alp[i].top()<<" ";
alp[i].pop();
}
cout << endl;
}*/
string ans;
rep(i,s.size()){
rep(j,26){
if(alp[j].empty())continue;
if(alp[j].top()-sub[j]<=k){
ans+='a'+j;
k-=alp[j].top()-sub[j];
//cout << k <<endl;
alp[j].pop();
rep(z,j)sub[z]++;
break;
}
}
}
cout << ans <<endl;
}
|
An art exhibition will be held in JOI. At the art exhibition, various works of art from all over the country will be exhibited.
N works of art were collected as candidates for the works of art to be exhibited. These works of art are numbered 1, 2, ..., N. Each work of art has a set value called size and value. The size of the work of art i (1 \ leq i \ leq N) is A_i, and the value is B_i.
At the art exhibition, one or more of these works of art will be selected and exhibited. The venue for the art exhibition is large enough to display all N works of art. However, due to the aesthetic sense of the people of JOI, I would like to select works of art to be exhibited so that the size difference between the works of art does not become too large. On the other hand, I would like to exhibit as many works of art as possible. Therefore, I decided to select the works of art to be exhibited so as to meet the following conditions:
* Let A_ {max} be the size of the largest piece of art and A_ {min} be the size of the smallest piece of art selected. Also, let S be the sum of the values of the selected works of art.
* At this time, maximize S-(A_ {max} --A_ {min}).
Task
Given the number of candidates for the works of art to be exhibited and the size and value of each work of art, find the maximum value of S-(A_ {max} --A_ {min}).
input
Read the following input from standard input.
* The integer N is written on the first line. This represents the number of candidates for the works of art to be exhibited.
* In the i-th line (1 \ leq i \ leq N) of the following N lines, two integers A_i and B_i are written separated by a blank. These indicate that the size of the work of art i is A_i and the value is B_i.
output
Output the maximum value of S-(A_ {max} --A_ {min}) to the standard output on one line.
Limits
All input data satisfy the following conditions.
* 2 \ leq N \ leq 500 000.
* 1 \ leq A_i \ leq 1 000 000 000 000 000 = 10 ^ {15} (1 \ leq i \ leq N).
* 1 \ leq B_i \ leq 1 000 000 000 (1 \ leq i \ leq N).
Input / output example
Input example 1
3
twenty three
11 2
4 5
Output example 1
6
In this input example, there are three candidates for the works of art to be exhibited. The size and value of each work of art are as follows.
* The size of art 1 is 2 and the value is 3.
* Art 2 has a size of 11 and a value of 2.
* Art 3 has a size of 4 and a value of 5.
In this case, if you choose to display art 1 and art 3, then S-(A_ {max} --A_ {min}) = 6 as follows.
* The largest work of art selected is work of art 3. Therefore, A_ {max} = 4.
* The smallest work of art selected is work of art 1. Therefore, A_ {min} = 2.
* Since the sum of the values of the selected works of art is 3 + 5 = 8, S = 8.
Since it is impossible to set S-(A_ {max} --A_ {min}) to 7 or more, 6 is output.
Input example 2
6
4 1
1 5
10 3
9 1
4 2
5 3
Output example 2
7
Input example 3
15
1543361732 260774320
2089759661 257198921
1555665663 389548466
4133306295 296394520
2596448427 301103944
1701413087 274491541
2347488426 912791996
2133012079 444074242
2659886224 656957044
1345396764 259870638
2671164286 233246973
2791812672 585862344
2996614635 91065315
971304780 488995617
1523452673 988137562
Output example 3
4232545716
Creative Commons License
Information Olympics Japan Committee work "17th Japan Information Olympics (JOI 2017/2018) Final Selection"
Example
Input
3
2 3
11 2
4 5
Output
6
|
#include <iostream>
#include <algorithm>
#include <vector>
using lint = long long;
constexpr lint INF = 1LL << 60;
void solve() {
int n;
std::cin >> n;
std::vector<std::pair<lint, lint>> ps(n);
for (auto& p : ps) std::cin >> p.first >> p.second;
std::sort(ps.begin(), ps.end());
lint ans = 0, min = INF, vsum = 0;
for (int r = 0; r < n; ++r) {
min = std::min(min, vsum - ps[r].first);
vsum += ps[r].second;
ans = std::max(ans, vsum - ps[r].first - min);
}
std::cout << ans << std::endl;
}
int main() {
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
solve();
return 0;
}
|
Prof. Hachioji has devised a new numeral system of integral numbers with four lowercase letters "m", "c", "x", "i" and with eight digits "2", "3", "4", "5", "6", "7", "8", "9". He doesn't use digit "0" nor digit "1" in this system.
The letters "m", "c", "x" and "i" correspond to 1000, 100, 10 and 1, respectively, and the digits "2", ...,"9" correspond to 2, ..., 9, respectively. This system has nothing to do with the Roman numeral system.
For example, character strings
> "5m2c3x4i", "m2c4i" and "5m2c3x"
correspond to the integral numbers 5234 (=5*1000+2*100+3*10+4*1), 1204 (=1000+2*100+4*1), and 5230 (=5*1000+2*100+3*10), respectively. The parts of strings in the above example, "5m", "2c", "3x" and "4i" represent 5000 (=5*1000), 200 (=2*100), 30 (=3*10) and 4 (=4*1), respectively.
Each of the letters "m", "c", "x" and "i" may be prefixed by one of the digits "2", "3", ..., "9". In that case, the prefix digit and the letter are regarded as a pair. A pair that consists of a prefix digit and a letter corresponds to an integer that is equal to the original value of the letter multiplied by the value of the prefix digit.
For each letter "m", "c", "x" and "i", the number of its occurrence in a string is at most one. When it has a prefix digit, it should appear together with the prefix digit. The letters "m", "c", "x" and "i" must appear in this order, from left to right. Moreover, when a digit exists in a string, it should appear as the prefix digit of the following letter. Each letter may be omitted in a string, but the whole string must not be empty. A string made in this manner is called an MCXI-string.
An MCXI-string corresponds to a positive integer that is the sum of the values of the letters and those of the pairs contained in it as mentioned above. The positive integer corresponding to an MCXI-string is called its MCXI-value. Moreover, given an integer from 1 to 9999, there is a unique MCXI-string whose MCXI-value is equal to the given integer. For example, the MCXI-value of an MCXI-string "m2c4i" is 1204 that is equal to `1000 + 2*100 + 4*1`. There are no MCXI-strings but "m2c4i" that correspond to 1204. Note that strings "1m2c4i", "mcc4i", "m2c0x4i", and "2cm4i" are not valid MCXI-strings. The reasons are use of "1", multiple occurrences of "c", use of "0", and the wrong order of "c" and "m", respectively.
Your job is to write a program for Prof. Hachioji that reads two MCXI-strings, computes the sum of their MCXI-values, and prints the MCXI-string corresponding to the result.
Input
The input is as follows. The first line contains a positive integer n (<= 500) that indicates the number of the following lines. The k+1 th line is the specification of the k th computation (k=1, ..., n).
> n
> specification1
> specification2
> ...
> specificationn
>
Each specification is described in a line:
> MCXI-string1 MCXI-string2
The two MCXI-strings are separated by a space.
You may assume that the sum of the two MCXI-values of the two MCXI-strings in each specification is less than or equal to 9999.
Output
For each specification, your program should print an MCXI-string in a line. Its MCXI-value should be the sum of the two MCXI-values of the MCXI-strings in the specification. No other characters should appear in the output.
Example
Input
10
xi x9i
i 9i
c2x2i 4c8x8i
m2ci 4m7c9x8i
9c9x9i i
i 9m9c9x8i
m i
i m
m9i i
9m8c7xi c2x8i
Output
3x
x
6cx
5m9c9x9i
m
9m9c9x9i
mi
mi
mx
9m9c9x9i
|
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <sstream>
#include <cctype>
using namespace std;
int mcxi_to_i(string s) {
int ans = 0;
int keta = 1;
for(unsigned int i=0; i<s.size(); i++) {
switch(s[i]) {
case 'm': ans += 1000 * keta; keta = 1; break;
case 'c': ans += 100 * keta; keta = 1; break;
case 'x': ans += 10 * keta; keta = 1; break;
case 'i': ans += 1 * keta; keta = 1; break;
default:
// cerr << s[i] << endl;
keta = (int) s[i] - '0';
// cerr << "keta: " << keta << endl;
break;
}
}
// cerr << ans << endl;
return ans;
}
string keta(int x, int waru, string k) {
int keta = (x%(waru*10))/waru;
if (keta == 0) return "";
if (keta == 1) return k;
stringstream ss;
ss << keta;
return ss.str() + k;
}
string i_to_mcxi(int x) {
return keta(x, 1000, "m") + keta(x, 100, "c")
+ keta(x, 10, "x") + keta(x, 1, "i");
}
int main() {
int n;
scanf("%d", &n);
for (int i=0; i<n; i++) {
string a, b;
cin >> a >> b;
int c = mcxi_to_i(a) + mcxi_to_i(b);
cout << i_to_mcxi(c) << endl;
}
}
|
Your task in this problem is to create a program that finds the shortest path between two given locations on a given street map, which is represented as a collection of line segments on a plane.
<image>
Figure 4 is an example of a street map, where some line segments represent streets and the others are signs indicating the directions in which cars cannot move. More concretely, AE, AM, MQ, EQ, CP and HJ represent the streets and the others are signs in this map. In general, an end point of a sign touches one and only one line segment representing a street and the other end point is open. Each end point of every street touches one or more streets, but no signs.
The sign BF, for instance, indicates that at B cars may move left to right but may not in the reverse direction. In general, cars may not move from the obtuse angle side to the acute angle side at a point where a sign touches a street (note that the angle CBF is obtuse and the angle ABF is acute). Cars may directly move neither from P to M nor from M to P since cars moving left to right may not go through N and those moving right to left may not go through O. In a special case where the angle between a sign and a street is rectangular, cars may not move in either directions at the point. For instance, cars may directly move neither from H to J nor from J to H.
You should write a program that finds the shortest path obeying these traffic rules. The length of a line segment between (x1, y1) and (x2, y2) is √{(x2 − x1)2 + (y2 − y1 )2} .
Input
The input consists of multiple datasets, each in the following format.
n
xs ys
xg yg
x11 y11 x21 y21
.
.
.
x1k y1k x2k y2k
.
.
.
x1n y1n x2n y2n
n, representing the number of line segments, is a positive integer less than or equal to 200.
(xs, ys) and (xg, yg) are the start and goal points, respectively. You can assume that (xs, ys) ≠ (xg, yg) and that each of them is located on an end point of some line segment representing a street. You can also assume that the shortest path from (xs, ys) to (xg, yg) is unique.
(x1k, y1k) and (x2k, y2k ) are the two end points of the kth line segment. You can assume that (x1k, y1k) ≠(x2k, y2k ). Two line segments never cross nor overlap. That is, if they share a point, it is always one of their end points.
All the coordinates are non-negative integers less than or equal to 1000. The end of the input is indicated by a line containing a single zero.
Output
For each input dataset, print every street intersection point on the shortest path from the start point to the goal point, one in an output line in this order, and a zero in a line following those points. Note that a street intersection point is a point where at least two line segments representing streets meet. An output line for a street intersection point should contain its x- and y-coordinates separated by a space.
Print -1 if there are no paths from the start point to the goal point.
Example
Input
8
1 1
4 4
1 1 4 1
1 1 1 4
3 1 3 4
4 3 5 3
2 4 3 5
4 1 4 4
3 3 2 2
1 4 4 4
9
1 5
5 1
5 4 5 1
1 5 1 1
1 5 5 1
2 3 2 4
5 4 1 5
3 2 2 1
4 2 4 1
1 1 5 1
5 3 4 3
11
5 5
1 0
3 1 5 1
4 3 4 2
3 1 5 5
2 3 2 2
1 0 1 2
1 2 3 4
3 4 5 5
1 0 5 2
4 0 4 1
5 5 5 1
2 3 2 4
0
Output
1 1
3 1
3 4
4 4
0
-1
5 5
5 2
3 1
1 0
0
|
#include <cstdio>
#include <iostream>
#include <vector>
#include <list>
#include <cmath>
#include <fstream>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <complex>
#include <iterator>
#include <cstdlib>
#include <cstring>
#include <sstream>
using namespace std;
#define EPS (1e-10)
#define EQ(a,b) (abs((a) - (b)) < EPS)
#define EQV(a,b) (EQ((a).real(),(b).real()) && EQ((a).imag(),(b).imag()))
typedef complex<double> P;
typedef pair<P,P> Edge;
typedef long long ll;
const double PI=4*atan(1.0);
const int MAX_SIZE = 10000;
//#define RED_FILE
#ifdef RED_FILE
ifstream ifs("input.txt");
ofstream ofs("output.txt");
#define cin ifs
#define cout ofs
#endif
// àÏ
double dot(P a, P b) {
return (a.real() * b.real() + a.imag() * b.imag());
}
// OÏ
double cross(P a, P b) {
return (a.real() * b.imag() - a.imag() * b.real());
}
// _cª¼üabãÉ é©È¢©
int is_point_on_line(P a, P b, P c) {
return EQ( cross(b-a, c-a), 0.0 );
}
// 2¼ü̼s»è
int is_orthogonal(P a1, P a2, P b1, P b2) {
return EQ( dot(a1-a2, b1-b2), 0.0 );
}
// 2¼ü̽s»è
int is_parallel(P a1, P a2, P b1, P b2) {
return EQ( cross(a1-a2, b1-b2), 0.0 );
}
// _a,bðÊé¼üÆ_cÌÔÌ£
double distance_l_p(P a, P b, P c) {
return abs(cross(b-a, c-a)) / abs(b-a);
}
// _a,bð[_Æ·éüªÆ_cÆÌ£
double distance_ls_p(P a, P b, P c) {
if ( dot(b-a, c-a) < EPS ) return abs(c-a);
if ( dot(a-b, c-b) < EPS ) return abs(c-b);
return abs(cross(b-a, c-a)) / abs(b-a);
}
// a1,a2ð[_Æ·éüªÆb1,b2ð[_Æ·éüªÌð·»è
int is_intersected_ls(P a1, P a2, P b1, P b2) {
// üªª½sÈêÍdÈÁĢȢ±ÆÉ·é
if(abs(cross(a2-a1,b2-b1)) < EPS){
return 0;
}
return ( cross(a2-a1, b1-a1) * cross(a2-a1, b2-a1) < EPS ) &&
( cross(b2-b1, a1-b1) * cross(b2-b1, a2-b1) < EPS );
}
// a1,a2ð[_Æ·éüªÆb1,b2ð[_Æ·éüªÌð_vZ
P intersection_ls(P a1, P a2, P b1, P b2) {
P b = b2-b1;
double d1 = abs(cross(b, a1-b1));
double d2 = abs(cross(b, a2-b1));
double t = d1 / (d1 + d2);
return a1 + (a2-a1) * t;
}
// a1,a2ðÊé¼üÆb1,b2ðÊé¼üÌð·»è
int is_intersected_l(P a1, P a2, P b1, P b2) {
return !EQ( cross(a1-a2, b1-b2), 0.0 );
}
// a1,a2ðÊé¼üÆb1,b2ðÊé¼üÌð_vZ
P intersection_l(P a1, P a2, P b1, P b2) {
P a = a2 - a1; P b = b2 - b1;
return a1 + a * cross(b, b1-a1) / cross(b, a);
}
// 2xNgÔÌpx
// a©çbÖ¶üèŽx©(0->2*PI)
double diffAngle(P a,P b){
double angle=atan2(cross(a,b),dot(a,b));
if(angle<0)
return 2*PI+angle;
return angle;
}
int n;
int sy,sx;
int gy,gx;
const int INF=1000000000;
double d[1001][1001];
int prv[1001][1001];
int main(){
while(cin>>n&&n!=0){
vector<pair<int,int> > ps;
for(int i = 0; i < 1001; i++){
for(int j = 0; j < 1001; j++){
if(i==j)d[i][j]=0;
else d[i][j]=INF;
prv[i][j]=INF;
}
}
vector<Edge> es;
cin>>sx>>sy;
cin>>gx>>gy;
// ¸_Ìo»ñð²¸
map<pair<int,int>,int > m;
for(int i = 0; i < n; i++){
int x1,x2,y1,y2;
cin>>x1>>y1>>x2>>y2;
m[make_pair(y1,x1)]++;
m[make_pair(y2,x2)]++;
es.push_back(make_pair(P(x1,y1),P(x2,y2)));
}
// roadÆsignŪ¯é
vector<Edge> roads;
vector<Edge> signs;
int nodeNum=0;
map<pair<int,int>,int> nodes;
for(int i = 0; i < n; i++){
P p1=es[i].first;
P p2=es[i].second;
// é_ªÇÌüªÆàNXµÈ¢©Ç¤©ð`FbN
bool p1ok=true;
bool p2ok=true;
for(int j = 0; j < n; j++){
if(i==j)continue;
if(EQ(distance_ls_p(es[j].first,es[j].second,p1),0))
p1ok=false;
if(EQ(distance_ls_p(es[j].first,es[j].second,p2),0))
p2ok=false;
}
// sign
if(p1ok){
// open nodeðãëɵĨ
swap(es[i].first,es[i].second);
signs.push_back(es[i]);
}
// sign
else if(p2ok)
signs.push_back(es[i]);
// road
else{
pair<int,int> p=make_pair((int)(p1.imag()+EPS),(int)(p1.real()+EPS));
pair<int,int> pp=make_pair((int)(p2.imag()+EPS),(int)(p2.real()+EPS));
// ܾo»µÄ¢È¢¸_
if(nodes.find(p)==nodes.end()){
ps.push_back(p);
nodes[p]=nodeNum++;
}
if(nodes.find(pp)==nodes.end()){
ps.push_back(pp);
nodes[pp]=nodeNum++;
}
roads.push_back(es[i]);
}
}
vector<Edge> roads2;
// roadÌð·_Åroadðª·é
for(int i = 0; i < roads.size(); i++){
// ð_Æ[_ðÛ
vector<pair<int,int> > tmp;
// [_ðÛ
tmp.push_back(make_pair((int)(roads[i].first.imag()+EPS),(int)(EPS+roads[i].first.real())));
tmp.push_back(make_pair((int)(roads[i].second.imag()+EPS),(int)(EPS+roads[i].second.real())));
// roadÉð··éð_ð·×ÄßĨ¢ÄA·×ÄÌð_ÌgÝí¹ÌƱëɹðÍé
for(int j = 0; j < roads.size(); j++){
if(i==j)continue;
// ð_ðtmpÉÇÁ
if(!EQV(roads[j].first,roads[i].first)&&!EQV(roads[j].first,roads[i].second)&&EQ(distance_ls_p(roads[i].first,roads[i].second,roads[j].first),0))
tmp.push_back(make_pair((int)(roads[j].first.imag()+EPS),(int)(roads[j].first.real()+EPS)));
if(!EQV(roads[j].second,roads[i].first)&&!EQV(roads[j].second,roads[i].second)&&EQ(distance_ls_p(roads[i].first,roads[i].second,roads[j].second),0))
tmp.push_back(make_pair((int)(roads[j].second.imag()+EPS),(int)(roads[j].second.real()+EPS)));
}
// _ð\[g
sort(tmp.begin(),tmp.end());
// \[gµ½ÔɹðªµÄ¢
pair<int,int> prv=tmp[0];
for(int j = 1; j < tmp.size(); j++){
roads2.push_back(make_pair(P(prv.second,prv.first),P(tmp[j].second,tmp[j].first)));
prv=tmp[j];
}
}
roads=roads2;
// ¼ûüÉÓð£é
for(int i = 0; i < roads2.size(); i++){
pair<int,int> p=make_pair(roads2[i].first.imag(),roads2[i].first.real());
pair<int,int> pp=make_pair(roads2[i].second.imag(),roads2[i].second.real());
d[nodes[p]][nodes[pp]]=abs(roads2[i].first-roads2[i].second);
prv[nodes[p]][nodes[pp]]=nodes[p];
d[nodes[pp]][nodes[p]]=abs(roads2[i].first-roads2[i].second);
prv[nodes[pp]][nodes[p]]=nodes[pp];
}
for(int i = 0; i < signs.size(); i++){
for(int j = 0; j < roads.size(); j++){
P p=signs[i].first;
if(EQ(distance_ls_p(roads[j].first,roads[j].second,p),0)){
P cp=p;
P rp1=roads[j].first;
double ag=diffAngle(rp1-cp,signs[i].second-cp);
if(ag>=PI)
ag=2*PI-ag;
pair<int,int> p1=make_pair((int)(roads[j].first.imag()+EPS),(int)(roads[j].first.real()+EPS));
pair<int,int> p2=make_pair((int)(roads[j].second.imag()+EPS),(int)(roads[j].second.real()+EPS));
int node1=nodes[p1];
int node2=nodes[p2];
if(EQ(ag,PI/2)){
d[node1][node2]=INF;
d[node2][node1]=INF;
prv[node1][node2]=INF;
prv[node2][node1]=INF;
}
else{
int from=node2;
int to=node1;
if(ag<PI/2){
d[from][to]=INF;
prv[from][to]=INF;
}
else{
d[to][from]=INF;
prv[to][from]=INF;
}
}
}
}
}
int V=nodeNum;
// wfÅÅZ£ðvZ
int s=nodes[make_pair(sy,sx)];
int g=nodes[make_pair(gy,gx)];
for(int i = 0; i < V; i++){
for(int j = 0; j < V; j++){
for(int k = 0; k < V; k++){
if(d[j][k]>d[j][i]+d[i][k]){
int cp=k;
// XV
while(1){
prv[j][cp]=prv[i][cp];
cp=prv[i][cp];
if(cp==i)break;
}
d[j][k]=d[j][i]+d[i][k];
}
}
}
}
if(EQ(d[s][g],INF)){
cout<<-1<<endl;
continue;
}
else{
vector<int> v;
int cp=g;
while(1){
v.push_back(cp);
if(cp==s)
break;
cp=prv[s][cp];
}
for(int j = v.size()-1; j >= 0; j--)
cout<<ps[v[j]].second<<" "<<ps[v[j]].first<<endl;
cout<<0<<endl;
}
}
return 0;
}
|
Draw in Straight Lines
You plan to draw a black-and-white painting on a rectangular canvas. The painting will be a grid array of pixels, either black or white. You can paint black or white lines or dots on the initially white canvas.
You can apply a sequence of the following two operations in any order.
* Painting pixels on a horizontal or vertical line segment, single pixel wide and two or more pixel long, either black or white. This operation has a cost proportional to the length (the number of pixels) of the line segment multiplied by a specified coefficient in addition to a specified constant cost.
* Painting a single pixel, either black or white. This operation has a specified constant cost.
You can overpaint already painted pixels as long as the following conditions are satisfied.
* The pixel has been painted at most once before. Overpainting a pixel too many times results in too thick layers of inks, making the picture look ugly. Note that painting a pixel with the same color is also counted as overpainting. For instance, if you have painted a pixel with black twice, you can paint it neither black nor white anymore.
* The pixel once painted white should not be overpainted with the black ink. As the white ink takes very long to dry, overpainting the same pixel black would make the pixel gray, rather than black. The reverse, that is, painting white over a pixel already painted black, has no problem.
Your task is to compute the minimum total cost to draw the specified image.
Input
The input consists of a single test case. The first line contains five integers $n$, $m$, $a$, $b$, and $c$, where $n$ ($1 \leq n \leq 40$) and $m$ ($1 \leq m \leq 40$) are the height and the width of the canvas in the number of pixels, and $a$ ($0 \leq a \leq 40$), $b$ ($0 \leq b \leq 40$), and $c$ ($0 \leq c \leq 40$) are constants defining painting costs as follows. Painting a line segment of length $l$ costs $al + b$ and painting a single pixel costs $c$. These three constants satisfy $c \leq a + b$.
The next $n$ lines show the black-and-white image you want to draw. Each of the lines contains a string of length $m$. The $j$-th character of the $i$-th string is ‘#’ if the color of the pixel in the $i$-th row and the $j$-th column is to be black, and it is ‘.’ if the color is to be white.
Output
Output the minimum cost.
Sample Input 1
3 3 1 2 3
.#.
.#.
Sample Output 1
10
Sample Input 2
2 7 0 1 1
.###
.###
Sample Output 2
3
Sample Input 3
5 5 1 4 4
..#..
..#..
.##
..#..
..#..
Sample Output 3
24
Sample Input 4
7 24 1 10 10
...###..#####....###.
.#...#...#.#....#..#...#
.#..#......#....#.#.....
.#..#......#####..#.....
.#..#......#......#.....
.#...#...#.#.......#...#
...###..#........###.
Sample Output 4
256
Example
Input
3 3 1 2 3
.#.
###
.#.
Output
10
|
#include<stdio.h>
#include<cstring>
#include<algorithm>
#include<vector>
#include<map>
#include<assert.h>
#include<set>
#include<cmath>
#include<queue>
#include<cstdlib>
#include<iostream>
#include<bitset>
#define pii pair<int,int>
#define fi first
#define se second
#define pb push_back
#define rep(i,j,k) for(int i=(int)(j);i<=(int)(k);i++)
#define per(i,j,k) for(int i=(int)(j);i>=(int)(k);i--)
using namespace std;
typedef long long LL;
typedef double db;
const int inf=1e9;
namespace h{
const int N=43*43*4;
int head[N],np[N*20],p[N*20],flow[N*20],tot;
int S,T;
void init(int n){
S=n+1;
T=n+2;
rep(i,1,T)head[i]=0;
rep(i,1,tot){
p[i]=np[i]=flow[i]=0;
}
tot=1;
}
void add(int a ,int b,int c){
++tot;p[tot]=b;np[tot]=head[a];head[a]=tot;flow[tot]=c;
++tot;p[tot]=a;np[tot]=head[b];head[b]=tot;flow[tot]=0;
}
void ax(int x,int a){
//贡献 ax
add(S,x,a);
}
void a1_x(int x,int a){
//贡献 a(1-x)
add(x,T,a);
}
void cx1_y(int x,int y,int c){
//贡献 cx(1-y)
add(y,x,c);
}
int q[N],dis[N];
int bfs(){
rep(i,1,T)dis[i]=-1;
q[q[0]=1]=S;
dis[S]=0;
rep(i,1,q[0]){
int x=q[i];
for(int u=head[x];u;u=np[u])if(dis[p[u]]==-1)if(flow[u]){
dis[p[u]]=dis[x]+1;
q[++q[0]]=p[u];
}
}
return dis[T];
}
int dinic(int x,int ff){
int res=0;
if(x==T)return ff;
for(int u=head[x];u;u=np[u])if(dis[p[u]]==dis[x]+1)if(flow[u]){
int ret=dinic(p[u],min(ff,flow[u]));
flow[u]-=ret;
flow[u^1]+=ret;
ff-=ret;
res+=ret;
if(!ff)break;
}
if(!res)dis[x]=-1;
return res;
}
int calc(){
int ans=0;
while(bfs()!=-1)ans+=dinic(S,1e9);
return ans;
}
};
const int N=45;
int n,m,ca,cb,cc;
char s[N][N];
int bh[N][N],_wh[N][N],_bv[N][N],wv[N][N];
int t;
void Main(){
scanf("%d%d%d%d%d",&n,&m,&ca,&cb,&cc);
rep(i,1,n)scanf("%s",s[i]+1);
t=0;
rep(i,1,n)rep(j,1,m){
bh[i][j]=++t;
wv[i][j]=++t;
_wh[i][j]=++t;
_bv[i][j]=++t;
}
h::init(t);
//cost of paint h or v
rep(i,1,n)rep(j,1,m){
h::ax(bh[i][j],ca);
h::ax(wv[i][j],ca);
h::a1_x(_wh[i][j],ca);
h::a1_x(_bv[i][j],ca);
if(j+1<=m){
h::cx1_y(bh[i][j],bh[i][j+1],cb);
h::cx1_y(_wh[i][j+1],_wh[i][j],cb);
}
else{
h::ax(bh[i][j],cb);
h::a1_x(_wh[i][j],cb);
}
if(i+1<=n){
h::cx1_y(wv[i][j],wv[i+1][j],cb);
h::cx1_y(_bv[i+1][j],_bv[i][j],cb);
}
else{
h::ax(wv[i][j],cb);
h::a1_x(_bv[i][j],cb);
}
}
//cost of paint single dot
rep(i,1,n)rep(j,1,m){
if(s[i][j]=='#'){
//black
//前面不能往这里涂白，只要涂白就是inf
h::ax(wv[i][j],inf);
h::a1_x(_wh[i][j],inf);
//如果没被涂过，就要 c 的代价
h::cx1_y(_bv[i][j],bh[i][j],cc);
}
else{
//white
//涂了黑且没涂白就要 c 的代价，因为同一个格子不可能被hh,vv，所以只有两种情况
h::cx1_y(bh[i][j],wv[i][j],cc);
h::cx1_y(_wh[i][j],_bv[i][j],cc);
//涂了两次黑，就是inf
h::cx1_y(bh[i][j],_bv[i][j],inf);
}
}
printf("%d\n",h::calc());
}
int main(){
int t=1;
while(t--)Main();
return 0;
}
|
<!--
Problem E
-->
Cube Surface Puzzle
Given a set of six pieces, "Cube Surface Puzzle" is to construct a hollow cube with filled surface. Pieces of a puzzle is made of a number of small unit cubes laid grid-aligned on a plane. For a puzzle constructing a cube of its side length n, unit cubes are on either of the following two areas.
* Core (blue): A square area with its side length n−2. Unit cubes fill up this area.
* Fringe (red): The area of width 1 unit forming the outer fringe of the core. Each unit square in this area may be empty or with a unit cube on it.
Each piece is connected with faces of its unit cubes. Pieces can be arbitrarily rotated and either side of the pieces can be inside or outside of the constructed cube. The unit cubes on the core area should come in the centers of the faces of the constructed cube.
Consider that we have six pieces in Fig. E-1 (The first dataset of Sample Input). Then, we can construct a cube as shown in Fig. E-2.
<image> Fig. E-1 Pieces from the first dataset of Sample Input <image> Fig. E-2 Constructing a cube
Mr. Hadrian Hex has collected a number of cube surface puzzles. One day, those pieces were mixed together and he cannot find yet from which six pieces he can construct a cube. Your task is to write a program to help Mr. Hex, which judges whether we can construct a cube for a given set of pieces.
Input
The input consists of at most 200 datasets, each in the following format.
> n
> x1,1x1,2 … x1,n
> x2,1x2,2 … x2,n
> …
> x6n,1x6n,2 … x6n,n
The first line contains an integer n denoting the length of one side of the cube to be constructed (3 ≤ n ≤ 9, n is odd). The following 6n lines give the six pieces. Each piece is described in n lines. Each of the lines corresponds to one grid row and each of the characters in the line, either 'X' or '.', indicates whether or not a unit cube is on the corresponding unit square: 'X' means a unit cube is on the column and '.' means none is there.
The core area of each piece is centered in the data for the piece.
The end of the input is indicated by a line containing a zero.
Output
For each dataset, output "`Yes`" if we can construct a cube, or "`No`" if we cannot.
Sample Input
5
..XX.
.XXX.
XXXXX
XXXXX
X....
....X
XXXXX
.XXX.
.XXX.
.....
..XXX
XXXX.
.XXXX
.XXXX
...X.
...X.
.XXXX
XXXX.
XXXX.
.X.X.
XXX.X
.XXXX
XXXXX
.XXXX
.XXXX
XX...
.XXXX
XXXXX
XXXXX
XX...
5
..XX.
.XXX.
XXXXX
XXXX.
X....
....X
XXXXX
.XXX.
.XXX.
.....
.XXXX
XXXX.
.XXXX
.XXXX
...X.
...X.
.XXXX
XXXX.
XXXX.
.X.X.
XXX.X
.XXXX
XXXXX
.XXXX
.XXXX
XX...
XXXXX
XXXXX
.XXXX
XX...
0
Output for the Sample Input
Yes
No
Example
Input
5
..XX.
.XXX.
XXXXX
XXXXX
X....
....X
XXXXX
.XXX.
.XXX.
.....
..XXX
XXXX.
.XXXX
.XXXX
...X.
...X.
.XXXX
XXXX.
XXXX.
.X.X.
XXX.X
.XXXX
XXXXX
.XXXX
.XXXX
XX...
.XXXX
XXXXX
XXXXX
XX...
5
..XX.
.XXX.
XXXXX
XXXX.
X....
....X
XXXXX
.XXX.
.XXX.
.....
.XXXX
XXXX.
.XXXX
.XXXX
...X.
...X.
.XXXX
XXXX.
XXXX.
.X.X.
XXX.X
.XXXX
XXXXX
.XXXX
.XXXX
XX...
XXXXX
XXXXX
.XXXX
XX...
0
Output
Yes
No
|
#include<cstdio>
#include<vector>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;
#define f(i,n) for(int i=0;i<(int)n;i++)
#define N 1010000
vector<int>b;
vector<int>s;
vector<int>r;
int n, k;
char a[N];
int main(void) {
int a[6][4][2];
int r[6][4][2];
int num[24][4];
int d[4];
vector<int>nummake;
f(i, 4)nummake.push_back(i);
f(i, 24) {
f(j, 4)num[i][j] = nummake[j];
next_permutation(nummake.begin(), nummake.end());
}
bool used[6];
int b[12];
int bb[12];
int n, k, kk, nn;
int x, y, z;
int e[4];
int p[4];
int q[4];
char c[10][10];
bool v, vv;
while (true) {
vv = false;
scanf("%d", &n);
if (n == 0)return 0;
k = 1;
f(i, n)k = k * 2;
nn = k / 2;
k--;
kk = (k / 2) - 1;
f(i, 6)used[i] = false;
used[0] = true;
f(i, 6) {
f(ii, 10) {
f(jj, 10)c[ii][jj] = 0;
}
f(ii, n)scanf("%s", c[ii]);
x = 0;
f(j, n) {
x *= 2;
if (c[0][j] == 'X')x++;
}
a[i][0][0] = x;
r[i][0][1] = x;
x = 0;
for (int j = n - 1; j >= 0; j--) {
x *= 2;
if (c[0][j] == 'X')x++;
}
a[i][0][1] = x;
r[i][0][0] = x;
x = 0;
f(j, n) {
x *= 2;
if (c[j][n - 1] == 'X')x++;
}
a[i][1][0] = x;
r[i][3][1] = x;
x = 0;
for (int j = n - 1; j >= 0; j--) {
x *= 2;
if (c[j][n - 1] == 'X')x++;
}
a[i][3][1] = x;
r[i][1][0] = x;
x = 0;
for (int j = n - 1; j >= 0; j--) {
x *= 2;
if (c[n - 1][j] == 'X')x++;
}
a[i][2][0] = x;
r[i][2][1] = x;
x = 0;
f(j, n) {
x *= 2;
if (c[n - 1][j] == 'X')x++;
}
a[i][2][1] = x;
r[i][2][0] = x;
x = 0;
for (int j = n - 1; j >= 0; j--) {
x *= 2;
if (c[j][0] == 'X')x++;
}
a[i][3][0] = x;
r[i][1][1] = x;
x = 0;
f(j, n) {
x *= 2;
if (c[j][0] == 'X')x++;
}
a[i][1][1] = x;
r[i][3][0] = x;
}
f(i, 4)b[i] = a[0][i][0];
f(i, 40) {
x = i / 8;
x++;
used[x] = true;
if ((i % 8) < 4) {
y = i % 4;
f(j, 4) {
z = (y + j) % 4;
b[j + 4] = a[x][z][0];
}
}
else {
y = i % 4;
f(j, 4) {
z = (y + j) % 4;
b[j + 4] = a[x][z][1];
}
}
x = 0;
f(j, 6) {
if (!used[j]) {
d[x] = j;
x++;
}
}
f(j, 24) {
f(ii, 4)e[ii] = d[num[j][ii]];
f(i0, 8) {
p[0] = i0 % 4;
q[0] = i0 / 4;
x = p[0] % 4;
bb[0] = r[e[0]][x][q[0]];
if ((b[0] & bb[0]) != 0)continue;
if ((kk&(b[0] | bb[0])) != kk)continue;
x = (p[0] + 1) % 4;
b[8] = a[e[0]][x][q[0]];
x = (p[0] + 2) % 4;
bb[4] = a[e[0]][x][q[0]];
if ((b[4] & bb[4]) != 0)continue;
if ((kk&(b[4] | bb[4])) != kk)continue;
x = (p[0] + 3) % 4;
b[9] = r[e[0]][x][q[0]];
f(i1, 8) {
p[1] = i1 % 4;
q[1] = i1 / 4;
x = p[1] % 4;
bb[1] = r[e[1]][x][q[1]];
if ((b[1] & bb[1]) != 0)continue;
if ((kk&(b[1] | bb[1])) != kk)continue;
x = (p[1] + 1) % 4;
bb[9] = a[e[1]][x][q[1]];
if ((b[9] & bb[9]) != 0)continue;
if ((kk&(b[9] | bb[9])) != kk)continue;
x = (p[1] + 2) % 4;
bb[5] = a[e[1]][x][q[1]];
if ((b[5] & bb[5]) != 0)continue;
if ((kk&(b[5] | bb[5])) != kk)continue;
x = (p[1] + 3) % 4;
b[10] = r[e[1]][x][q[1]];
f(i2, 8) {
p[2] = i2 % 4;
q[2] = i2 / 4;
x = p[2] % 4;
bb[2] = r[e[2]][x][q[2]];
if ((b[2] & bb[2]) != 0)continue;
if ((kk&(b[2] | bb[2])) != kk)continue;
x = (p[2] + 1) % 4;
bb[10] = a[e[2]][x][q[2]];
if ((b[10] & bb[10]) != 0)continue;
if ((kk&(b[10] | bb[10])) != kk)continue;
x = (p[2] + 2) % 4;
bb[6] = a[e[2]][x][q[2]];
if ((b[6] & bb[6]) != 0)continue;
if ((kk&(b[6] | bb[6])) != kk)continue;
x = (p[2] + 3) % 4;
b[11] = r[e[2]][x][q[2]];
f(i3, 8) {
p[3] = i3 % 4;
q[3] = i3 / 4;
x = p[3] % 4;
bb[3] = r[e[3]][x][q[3]];
if ((b[3] & bb[3]) != 0)continue;
if ((kk&(b[3] | bb[3])) != kk)continue;
x = (p[3] + 1) % 4;
bb[11] = a[e[3]][x][q[3]];
if ((b[11] & bb[11]) != 0)continue;
if ((kk&(b[11] | bb[11])) != kk)continue;
x = (p[3] + 2) % 4;
bb[7] = a[e[3]][x][q[3]];
if ((b[7] & bb[7]) != 0)continue;
if ((kk&(b[7] | bb[7])) != kk)continue;
x = (p[3] + 3) % 4;
bb[8] = r[e[3]][x][q[3]];
if ((b[8] & bb[8]) != 0)continue;
if ((kk&(b[8] | bb[8])) != kk)continue;
if ((b[7] + b[8] + bb[8]) % 2 == 0)continue;
if ((b[4] + b[9] + bb[9]) % 2 == 0)continue;
if ((b[5] + b[10] + bb[10]) % 2 == 0)continue;
if ((b[6] + b[11] + bb[11]) % 2 == 0)continue;
if ((b[3] + (b[8] / nn) + (bb[8] / nn)) % 2 == 0)continue;
if ((b[0] + (b[9] / nn) + (bb[9] / nn)) % 2 == 0)continue;
if ((b[1] + (b[10] / nn) + (bb[10] / nn)) % 2 == 0)continue;
if ((b[2] + (b[11] / nn) + (bb[11] / nn)) % 2 == 0)continue;
vv = true;
break;
}
if (vv)break;
}
if (vv)break;
}
if (vv)break;
}
if (vv)break;
}
x = (i / 8) + 1;
used[x] = false;
if (vv)break;
}
if (!vv) {
f(i, 4)b[i] = a[0][i][1];
f(i, 40) {
x = i / 8;
x++;
used[x] = true;
if ((i % 8) < 4) {
y = i % 4;
f(j, 4) {
z = (y + j) % 4;
b[j + 4] = a[x][z][0];
}
}
else {
y = i % 4;
f(j, 4) {
z = (y + j) % 4;
b[j + 4] = a[x][z][1];
}
}
x = 0;
f(j, 6) {
if (!used[j]) {
d[x] = j;
x++;
}
}
f(j, 24) {
f(ii, 4)e[ii] = d[num[j][ii]];
f(i0, 8) {
p[0] = i0 % 4;
q[0] = i0 / 4;
x = p[0] % 4;
bb[0] = r[e[0]][x][q[0]];
if ((b[0] & bb[0]) != 0)continue;
if ((kk&(b[0] | bb[0])) != kk)continue;
x = (p[0] + 1) % 4;
b[8] = a[e[0]][x][q[0]];
x = (p[0] + 2) % 4;
bb[4] = a[e[0]][x][q[0]];
if ((b[4] & bb[4]) != 0)continue;
if ((kk&(b[4] | bb[4])) != kk)continue;
x = (p[0] + 3) % 4;
b[9] = r[e[0]][x][q[0]];
f(i1, 8) {
p[1] = i1 % 4;
q[1] = i1 / 4;
x = p[1] % 4;
bb[1] = r[e[1]][x][q[1]];
if ((b[1] & bb[1]) != 0)continue;
if ((kk&(b[1] | bb[1])) != kk)continue;
x = (p[1] + 1) % 4;
bb[9] = a[e[1]][x][q[1]];
if ((b[9] & bb[9]) != 0)continue;
if ((kk&(b[9] | bb[9])) != kk)continue;
x = (p[1] + 2) % 4;
bb[5] = a[e[1]][x][q[1]];
if ((b[5] & bb[5]) != 0)continue;
if ((kk&(b[5] | bb[5])) != kk)continue;
x = (p[1] + 3) % 4;
b[10] = r[e[1]][x][q[1]];
f(i2, 8) {
p[2] = i2 % 4;
q[2] = i2 / 4;
x = p[2] % 4;
bb[2] = r[e[2]][x][q[2]];
if ((b[2] & bb[2]) != 0)continue;
if ((kk&(b[2] | bb[2])) != kk)continue;
x = (p[2] + 1) % 4;
bb[10] = a[e[2]][x][q[2]];
if ((b[10] & bb[10]) != 0)continue;
if ((kk&(b[10] | bb[10])) != kk)continue;
x = (p[2] + 2) % 4;
bb[6] = a[e[2]][x][q[2]];
if ((b[6] & bb[6]) != 0)continue;
if ((kk&(b[6] | bb[6])) != kk)continue;
x = (p[2] + 3) % 4;
b[11] = r[e[2]][x][q[2]];
f(i3, 8) {
p[3] = i3 % 4;
q[3] = i3 / 4;
x = p[3] % 4;
bb[3] = r[e[3]][x][q[3]];
if ((b[3] & bb[3]) != 0)continue;
if ((kk&(b[3] | bb[3])) != kk)continue;
x = (p[3] + 1) % 4;
bb[11] = a[e[3]][x][q[3]];
if ((b[11] & bb[11]) != 0)continue;
if ((kk&(b[11] | bb[11])) != kk)continue;
x = (p[3] + 2) % 4;
bb[7] = a[e[3]][x][q[3]];
if ((b[7] & bb[7]) != 0)continue;
if ((kk&(b[7] | bb[7])) != kk)continue;
x = (p[3] + 3) % 4;
bb[8] = r[e[3]][x][q[3]];
if ((b[8] & bb[8]) != 0)continue;
if ((kk&(b[8] | bb[8])) != kk)continue;
if ((b[7] + b[8] + bb[8]) % 2 == 0)continue;
if ((b[4] + b[9] + bb[9]) % 2 == 0)continue;
if ((b[5] + b[10] + bb[10]) % 2 == 0)continue;
if ((b[6] + b[11] + bb[11]) % 2 == 0)continue;
if ((b[3] + (b[8] / nn) + (bb[8] / nn)) % 2 == 0)continue;
if ((b[0] + (b[9] / nn) + (bb[9] / nn)) % 2 == 0)continue;
if ((b[1] + (b[10] / nn) + (bb[10] / nn)) % 2 == 0)continue;
if ((b[2] + (b[11] / nn) + (bb[11] / nn)) % 2 == 0)continue;
vv = true;
break;
}
if (vv)break;
}
if (vv)break;
}
if (vv)break;
}
if (vv)break;
}
x = (i / 8) + 1;
used[x] = false;
if (vv)break;
}
}
if (vv)printf("Yes\n");
else printf("No\n");
}
return 0;
}
|
Issac H. Ives hosted a party for girls. He had some nice goods and wanted to distribute them to the girls as the presents. However, there were not enough number of presents and thus he needed to decide who would take them. He held a game for that purpose.
Before the game, Issac had all the girls divided into two teams: he named his close friends Bella and Gabriella as two leaders and asked other girls to join either Bella or Gabriella. After the two teams were formed, Issac asked the girls to form one big circle.
The rule of the game was as follows. The game consisted of a number of rounds. In each round, the girls called numbers from 1 to N in clockwise order (N was a number fixed before the game started). The girl calling the number N was told to get out of the circle and excluded from the rest of the game. Then the next round was started from the next girl, that is, the girls called the numbers again, and the one calling N left the circle. This was repeated until only the members of either team remained. The remaining team won the game.
As the game went on, Bella found far more girls of her team excluded than those of Gabriella’s team. Bella complained it, and requested Issac to make the next round begin with a call of zero instead of one. Issac liked her idea as he was a computer scientist, and accepted her request. After that round, many girls of Gabriella’s team came to leave the circle, and eventually Bella’s team won the game and got the presents from Issac.
Now let’s consider the following situation. There are two teams led by Bella and Gabriella respectively, where they does not necessarily have the same numbers of members. Bella is allowed to change the starting number from one to zero at up to one round (regardless the starting girl belongs to her team or not). We want to know how many girls of Bella’s team at most can remain in the circle. You are requested to write a program for it.
Input
The input is a sequence of datasets. The first line of the input contains the number of datasets. The number of datasets does not exceed 200.
Each dataset consists of a line with a positive integer N (1 ≤ N ≤ 230) and a string that specifies the clockwise order of the girls. Each character of the string is either ‘B’ (that denotes a member of Bella’s team) or ‘G’ (Gabriella’s team). The first round begins with the girl indicated by the first character of the string. The length of the string is between 2 and 200 inclusive.
Output
For each dataset, print in a line the maximum possible number of the girls of Bella’s team remaining in the circle, or “0” (without quotes) if there are no ways for Bella’s team to win the game.
Example
Input
6
1 GB
3 GBGBBB
9 BBBGBBBGGG
9 GGBGBBGBBB
7 GBGGGGBGGG
3 BBBBBGBBBB
Output
1
4
4
1
0
8
|
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
//Girls' Party
public class Main{
int N, res;
Set<String>[] v;
void dfs(int nb, int ng, int z, String s){
if(nb<=res)return;
if(ng==0){
res = nb; return;
}
if(v[z].contains(s))return;
v[z].add(s);
int n = s.length(), d = (N-1)%n;
if(s.charAt(d)=='B'){
dfs(nb-1, ng, z, s.substring(d+1)+s.substring(0, d));
}
else{
dfs(nb, ng-1, z, s.substring(d+1)+s.substring(0, d));
}
if(z==1)return;
d = N%n;
if(s.charAt(d)=='B'){
dfs(nb-1, ng, 1, s.substring(d+1)+s.substring(0, d));
}
else{
dfs(nb, ng-1, 1, s.substring(d+1)+s.substring(0, d));
}
}
@SuppressWarnings("unchecked")
void run(){
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
while(T--!=0){
N = sc.nextInt();
String s = sc.next();
v = new Set[2];
v[0] = new HashSet<String>(); v[1] = new HashSet<String>();
res = 0;
int nb = 0, ng = 0;
for(char c:s.toCharArray())
if(c=='B')nb++;
else ng++;
dfs(nb, ng, 0, s);
System.out.println(res);
}
}
public static void main(String[] args) {
new Main().run();
}
}
|
N people run a marathon. There are M resting places on the way. For each resting place, the i-th runner takes a break with probability P_i percent. When the i-th runner takes a break, he gets rest for T_i time.
The i-th runner runs at constant speed V_i, and the distance of the marathon is L.
You are requested to compute the probability for each runner to win the first place. If a runner arrives at the goal with another person at the same time, they are not considered to win the first place.
Input
A dataset is given in the following format:
N M L
P_1 T_1 V_1
P_2 T_2 V_2
...
P_N T_N V_N
The first line of a dataset contains three integers N (1 \leq N \leq 100), M (0 \leq M \leq 50) and L (1 \leq L \leq 100,000). N is the number of runners. M is the number of resting places. L is the distance of the marathon.
Each of the following N lines contains three integers P_i (0 \leq P_i \leq 100), T_i (0 \leq T_i \leq 100) and V_i (0 \leq V_i \leq 100) describing the i-th runner. P_i is the probability to take a break. T_i is the time of resting. V_i is the speed.
Output
For each runner, you should answer the probability of winning. The i-th line in the output should be the probability that the i-th runner wins the marathon. Each number in the output should not contain an error greater than 10^{-5}.
Examples
Input
2 2 50
30 50 1
30 50 2
Output
0.28770000
0.71230000
Input
2 1 100
100 100 10
0 100 1
Output
0.00000000
1.00000000
Input
3 1 100
50 1 1
50 1 1
50 1 1
Output
0.12500000
0.12500000
0.12500000
Input
2 2 50
30 0 1
30 50 2
Output
0.51000000
0.49000000
|
#include<stdio.h>
#include<algorithm>
using namespace std;
int p[110];
int t[110];
int v[110];
double dp[110][110];
double prob[110][110];
int main(){
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
for(int i=0;i<a;i++){
scanf("%d%d%d",p+i,t+i,v+i);
for(int j=0;j<=b;j++)for(int k=0;k<=b;k++)dp[j][k]=0;
dp[0][0]=1;
for(int j=0;j<b;j++){
for(int k=0;k<=j;k++){
dp[j+1][k+1]+=dp[j][k]*p[i]/100;
dp[j+1][k]+=dp[j][k]*(100-p[i])/100;
}
}
for(int j=0;j<=b;j++)prob[i][j]=dp[b][j];
}
double EPS=1e-12;
for(int i=0;i<a;i++){
double ret=0;
for(int j=0;j<=b;j++){
if(!v[i])continue;
double time=(double)c/v[i]+j*t[i];
double ks=prob[i][j];
for(int k=0;k<a;k++){
if(i==k)continue;
double tmp=0;
for(int l=0;l<=b;l++){
if(v[k]&&time+EPS>(double)c/v[k]+l*t[k])continue;
tmp+=prob[k][l];
}
ks*=tmp;
}
ret+=ks;
}
printf("%.12f\n",ret);
}
}
|
You are a secret agent from the Intelligence Center of Peacemaking Committee. You've just sneaked into a secret laboratory of an evil company, Automated Crime Machines.
Your mission is to get a confidential document kept in the laboratory. To reach the document, you need to unlock the door to the safe where it is kept. You have to unlock the door in a correct way and with a great care; otherwise an alarm would ring and you would be caught by the secret police.
The lock has a circular dial with N lights around it and a hand pointing to one of them. The lock also has M buttons to control the hand. Each button has a number Li printed on it.
Initially, all the lights around the dial are turned off. When the i-th button is pressed, the hand revolves clockwise by Li lights, and the pointed light is turned on. You are allowed to press the buttons exactly N times. The lock opens only when you make all the lights turned on.
<image>
For example, in the case with N = 6, M = 2, L1 = 2 and L2 = 5, you can unlock the door by pressing buttons 2, 2, 2, 5, 2 and 2 in this order.
There are a number of doors in the laboratory, and some of them don’t seem to be unlockable. Figure out which lock can be opened, given the values N, M, and Li's.
Input
The input starts with a line containing two integers, which represent N and M respectively. M lines follow, each of which contains an integer representing Li.
It is guaranteed that 1 ≤ N ≤ 109, 1 ≤ M ≤ 105, and 1 ≤ Li ≤ N for each i = 1, 2, ... N.
Output
Output a line with "Yes" (without quotes) if the lock can be opened, and "No" otherwise.
Examples
Input
6 2
2
5
Output
Yes
Input
3 1
1
Output
Yes
Input
4 2
2
4
Output
No
|
#include<cstdio>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
int gcd(int a,int b){ return b?gcd(b,a%b):a; }
int main(){
int n,m; scanf("%d%d",&n,&m);
rep(i,m){
int l; scanf("%d",&l);
n=gcd(n,l);
}
puts(n==1?"Yes":"No");
return 0;
}
|
You and your grandma are playing with graph automata, which is generalization of cell automata.
A graph automaton is expressed by a graph. The vertices of the graph have a time-dependent value, which can be either 0 or 1. There is no more than one edge between any of two vertices, but self-loops might exist.
The values of vertices change regularly according to the following rule: At time t+1, the value of vertex i will be 1 if and only if there are an odd number of edges from the vertex i to a vertex which has the value 1 at time t; otherwise 0.
Now, your forgetful grandma forgot the past states of the automaton. Your task is to write a program which recovers the past states from the current time and states --- time machines are way too expensive. There may be multiple candidates or no consistent states. For such cases, you must print an appropriate error message.
Input
The input is formatted as follows:
N
a_{11} ... a_{1N}
:
:
a_{N1} ... a_{NN}
v_1
:
:
v_N
T
The first line contains one integer N (2 \leq N \leq 300). N indicates the number of vertices. The following N lines indicate the adjacent matrix of the graph. When (i,j)-element is 1, there is an edge from vertex i to vertex j. Otherwise, there is no edge. The following N lines indicate the value vector of the vertices. The i-th element indicates the value of vertex i at time 0. Each element of the matrix and the vector can be 0 or 1. The last line contains one integer T (1 \leq T \leq 100,000,000). -T is the time your grandma wants to know the status at.
Output
Print the value vector at time -T separated one white space in one line as follows:
v_1 ... v_N
Each value must be separated with one white space. If there is no consistent value vectors, you should print `none` in one line. Or if there are multiple candidates and the solution is not unique (i.e. the solution is not unique), you should print `ambiguous` in one line.
Sample Input 1
2
1 1
0 1
1
1
1
Output for the Sample Input 1
0 1
Sample Input 2
2
0 1
0 0
1
0
1
Output for the Sample Input 2
ambiguous
Sample Input 3
2
0 1
0 0
1
0
2
Output for the Sample Input 3
none
Example
Input
2
1 1
0 1
1
1
1
Output
0 1
|
#include<bits/stdc++.h>
using namespace std;
typedef vector<int> vec;
typedef vector<vec> mat;
/*Gauss_Jordan(2?????°???????????§???)
O(n^3)
Ax=b????§£??? A?????£?????????
?§£???????????¨??????????????????????????????
?§£???????????§????????¨?????????n+1??????????????????
N???????????°??§M??????????¨???????????????´??????init?????????
mat A(N,vec(M,0));
vec B(N,0);
gauss_jordan(A,B)
*/
vec gauss_jordan(const mat& A,const vec& b){
int n=A.size();
mat B(n,vec(n+1));
vector<int> can(n,1);
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)B[i][j]=A[i][j]; //n*(n+1)?????????????????????
for(int i=0;i<n;i++)B[i][n]=b[i]; //n???????????£??\
for(int i=0;i<n;i++){
int pivot=i;//?¬????????????¨??????????????????
for(int j=0;j<n;j++)if(can[j] && B[j][i])pivot=j;//0??\??????1????????¢???
swap(B[i],B[pivot]);//i??????????????£????????????
if(B[i][i]==1)can[i] = 0;
for(int j=0;j<n;j++){ //
if(i!=j && B[j][i])//i??????-i?????????????????????
for(int k=i;k<=n;k++)B[j][k]=B[j][k] ^ B[i][k];//i????????????i????????\??????0????????????
}
}
vec x(n);
for(int i=0;i<n;i++)x[i]=B[i][n];
int many = 0;
for(int i=0;i<n;i++){
if(B[i][i] == 0) many = 1;
if(B[i][i] == 0 && B[i][n] == 1) return vec();
}
if(many) return vec(n+1);
return x;
}
mat Mult(const mat &A,const mat &B){
assert(A[0].size() == B.size());
int n = A.size(),m = B.size(),l = B[0].size();
mat C(A.size(),vec(B[0].size(),0));
for(int i=0;i<n;i++)
for(int j=0;j<l;j++)
for(int k=0;k<m;k++) C[i][j]^=(A[i][k]*B[k][j]);
return C;
}
mat pow(mat X,int y){
assert(X.size() == X[0].size());
mat res(X.size(),vec(X[0].size()));
for(int i=0;i<(int)res.size();i++) res[i][i] = 1;
while(y){
if(y%2) res = Mult(res,X);
y/=2;
X = Mult(X,X);
}
return res;
}
int main(){
int n;
cin>>n;
mat A(n,vec(n));
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)cin>>A[i][j];
vec B(n);
for(int i=0;i<n;i++) cin>> B[i];
int T;
cin>>T;
mat AT = pow(A,T);
vec ans = gauss_jordan(AT,B);
if(ans.empty()) cout<<"none"<<endl;
else if(ans.size()>n) cout<<"ambiguous"<<endl;
else {
for(int i=0;i<(int)ans.size();i++){
if(i)cout<<" ";
cout<<ans[i];
}
cout<<endl;
}
return 0;
}
|
E: Arai's --Arai's-
problem
Arai's is a female idol group that has been popular since the school idol era. Nowadays, it is active at the world level as a large group to which many "Arai" belong. And today, it was decided to start a new project. They decided to try to further increase sales by forming several small units.
"Arai" has A people and "Arai" has B people in Arai's, and it consists of A + B people "Arai" in total. The new unit will consist of a pair of "Arai" and one "Arai". (Here, the same "Arai" must not belong to multiple units.) However, one "Arai" does not think well about some "Arai", and there is also "Arai". "Arai" doesn't really think about some "Arai". When "Arai" and others form a unit, they do not accept "Arai" who they do not like as a pair, and on the other hand, they cannot form a unit unless they accept it.
As Arai's manager, you want to make as many units as you can, but the friendships of the members made you feel the limits. So you thought about meeting with "Arai" individually and telling good rumors about "Arai" who wants to form a unit. "Arai" who had an interview will review "Arai" who heard the rumor and will accept it as a pair of units.
But you can't take that much time, so you can only hear rumors up to K times. You have tried to maximize the number of units you can form in a limited amount of time. Find the maximum number of units you can form.
Input format
A B K
a_1_1
...
a_A
b_1_1
...
b_B
On the first line, the number of "Arai" A and the number B of "Arai" (1 \ ≤ A, B \ ≤ 200, where A and B are integers), and the number of people who can hear rumors K ( 0 \ ≤ K \ ≤ 200, where K is an integer) is given, separated by blanks.
The following line A is given a string consisting of only 0s and 1s of length B, respectively. When the j-th character of the character string a_i on the i-th line is 1, the i-th "Arai" does not think well about the j-th "Arai".
The following line B is given a string consisting of only 0s and 1s of length A, respectively. When the j-th character of the character string b_i on the i-th line is 1, the i-th "Arai" does not think well about the j-th "Arai".
Output format
Output the maximum number of units you can form on one line.
Input example 1
3 3 4
111
111
111
111
111
111
Output example 1
2
Input example 2
3 3 2
101
100
010
001
011
111
Output example 2
3
Input example 3
5 6 3
101101
110110
010111
110110
110111
01010
10101
11101
01011
11011
11011
Output example 3
Four
Example
Input
3 3 4
111
111
111
111
111
111
Output
2
|
#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
using ll = long long;
template<int V>
struct MinConstFlow {
using C = int;
using T = int;
const T INF = 1<<28;
using P = pair<T, int>;
struct Edge {
int to, rev;
C cap;
T cost;
};
vector<Edge> g[V];
T h[V], dist[V];
int pv[V], pe[V];
void add(int from, int to, C cap, T cost) {
g[from].push_back(Edge{to, (int)g[to].size(), cap, cost});
g[to].push_back(Edge{from, (int)g[from].size()-1, 0, -cost});
}
T exec(int s, int t, T mc) {
T res = 0;
fill_n(h, V, 0);
while (true) {
fill_n(dist, V, INF);
dist[s] = 0;
priority_queue<P, vector<P>, greater<P>> que;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top(); que.pop();
int v = p.second;
if (dist[v] < p.first) continue;
for (int i = 0; i < (int)g[v].size(); i++) {
Edge &e = g[v][i];
if (e.cap && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
pv[e.to] = v;
pe[e.to] = i;
que.push(P(dist[e.to], e.to));
}
}
}
if (dist[t] == INF) {
return res;
}
for (int v = 0; v < V; v++) {
h[v] += dist[v];
}
if (mc < h[t]) return res;
mc -= h[t];
res++;
for (int v = t; v != s; v = pv[v]) {
Edge &e = g[pv[v]][pe[v]];
e.cap--;
g[v][e.rev].cap++;
}
}
}
};
const int MN = 220;
MinConstFlow<2*MN> mcf;
int main() {
int a, b, k;
cin >> a >> b >> k;
int g[a][b];
for (int i = 0; i < a; i++) {
for (int j = 0; j < b; j++) {
g[i][j] = 2;
}
}
for (int i = 0; i < a; i++) {
string s;
cin >> s;
for (int j = 0; j < b; j++) {
if (s[j] == '0') {
g[i][j]--;
}
}
}
for (int i = 0; i < b; i++) {
string s;
cin >> s;
for (int j = 0; j < a; j++) {
if (s[j] == '0') {
g[j][i]--;
}
}
}
// from to cap cost
int sv = a+b, tv = a+b+1;
for (int i = 0; i < a; i++) {
mcf.add(sv, i, 1, 0);
}
for (int i = 0; i < b; i++) {
mcf.add(a+i, tv, 1, 0);
}
for (int i = 0; i < a; i++) {
for (int j = 0; j < b; j++) {
mcf.add(i, a+j, 1, g[i][j]);
}
}
cout << mcf.exec(sv, tv, k) << endl;
}
|
You received a card with an integer $S$ and a multiplication table of infinite size. All the elements in the table are integers, and an integer at the $i$-th row from the top and the $j$-th column from the left is $A_{i,j} = i \times j$ ($i,j \geq 1$). The table has infinite size, i.e., the number of the rows and the number of the columns are infinite.
You love rectangular regions of the table in which the sum of numbers is $S$. Your task is to count the number of integer tuples $(a, b, c, d)$ that satisfies $1 \leq a \leq b, 1 \leq c \leq d$ and $\sum_{i=a}^b \sum_{j=c}^d A_{i,j} = S$.
Input
The input consists of a single test case of the following form.
$S$
The first line consists of one integer $S$ ($1 \leq S \leq 10^5$), representing the summation of rectangular regions you have to find.
Output
Print the number of rectangular regions whose summation is $S$ in one line.
Examples
Input
25
Output
10
Input
1
Output
1
Input
5
Output
4
Input
83160
Output
5120
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
signed main(){
int S;
int ans = 0, con = 0;
map<int,int> mp;
cin>>S;
for(int i = 1; i <= S; i++){
for(int j = i, sum = i; sum <= S; j++){
mp[sum]++;
// cout<<"i "<<i<<" j "<<j<<" "<<sum<<endl;
sum += j+1;
con++;
}
}
// cout<<con<<endl;
for(int i = 1; i <= S; i++){
if(S%i) continue;
int a = mp[i], b = mp[S/i];
// if(i == S/i) b--;
if(a < 0 || b < 0) continue;
ans += a * b;
}
cout<<ans<<endl;
return 0;
}
|
Problem
At the boys' school where Bit-kun attends, a Kippo game is played during the lunch break.
This school's Kippo game is famous for being a little strange.
First, prepare a $ N $ book ticket. The length of the $ i $ first ticket is $ a_i $.
The first move and the second move eat Kippo alternately.
If you eat a great length of Kippo at once, it will stick in your throat, so eat as much as you like, from $ 1 $ to $ D $.
They are clumsy and can only eat Kippo with an integer length.
When one of the Kippo is eaten up for the first time, the person who eats it loses.
When both parties act optimally, output "First" if the first move wins, and "Second" if the second move wins.
Constraints
The input satisfies the following conditions.
* $ 1 \ le N \ le 3 \ times 10 ^ 5 $
* $ 1 \ le D \ le 10 ^ 9 $
* $ 1 \ le a_i \ le 10 ^ 9 $
Input
The input is given in the following format.
$ N $ $ D $
$ a_1 $ $ a_2 $ $ ... $ $ a_N $
All inputs are given as integers.
Output
When both act optimally, output which one wins.
Output "First" if the first move wins, and "Second" if the second move wins.
Examples
Input
1 1
2
Output
First
Input
2 25
19 19
Output
Second
Input
3 5
10 8 4
Output
First
Input
4 10
3 8 5 2
Output
Second
|
#include <bits/stdc++.h>
using namespace std;
void prians(bool answer) {
if(answer)
cout << "First" << endl;
else
cout << "Second" << endl;
}
long long n, d;
long long a[300005] = {0};
long long ans = 0;
int main() {
cin >> n >> d;
for(int i = 0; i < n; ++i) cin >> a[i];
for(int i = 0; i < n; ++i) ans ^= (a[i] - 1) % (d + 1);
prians(ans != 0);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.