input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
Traveling around the universe Benny saw some strange numbers. These numbers are called Universal numbers.
Benny asks you to help her to calculate the number of Universal numbers on some segments.
First of all, you are given 15 numbers called remsi.
The number is Universal if and only if it satisfies the following conditions:
There are at least two adjacent digits x and y such that x * 10 + y is prime.
For all prefixes of the number, all the numbers that are formed by some prefix must have the remainder of diving to the length of the prefix equal to remsnum_len.
In other words let all digs be all the digits of the number.
The digs1 must have remainder of dividing by 1 equal to rems1.
The digs1 * 10 + digs2 must have remainder of dividing by 2 equal to rems2.
The digs1 * 100 + digs2 * 10 + digs3 must have remainder of dividing by 3 equal to rems3.
And so on.
You have to answer N queries. Each query will contain two integers A and B denoting the range where you have to count the number of universal numbers.
Contraints
1 ≤ N ≤ 10^{5}
1 ≤ A ≤ B ≤ 10^{15} - 1
Input
The first line contains 15 integers denoting remsi.
The second line contains single integer N.
The following N lines contain two integers each denoting A and B.
Output
Print answer for each query in a single line.
SAMPLE INPUT
0 1 0 0 0 0 0 0 1 1 1 2 3 4 5
1
13 16
SAMPLE OUTPUT
1
Explanation
13 is only one universal number.
|
take=lambda: raw_input().strip()
calculate=lambda: list(map(int,raw_input().strip().split()))
numbers=[1,2,3,4,5,6,7,8,9,0]
num=[[1,2,3,4,5,6,7,8,9],[],[],[],[],[],[],[],[],[],[],[],[],[],[]]
primes=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
ans=[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]]
def Cal(x):
global rem,ans
for i in xrange(len(ans[x-2])):
for j in numbers:
if (ans[x-2][i]*10+j)%(x)==rem[x-1]:
ans[x-1].append(ans[x-2][i]*10+j)
for j in xrange(len(num[x-2])):
for i in numbers:
if (num[x-2][j]*10+i)%(x)==rem[x-1]:
if (num[x-2][j]%10)*10+i in primes:
ans[x-1].append(num[x-2][j]*10+i)
else:
num[x-1].append(num[x-2][j]*10+i)
def count(x,A=-1,B=10**10):
global ans
i,count=0,0
for i in ans[x-1]:
if A<=i<=B:
count+=1
return count
rem=calculate()
N=int(take())
if rem[0]==1:
for i in xrange(N):
x=take()
print 0
else:
for i in xrange(2,16):
Cal(i)
for i in xrange(N):
sums=0
A,B=take().split()
A,B=int(A),int(B)
f,t=len(list(str(A))),len(list(str(B)))
if f==t:
sums=count(f,A=A,B=B)
else:
sums=count(f,A=A)
for i in xrange(f+1,t):
sums+=len(ans[i-1])
sums+=count(t,A=-1,B=B)
print sums
|
Problem:
N boxes are arranged systematically in a circle and numbered from 1 to N in increasing order in clockwise direction. There will be Q queries asking you whether boxes i and j can be connected by a straight rod such that this rod does not intersect ( criss - cross as seen from top view ) with any of the other rods used to join other boxes in the previous queries. If the rod does not intersect with any of the other rods, the boxes i and j will be connected by the rod , or else the connection will not be made. Every box can be connected to at most one other box. No box can be connected to itself. Infinitley many rods of all possible sizes are available.
Input:
First line comprises of two space separated integers N and Q. Then there will be Q lines, each line will consist of two space separated integers i and j.
Output:
Print the answer to each query , 'YES' if the connection can be made and 'NO' if the connection cannot be made.
Constraints:
2 ≤ N ≤ 1000
1 ≤ Q ≤ 1000
1 ≤ i,j ≤ N
SAMPLE INPUT
10 7
1 5
2 7
2 3
2 4
9 9
10 9
8 6SAMPLE OUTPUT
YES
NO
YES
NO
NO
YES
YES
Explanation
1 and 5 can be connected by a rod.
2 and 7 cannot be connected by a rod because this rod intersects with the rod connecting 1 and 5.
2 and 3 can be connected.
2 and 4 cannot be connected as 2 is already connected to 3.
9 and 9 cannot be connected as no box can be connected to itself.
10 and 9 can be connected.
8 and 6 can be connected.
|
#Salman Lari
import sys
n,q=map(int,sys.stdin.readline().split())
u=[] #Used
up=[] #Used_ Pair
for k in range(q):
i,j=map(int,sys.stdin.readline().split())
if i in u or j in u:
print "NO"
continue
flag=1
for l in range(len(up)):
if i<up[l][1] and i>up[l][0]:
if j>up[l][1] or j<up[l][0]:
print "NO"
flag=0
break
if j<up[l][1] and j>up[l][0]:
if i>up[l][1] or i<up[l][0]:
print "NO"
flag=0
break
if flag==0:
continue
if i==j:
print "NO"
continue
u.append(i)
u.append(j)
up.append([min(i,j),max(i,j)])
print "YES"
|
Sam is dangerous boy. He like to fight with everyone who is more powerful than him. One day, Sam enters in the meeting of all gangsters of the city. He wants to fight with everyone who is more powerful than him.
But one man know his motive and tell to all gangsters about Sam. But gangsters don't know whether the Sam is present there or not and from how many gangsters Sam will fight.Help gangsters and tell them that Sam is present there or not. If Sam is present, then how many gangsters will fight with Sam.
INPUT:
The first line denotes the number of test cases T. For each line, a number N which denotes the total number of gangsters in the meeting including Sam and P which denotes the power of Sam. Next line, there are N space separated numbers denoting the power of each person.
OUTPUT:
You have to tell whether Sam is present in the meeting or not in terms of YES or NO. If Sam is there, then print the total number of gangsters who will fight with Sam.
Constraints:
1 ≤ T ≤ 100
1 ≤ N ≤ 10000
0 ≤ Power ≤ 1000000
SAMPLE INPUT
1
6 5
1 3 7 2 6 8
SAMPLE OUTPUT
NO 0
|
test=int(raw_input())
while test:
n,p=(raw_input().split())
count=0
n=int(n)
p=int(p)
power=[]
power = map(int, raw_input().split())
#print power
#print type(n)
#print power
for i in power:
if p<i:
# print i
count=count+1
if int(p) in power:
print "YES "+str(count)
else:
print "NO 0"
test=test-1
|
Little Arjit is in love with Deepa. They have always thought of themselves as the ideal couple - the best, possible match they could've managed. (No kidding!) And like every other couple, they promised each other not to fight after every other fight. But, when has that happened before?
But, this is a different couple - this is a programming couple - and they argue on weird things, like Fibonacci numbers, prime numbers, Sterling numbers, and what not!
Their recent fight might seem silly to a lot of people, but it is a matter of serious concern for both of them. They have bought a cake, and they weighed it in milligrams - the weight of the cake is always even and now they wish to divide the cake between them in some way, that both of them are satisfied.
Arjit challenges Deepa that if she can divide the weight of the cake as sum of two prime numbers between them, she can have the entire cake - and if she fails to do so, he'll get the cake.
The argument is getting more, and more heated now - please help them sort out their stupid arguments or an easier way would be to help them figure out who is going to have the cake.
Input Format:
The first line will contain a number, tc, denoting the number of test cases.
The next tc lines will contain an even number, denoting the weight of the cake in milligrams.
Output Format:
Print "Arjit" or "Deepa" according to the winner.
Constraints:
1 ≤ tc ≤ 100
1 ≤ n ≤ 100000
1 is NOT a prime number.
SAMPLE INPUT
2
4
8
SAMPLE OUTPUT
Deepa
Deepa
Explanation
4 can be represented as 2 + 2, so Deepa wins.
8 can be represented as 5 + 3, so Deepa wins.
|
##Goldbach's Conjecture
t=int(raw_input())
for i in range(t):
num=int(raw_input())
if num==2:
print 'Arjit'
else:
print 'Deepa'
|
Subodh'CS Department is writing a spell-checker system, and you have been tasked with writing a function to determine how closely two words resemble each other. The algorithm you are to use, albeit not a very good one, is to compare the two words character by character, and count how many times the characters in a given position are the same.
For instance, the words "TICK" and "TOCK" have a score of 3, since three characters (T, C, K) are the same.
Similarly, "CAT" and "DOG" score 0, since no letters match.
You are given Strings A and B and you have to return an integer K indicating the score (as defined above) of how closely the two match.
Input :
First line of input contains an integer T denoting the number of test cases.
Each test case contains two lines of input, where first line contains the string A and second line contains the string B.
Output :
For each test case print the score on a line.
Constraints :
A and B will each contain between 1 and 500 characters, inclusive.
Each character of a and b will be 'A'-'Z'.
1 ≤ T ≤ 50
SAMPLE INPUT
4
TICK
TOCK
CAT
DOG
APPLE
APPLES
FANTASTIC
ANTASTIC
SAMPLE OUTPUT
3
0
5
0
Explanation
Test Case #1:
The first example from the problem statement.
Test Case #2:
The first example from the problem statement.
Test Case #3:
Notice the lengths are different, so the most we can compare is 5 characters, which are all identical.
Test Case #4:
Here's an example of why this particular method is far from ideal. In a situation like this, it appears one character is missing the from the second string, but by our algorithm as described, they score a 0 in similarity.
|
import sys
from sys import stdin
def main():
T = int(stdin.readline().strip())
for i in xrange(T):
a = stdin.readline().strip()
b = stdin.readline().strip()
diff = abs(len(a) - len(b))
if len(a) > len(b):
a = a[:len(a) - diff]
elif len(b) >len(a):
b = b[:len(b)-diff]
count = 0
for j in xrange(len(a)):
if a[j]== b[j]:
count += 1
print count
if __name__ == '__main__':
main()
|
Mandark thinks he is better than Dexter. He challenges Dexter to find answer to a mathematics problem he created. Dexter accepts the challenge and decides to write a program for it to reduce manual calculations.
The problem: Let f(x) be the greatest odd divisor of x, where x is a positive integer. You are given a positive integer X. Calculate f(1)+f(2)+...+f(X).
INPUT
First line of input gives T, the number of test cases.
T lines follow, each having X as input positive integer.
OUTPUT
Print value of f(1)+f(2)+...+f(X) for each test case.
CONSTRAINTS
1 ≤ T ≤ 50
X will be between 1 and 1000000000, inclusive.
SAMPLE INPUT
2
7
777
SAMPLE OUTPUT
21
201537
Explanation
For first case, f(1)+f(2)+f(3)+f(4)+f(5)+f(6)+f(7)=1+1+3+1+5+3+7=21
Similarly, f(1)+f(2)+...+f(777) = 201537
|
T = int(raw_input())
while T > 0:
num = int(raw_input())
sum = 0
while num!=0:
if num%2==1:
a=(num+1)/2
else:
a=num/2
sum+=a*a
num=num-a
print sum
T-=1
|
Rajat is a guy who always wants to live in a fantasy world. In his world,
a deck consists of X cards, where X is a multiple of 4.
There are four types of cards namely spade , heart , club and diamond with
each type having values in range of [1,X/4] inclusive.
His cousin wants to test him. So,to test Rajat , his
cousin gives him a value of a card D and its card type K.
He asks him to find the probability that the above card is drawn
at the N^th draw if cards are drawn one by one from the deck without
replacement.
Input:
First line contains T the number of testcases.
Next T lines consists of X , N , D , K.
Output:
Output the probability upto 10 digits after decimal place for each testcase.
Constraints:
1 ≤ T ≤100
4 ≤ X ≤ 10^9
1 ≤ N ≤ X
K is a string denoting card's type = {heart , spade , diamond , club}
1 ≤ D ≤ X/4
SAMPLE INPUT
2
8 8 2 heart
52 1 10 spade
SAMPLE OUTPUT
0.1250000000
0.0192307692
|
T = input()
while(T>0):
xx,n,d,k = (raw_input().split())
x = int(xx)
print '%.10f' % (1.0/x)
T = T-1
|
Things are heated up between the Finance team and the Marketing team, and they decide to have one-on-one fifa matches to settle it once and for all.
Jha, being an intern, won’t play (it’s a battle of legends, after all) and has been given one job: to fix matches in the "hope" that he’ll match players of similar skill levels (so that matches aren’t one way and everybody enjoys).
He, being on Finance team, wants his team to win (disregarding ethics). Each game carries 100 points which is awarded to the winner or divided (50-50) between the players if it ends in a draw (according to skill levels of the players).
Jha has pulled off an all-nighter to come up with the best assignment possible. But he’s way too tired now. Help him verify his answer by calculating the maximum possible score of Finance team so that he can either sleep peacefully or come up with a new assignment if he missed the optimal one.
Input Format:
no_of_players_in_each_team
skill_levels_of_finance_team_players (space separated)
skill_levels_of_marketing_team_players (space separated)
Output Format:
Maximum possible score of Finance team
Constraints:
1 ≤ Number of players ≤ 20
1 ≤ Skill levels ≤ 1000
SAMPLE INPUT
3
8 5 3
8 5 3
SAMPLE OUTPUT
200
Explanation
If similar skills' players were matched, then all three matches would result in a draw (150 points). However, you can assign matches as 8-5, 5-3 and 3-8, resulting in 2 wins and 1 loss (200 points)!
|
n=input()
f=raw_input()
m=raw_input()
f=f.split()
m=m.split()
for x in range(0,n):
f[x]=int(f[x])
m[x]=int(m[x])
f=sorted(f, reverse=True)
m=sorted(m, reverse=True)
point=0
i=0
#print f
#print m
##winnings
while(i<len(f)):
j=0
temp=f[i]
while(j<len(m)):
if(temp>m[j]):
point=point+100
del(f[i])
del(m[j])
i = -1
break
elif(temp==m[j]):
point=point+50
del(f[i])
del(m[j])
i = -1
break
j=j+1
i=i+1
print point
|
Silly Snail was a very intelligent snail on Snail Island. In order to get eligible for marriage, he had to pass the Graduation Exam conducted by C.B.S.E ( Central Board of Snail Education ).
Seeing the intelligence level of the Silly Snail, the head of C.B.S.E decided to conduct the exam himself. Silly Snail performed very well in all the levels of the exam but got stuck on the last one.
At the final level of the exam, the Head of C.B.S.E sent him to one of the the Silly trees and Silly Snail's task was to report all the fruits on the tree in a specific way. Silly tree was a very special tree which had fruits of various colors.
Even the smallest Silly trees have a fruit with color 1. As the tree grows larger, two more fruits with unique colors get attached to some existing fruit of the tree as Fruit left and Fruit right. Silly Snail has to travel the Silly Tree in a very specific way and report the answer at the end.
A fruit with color 1 is assumed to be present on every Silly Tree. Silly Sail starts with color 1 and notes it down. On reaching any fruit, he notes down its color and then moves to the left part of the tree. on completing the entire left sub-tree, he moves to the right subtree and does the same.
Refer the sample test cases for more clarity.
While he was going to submit the answer sheet, the sheet was blown away by wind. You need to help the Silly Snail generate all the answers without traveling the entire tree again.
INPUT :
the first line of the input contains the number of test cases. The first line of each test case consists of a single integer n ( the number of relations describing the tree ).
n lines follow describing the n relations. Each relation has 3 space separated integers X, Y and Z. X is some existing fruit on the tree. Y and Z are the colors of the left fruit and right fruit of X respectively. If Y or Z = 0, it implies that X has no left fruit or right fruit respectively.
OUTPUT :
You need to display all the fruit colors on the Silly Tree in the described manner.
CONSTRAINTS :
1 ≤ t ≤ 50
0 ≤ n ≤ 100000
2 ≤ Y,Z ≤ 100000
1 ≤ X ≤ 100000
SAMPLE INPUT
2
7
1 7 3
7 9 14
3 10 5
9 6 12
14 8 4
10 2 0
5 11 0
4
1 11 13
11 14 7
14 5 9
7 6 4
SAMPLE OUTPUT
1 7 9 6 12 14 8 4 3 10 2 5 11
1 11 14 5 9 7 6 4 13
Explanation
For test case 2:
Silly Snail goes on to color 1, notes it down. Then he goes on to the left fruit of 1 that is 11, notes it down. then he visits the left fruit of 11, 14 and notes it down and then to 5. when no left subtree is left in this part, he goes to the right towards color 9 and then to 7,6,4, and finally to 13
|
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def traverse(root):
print root.data,
if root.left:
traverse(root.left)
if root.right:
traverse(root.right)
T = int(raw_input())
for t in range(T):
num_nodes = int(raw_input())
node_map = {}
root = Node(1)
node_map[1] = root
for n in range(num_nodes):
node_data, left_node_data, right_node_data = map(int, raw_input().split(" "))
node = node_map[node_data]
if left_node_data:
node.left = Node(left_node_data)
node_map[left_node_data] = node.left
if right_node_data:
node.right = Node(right_node_data)
node_map[right_node_data] = node.right
traverse(root)
print
|
Given are a permutation p_1, p_2, \dots, p_N of (1, 2, ..., N) and an integer K. Maroon performs the following operation for i = 1, 2, \dots, N - K + 1 in this order:
* Shuffle p_i, p_{i + 1}, \dots, p_{i + K - 1} uniformly randomly.
Find the expected value of the inversion number of the sequence after all the operations are performed, and print it modulo 998244353.
More specifically, from the constraints of this problem, it can be proved that the expected value is always a rational number, which can be represented as an irreducible fraction \frac{P}{Q}, and that the integer R that satisfies R \times Q \equiv P \pmod{998244353}, 0 \leq R < 998244353 is uniquely determined. Print this R.
Here, the inversion number of a sequence a_1, a_2, \dots, a_N is defined to be the number of ordered pairs (i, j) that satisfy i < j, a_i > a_j.
Constraints
* 2 \leq N \leq 200,000
* 2 \leq K \leq N
* (p_1, p_2, \dots, p_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
p_1 p_2 ... p_N
Output
Print the expected value modulo 998244353.
Examples
Input
3 2
1 2 3
Output
1
Input
10 3
1 8 4 9 2 3 7 10 5 6
Output
164091855
|
import sys
readline = sys.stdin.buffer.readline
mod=998244353
class BIT:
def __init__(self,n):
self.n=n
self.buf=[0]*n
def add(self,i,v):
buf=self.buf
while i<n:
buf[i]+=v
if buf[i]>=mod:
buf[i]-=mod
i+=(i+1)&(-i-1)
def get(self,i):
buf=self.buf
res=0
while i>=0:
res+=buf[i]
if res>=mod:
res-=mod
i-=(i+1)&(-i-1)
return res
def rng(self,b,e):
res=self.get(e-1)-self.get(b)
if res<0:
res+=mod
return res
n,k=map(int,readline().split())
p=list(map(int,readline().split()))
for i in range(n):
p[i]-=1
ans=0
bit=BIT(n)
for i in range(n):
ans+=i-bit.get(p[i])
bit.add(p[i],1)
z=pow(2,mod-2,mod);
w=1
winv=1
rem=(k-1)*pow(k,mod-2,mod)%mod
reminv=pow(rem,mod-2,mod)
bit=BIT(n)
for i in range(n):
lw=bit.get(p[i])
up=bit.rng(p[i],n)
dif=(lw-up+mod)%mod
ans=(ans+dif*w*z)%mod
bit.add(p[i],winv)
if i>=k-1:
w=w*rem%mod
winv=winv*reminv%mod
print(ans)
|
The cat Snuke wants to play a popular Japanese game called ÅtCoder, so Iroha has decided to teach him Japanese.
When counting pencils in Japanese, the counter word "本" follows the number. The pronunciation of this word varies depending on the number. Specifically, the pronunciation of "本" in the phrase "N 本" for a positive integer N not exceeding 999 is as follows:
* `hon` when the digit in the one's place of N is 2, 4, 5, 7, or 9;
* `pon` when the digit in the one's place of N is 0, 1, 6 or 8;
* `bon` when the digit in the one's place of N is 3.
Given N, print the pronunciation of "本" in the phrase "N 本".
Constraints
* N is a positive integer not exceeding 999.
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
16
Output
pon
Input
2
Output
hon
Input
183
Output
bon
|
n = input()
print('bon' if n[-1]=='3' else 'pon' if n[-1] in ['0','1','6','8'] else 'hon')
|
Takahashi has a maze, which is a grid of H \times W squares with H horizontal rows and W vertical columns.
The square at the i-th row from the top and the j-th column is a "wall" square if S_{ij} is `#`, and a "road" square if S_{ij} is `.`.
From a road square, you can move to a horizontally or vertically adjacent road square.
You cannot move out of the maze, move to a wall square, or move diagonally.
Takahashi will choose a starting square and a goal square, which can be any road squares, and give the maze to Aoki.
Aoki will then travel from the starting square to the goal square, in the minimum number of moves required.
In this situation, find the maximum possible number of moves Aoki has to make.
Constraints
* 1 \leq H,W \leq 20
* S_{ij} is `.` or `#`.
* S contains at least two occurrences of `.`.
* Any road square can be reached from any road square in zero or more moves.
Input
Input is given from Standard Input in the following format:
H W
S_{11}...S_{1W}
:
S_{H1}...S_{HW}
Output
Print the maximum possible number of moves Aoki has to make.
Examples
Input
3 3
...
...
...
Output
4
Input
3 5
...#.
.#.#.
.#...
Output
10
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int h,w;
cin>>h>>w;
vector<string> g(h);
for(string &s: g) cin>>s;
vector<int> dx={-1,0,0,1};
vector<int> dy={0,1,-1,0};
int ans=0;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
if(g[i][j]=='#') continue;
int cnt=0;
vector<vector<int>> d(h,vector<int>(w,-1));
queue<pair<int,int>> q;
d[i][j]=0;
pair<int,int> p(i,j);
q.push(p);
while(!q.empty()){
pair<int,int> v=q.front();q.pop();
int y=v.first,x=v.second;
for(int k=0;k<4;k++){
int Y=y+dy[k],X=x+dx[k];
if(0<=Y&&Y<h&&0<=X&&X<w&&g[Y][X]=='.'){
if(d[Y][X]!=-1) continue;
d[Y][X]=d[y][x]+1;
cnt=max(cnt,d[Y][X]);
pair<int,int> V(Y,X);
q.push(V);
}
}
}
ans=max(ans,cnt);
}
}
cout<<ans<<endl;
}
|
Given is a string S consisting of lowercase English letters. Find the maximum positive integer K that satisfies the following condition:
* There exists a partition of S into K non-empty strings S=S_1S_2...S_K such that S_i \neq S_{i+1} (1 \leq i \leq K-1).
Here S_1S_2...S_K represents the concatenation of S_1,S_2,...,S_K in this order.
Constraints
* 1 \leq |S| \leq 2 \times 10^5
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
Output
Print the maximum positive integer K that satisfies the condition.
Examples
Input
aabbaa
Output
4
Input
aaaccacabaababc
Output
12
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
public class Main {
static String s = "";
public static void main(String[] args) {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
try {
s = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
HashMap<Integer, String> map = new HashMap<>();
System.out.println(search(map,"", 0, 1));
}
static int search(HashMap<Integer, String> map, String prev, int begin, int len) {
if(begin+len > s.length())return map.size();
String sub = s.substring(begin, begin+len);
if(sub.equals(prev)) {
return search(map,prev, begin, len+1);
}else {
map.put(begin, sub);
return search(map, sub,begin+len, 1);
}
}
}
|
The restaurant AtCoder serves the following five dishes:
* ABC Don (rice bowl): takes A minutes to serve.
* ARC Curry: takes B minutes to serve.
* AGC Pasta: takes C minutes to serve.
* APC Ramen: takes D minutes to serve.
* ATC Hanbagu (hamburger patty): takes E minutes to serve.
Here, the time to serve a dish is the time between when an order is placed and when the dish is delivered.
This restaurant has the following rules on orders:
* An order can only be placed at a time that is a multiple of 10 (time 0, 10, 20, ...).
* Only one dish can be ordered at a time.
* No new order can be placed when an order is already placed and the dish is still not delivered, but a new order can be placed at the exact time when the dish is delivered.
E869120 arrives at this restaurant at time 0. He will order all five dishes. Find the earliest possible time for the last dish to be delivered.
Here, he can order the dishes in any order he likes, and he can place an order already at time 0.
Constraints
* A, B, C, D and E are integers between 1 and 123 (inclusive).
Input
Input is given from Standard Input in the following format:
A
B
C
D
E
Output
Print the earliest possible time for the last dish to be delivered, as an integer.
Examples
Input
29
20
7
35
120
Output
215
Input
101
86
119
108
57
Output
481
Input
123
123
123
123
123
Output
643
|
A = [-int(input()) for _ in range(5)]
m = max(A, key = lambda x: x%10)
print(-(m-m//10*10+sum([a//10*10 for a in A])))
|
Niwango-kun has \\(N\\) chickens as his pets. The chickens are identified by numbers \\(1\\) to \\(N\\), and the size of the \\(i\\)-th chicken is a positive integer \\(a_i\\).
\\(N\\) chickens decided to take each other's hand (wing) and form some cycles. The way to make cycles is represented by a permutation \\(p\\) of \\(1, \ldots , N\\). Chicken \\(i\\) takes chicken \\(p_i\\)'s left hand by its right hand. Chickens may take their own hand.
Let us define the cycle containing chicken \\(i\\) as the set consisting of chickens \\(p_i, p_{p_i}, \ldots, p_{\ddots_i} = i\\). It can be proven that after each chicken takes some chicken's hand, the \\(N\\) chickens can be decomposed into cycles.
The beauty \\(f(p)\\) of a way of forming cycles is defined as the product of the size of the smallest chicken in each cycle. Let \\(b_i \ (1 \leq i \leq N)\\) be the sum of \\(f(p)\\) among all possible permutations \\(p\\) for which \\(i\\) cycles are formed in the procedure above.
Find the greatest common divisor of \\(b_1, b_2, \ldots, b_N\\) and print it \\({\rm mod} \ 998244353\\).
Constraints
* \\(1 \leq N \leq 10^5\\)
* \\(1 \leq a_i \leq 10^9\\)
* All numbers given in input are integers
Input
Input is given from Standard Input in the following format:
\(N\)
\(a_1\) \(a_2\) \(\ldots\) \(a_N\)
Output
Print the answer.
Examples
Input
2
4 3
Output
3
Input
4
2 5 2 5
Output
2
|
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <string>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <stdio.h>
using namespace std;
#define int long long
int MOD = 998244353;
int gcd(int a, int b)
{
int c;
while (a != 0) {
c = a; a = b%a; b = c;
}
return b;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<int> A(N);
int res = 0;
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A.begin(), A.end());
res = A[0];
for (int i = 1; i < N; i++) {
res = (res * gcd(A[i], i)) % MOD;
}
cout << res << endl;
}
|
Snuke has an integer sequence A whose length is N. He likes permutations of (1, 2, ..., N), P, that satisfy the following condition:
* P_i \leq A_i for all i ( 1 \leq i \leq N ).
Snuke is interested in the inversion numbers of such permutations. Find the sum of the inversion numbers over all permutations that satisfy the condition. Since this can be extremely large, compute the sum modulo 10^9+7.
Constraints
* 1 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq N ( 1 \leq i \leq N )
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the sum of the inversion numbers over all permutations that satisfy the condition.
Examples
Input
3
2 3 3
Output
4
Input
6
4 2 5 1 6 3
Output
7
Input
5
4 4 4 4 4
Output
0
Input
30
22 30 15 20 10 29 11 29 28 11 26 10 18 28 22 5 29 16 24 24 27 10 21 30 29 19 28 27 18 23
Output
848414012
|
#include<bits/stdc++.h>
#define ld double
#define ull unsigned long long
#define ll long long
#define pii pair<int,int >
#define iiii pair<int,pii >
#define mp make_pair
#define INF 1000000000
#define MOD 1000000007
#define rep(i,x) for(int (i)=0;(i)<(x);(i)++)
inline int getint(){
int x=0,p=1;char c=getchar();
while (c<=32)c=getchar();
if(c==45)p=-p,c=getchar();
while (c>32)x=x*10+c-48,c=getchar();
return x*p;
}
using namespace std;
//ruogu_alter
const int N=2e5+5;
const int inv2=(MOD+1)/2;
int n,a[N],b[N],cnt[N],ib[N],pre[N],dx[N],dy[N];
//
inline void add(int &x,int y){
x+=y;if(x>=MOD)x-=MOD;
}
inline void sub(int &x,int y){
x-=y;if(x<0)x+=MOD;
}
inline int sub2(int x,int y){
x-=y;
return (x<0)?x+MOD:x;
}
inline int mul(int x,int y){
ll ans=1ll*x*y;
return ans%MOD;
}
inline int modpow(int x,int y){
int ans=1;
while(y){
if(y&1)ans=mul(ans,x);
x=mul(x,x);
y>>=1;
}
return ans;
}
inline int modinv(int x){
return modpow(x,MOD-2);
}
inline void upd(int x,int y){
while(x<N){
add(dy[x],y);
dx[x]++;
x+=x&-x;
}
}
inline int qry(int *d,int x){
int ans=0;
while(x){
add(ans,d[x]);
x-=x&-x;
}
return ans;
}
int main(){
//freopen(".in","r",stdin);
//freopen(".out","w",stdout);
n=getint();
for(int i=1;i<=n;i++){
a[i]=getint();
cnt[a[i]]++;
}
for(int i=n-1;i>=1;i--)cnt[i]+=cnt[i+1];
for(int i=1;i<=n;i++)cnt[i]-=n-i;
for(int i=1;i<=n;i++)if(cnt[i]<=0){
return !printf("%d\n",0);
}
int s=1;pre[0]=b[0]=1;
for(int i=1;i<=n;i++)s=mul(s,cnt[i]);
for(int i=1;i<=n;i++){
b[i]=mul(cnt[i]-1,modinv(cnt[i]));
if(!b[i])pre[i]=i,b[i]=b[i-1];
else pre[i]=pre[i-1],b[i]=mul(b[i-1],b[i]);
ib[i]=modinv(b[i]);
}
int res=0;
for(int i=1;i<=n;i++){
add(res,mul(b[a[i]],mul(s,mul(inv2,sub2(qry(dy,a[i]),qry(dy,pre[a[i]]-1))))));
// cout<<res<<endl;
upd(a[i],ib[a[i]]);
}
// cout<<res<<endl;
memset(dx,0,sizeof(dx));
memset(dy,0,sizeof(dy));
for(int i=n;i>=1;i--){
sub(res,mul(b[a[i]],mul(s,mul(inv2,sub2(qry(dy,a[i]-1),qry(dy,pre[a[i]]-1))))));
add(res,mul(s,qry(dx,a[i]-1)));
upd(a[i],ib[a[i]]);
}
cout<<res<<endl;
return 0;
}
|
Consider the following game:
* The game is played using a row of N squares and many stones.
* First, a_i stones are put in Square i\ (1 \leq i \leq N).
* A player can perform the following operation as many time as desired: "Select an integer i such that Square i contains exactly i stones. Remove all the stones from Square i, and add one stone to each of the i-1 squares from Square 1 to Square i-1."
* The final score of the player is the total number of the stones remaining in the squares.
For a sequence a of length N, let f(a) be the minimum score that can be obtained when the game is played on a.
Find the sum of f(a) over all sequences a of length N where each element is between 0 and K (inclusive). Since it can be extremely large, find the answer modulo 1000000007 (= 10^9+7).
Constraints
* 1 \leq N \leq 100
* 1 \leq K \leq N
Input
Input is given from Standard Input in the following format:
N K
Output
Print the sum of f(a) modulo 1000000007 (= 10^9+7).
Examples
Input
2 2
Output
10
Input
20 17
Output
983853488
|
#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<deque>
#include<string>
#include<string.h>
#include<vector>
#include<set>
#include<map>
#include<bitset>
#include<stdlib.h>
#include<cassert>
using namespace std;
const long long mod=1000000007;
const long long inf=mod*mod;
const long long d2=500000004;
const double EPS=1e-6;
const double PI=acos(-1.0);
int ABS(int a){return max(a,-a);}
long long ABS(long long a){return max(a,-a);}
long long dp[110][11000];
long long inv[110000];
int K;
long long calc(int a,int b){
if(dp[a][b]>=0)return dp[a][b];
if(a==0)return dp[a][b]=0;
long long ret=0;
for(int i=0;i<=K;i++){
int f=(b+i)/a;
int h=(b+i)%a;
if(i>a){
f=0;h=b+i;
}
ret=(ret+inv[K+1]*(calc(a-1,b+f)+h))%mod;
}
return dp[a][b]=ret;
}
int main(){
inv[1]=1;
for(int i=2;i<110000;i++)inv[i]=(mod-(mod/i)*inv[mod%i]%mod)%mod;
int a,b;scanf("%d%d",&a,&b);
K=b;
for(int i=0;i<110;i++)for(int j=0;j<11000;j++)dp[i][j]=-1;
long long ret=calc(a,0);
for(int i=0;i<a;i++)ret=ret*(b+1)%mod;
printf("%lld\n",ret);
}
|
There is a sequence of length N: a = (a_1, a_2, ..., a_N). Here, each a_i is a non-negative integer.
Snuke can repeatedly perform the following operation:
* Let the XOR of all the elements in a be x. Select an integer i (1 ≤ i ≤ N) and replace a_i with x.
Snuke's objective is to match a with another sequence b = (b_1, b_2, ..., b_N). Here, each b_i is a non-negative integer.
Determine whether the objective is achievable, and find the minimum necessary number of operations if the answer is positive.
Constraints
* 2 ≤ N ≤ 10^5
* a_i and b_i are integers.
* 0 ≤ a_i, b_i < 2^{30}
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
b_1 b_2 ... b_N
Output
If the objective is achievable, print the minimum necessary number of operations. Otherwise, print `-1` instead.
Examples
Input
3
0 1 2
3 1 0
Output
2
Input
3
0 1 2
0 1 2
Output
0
Input
2
1 1
0 0
Output
-1
Input
4
0 1 2 3
1 0 3 2
Output
5
|
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<ctime>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<bitset>
using namespace std;
typedef long long LL;
int gi() {
int w=0;bool q=1;char c=getchar();
while ((c<'0'||c>'9') && c!='-') c=getchar();
if (c=='-') q=0,c=getchar();
while (c>='0'&&c <= '9') w=w*10+c-'0',c=getchar();
return q? w:-w;
}
const int N=2e5+100;
int a[N],b[N],c[N];
int fa[N];inline int find(int x) { return fa[x]==x?x:fa[x]=find(fa[x]); }
int main()
{
int n=gi(),i,m=0;map<int,int>tot;
for (i=1;i<=n;i++) a[0]^=a[i]=gi();
for (i=1;i<=n;i++) b[0]^=b[i]=gi();
for (i=0;i<=n;i++) if (a[i]^b[i]) tot[c[m++]=a[i]]++,tot[c[m++]=b[i]]--;
for (auto p:tot) if (p.second) return puts("-1"),0;
sort(c,c+m);
m=unique(c,c+m)-c;
for (i=0;i<m;i++) fa[i]=i;
int ans=m;
for (i=1;i<=n;i++)
if (a[i]^b[i]) {
a[i]=lower_bound(c,c+m,a[i])-c;
b[i]=lower_bound(c,c+m,b[i])-c;
if (find(a[i])==find(b[i])) ans++;
else fa[find(a[i])]=find(b[i]);
}
for (i=0;i<m;i++) if (c[i]==a[0]) ans--;
printf("%d\n",ans);
return 0;
}
|
There is a tree with N vertices. The vertices are numbered 1 through N. For each 1 ≤ i ≤ N - 1, the i-th edge connects vertices a_i and b_i. The lengths of all the edges are 1.
Snuke likes some of the vertices. The information on his favorite vertices are given to you as a string s of length N. For each 1 ≤ i ≤ N, s_i is `1` if Snuke likes vertex i, and `0` if he does not like vertex i.
Initially, all the vertices are white. Snuke will perform the following operation exactly once:
* Select a vertex v that he likes, and a non-negative integer d. Then, paint all the vertices black whose distances from v are at most d.
Find the number of the possible combinations of colors of the vertices after the operation.
Constraints
* 2 ≤ N ≤ 2×10^5
* 1 ≤ a_i, b_i ≤ N
* The given graph is a tree.
* |s| = N
* s consists of `0` and `1`.
* s contains at least one occurrence of `1`.
Input
The input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_{N - 1} b_{N - 1}
s
Output
Print the number of the possible combinations of colors of the vertices after the operation.
Examples
Input
4
1 2
1 3
1 4
1100
Output
4
Input
5
1 2
1 3
1 4
4 5
11111
Output
11
Input
6
1 2
1 3
1 4
2 5
2 6
100011
Output
8
|
#include<bits/stdc++.h>
using namespace std;
const int N=200005;
int x,y,n,Max[N],Max2[N],l[N],z[N];
vector<int>G[N];
char s[N];
long long ans;
inline void upd(int x,int y){
if (y>Max[x])Max2[x]=Max[x],Max[x]=y;
else if (y>Max2[x])Max2[x]=y;
}
inline void dfs1(int x,int y){
l[x]=N;
if (s[x]=='1')l[x]=0,z[x]=1;
for (int i:G[x])
if (i!=y){
dfs1(i,x);
int d=Max[i]+1;
upd(x,d);
if (z[i]){
l[x]=min(l[x],d);
z[x]+=z[i];
}
}
}
inline void dfs2(int x,int y){
if (y){
int d=Max[x]+1==Max[y]?Max2[y]+1:Max[y]+1;
upd(x,d);
if (z[1]>z[x])l[x]=min(l[x],d);
}
for (int i:G[x])
if (i!=y)dfs2(i,x);
int L=l[x],R=min(Max2[x]+1,Max[x]-1);
if (L<=R)ans+=R-L+1;
}
int main(){
scanf("%d",&n);
for (int i=1;i<n;i++){
scanf("%d%d",&x,&y);
G[x].push_back(y);
G[y].push_back(x);
}
scanf("%s",s+1);
dfs1(1,0);
dfs2(1,0);
printf("%lld\n",ans+1);
return 0;
}
|
You are given an undirected graph with N vertices and M edges. Here, N-1≤M≤N holds and the graph is connected. There are no self-loops or multiple edges in this graph.
The vertices are numbered 1 through N, and the edges are numbered 1 through M. Edge i connects vertices a_i and b_i.
The color of each vertex can be either white or black. Initially, all the vertices are white. Snuke is trying to turn all the vertices black by performing the following operation some number of times:
* Select a pair of adjacent vertices with the same color, and invert the colors of those vertices. That is, if the vertices are both white, then turn them black, and vice versa.
Determine if it is possible to turn all the vertices black. If the answer is positive, find the minimum number of times the operation needs to be performed in order to achieve the objective.
Constraints
* 2≤N≤10^5
* N-1≤M≤N
* 1≤a_i,b_i≤N
* There are no self-loops or multiple edges in the given graph.
* The given graph is connected.
Input
The input is given from Standard Input in the following format:
N M
a_1 b_1
a_2 b_2
:
a_M b_M
Output
If it is possible to turn all the vertices black, print the minimum number of times the operation needs to be performed in order to achieve the objective. Otherwise, print `-1` instead.
Examples
Input
6 5
1 2
1 3
1 4
2 5
2 6
Output
5
Input
3 2
1 2
2 3
Output
-1
Input
4 4
1 2
2 3
3 4
4 1
Output
2
Input
6 6
1 2
2 3
3 1
1 4
1 5
1 6
Output
7
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=200010;
int size[N],Flag,cnt2[N],pp[N],cc,sd[N];
int cnt[N],col[N],n,m,ne[N],tot,fi[N],zz[N],flag[N],x,y,X,Y;
void jb(int x,int y){
ne[++tot]=fi[x];
fi[x]=tot;
zz[tot]=y;
}
void dfs2(int x){
cnt2[x]=col[x];flag[x]=1;
for (int i=fi[x];i;i=ne[i])
if (!flag[zz[i]]&&!pp[i]){
dfs2(zz[i]);
cnt2[x]+=cnt2[zz[i]];
}
}
int solve(){
memset(flag,0,sizeof flag);
dfs2(1);
int ans=0;
for (int i=1;i<=n;i++)ans+=abs(size[i]-cnt2[i]-cnt[i]);
return ans;
}
int check(int x){
col[X]-=x;col[Y]+=x;
int k=solve();
col[X]+=x;col[Y]-=x;
return k+abs(x);
}
void dfs(int x,int y){
size[x]=flag[x]=1;cnt[x]=col[x];
for (int i=fi[x];i;i=ne[i])
if (i!=y){
if (flag[zz[i]]&&sd[zz[i]]<sd[x]){
X=x;cc++;
Y=zz[i];
Flag=(sd[x]-sd[zz[i]])&1;
pp[i]=pp[i^1]=1;
continue;
}
if (flag[zz[i]])continue;
sd[zz[i]]=sd[x]+1;
col[zz[i]]=col[x]^1;
dfs(zz[i],i^1);
cnt[x]+=cnt[zz[i]];
size[x]+=size[zz[i]];
}
}
signed main(){
scanf("%lld%lld",&n,&m);
tot=1;
for (int i=1;i<=m;i++){
scanf("%lld%lld",&x,&y);
jb(x,y);jb(y,x);
}
col[1]=1;
dfs(1,0);
int S=cnt[1],T=n-cnt[1];
if (m==n-1){
if (S!=T){
puts("-1");
return 0;
}
printf("%lld\n",solve());
}
else if (Flag){
if (S!=T){
puts("-1");
return 0;
}
int l=-n,r=n;
while (l+5<r){
int mid1=l+(r-l)/3,mid2=r-(r-l)/3;
if (check(mid1)>check(mid2))l=mid1;
else r=mid2;
}
int ans=1e18;
for (int i=l;i<=r;i++)ans=min(ans,check(i));
printf("%lld\n",ans);
}
else {
if ((S&1)!=(T&1)){
puts("-1");
return 0;
}
col[X]+=(T-S)/2;
col[Y]+=(T-S)/2;
printf("%lld\n",solve()+abs(T-S)/2);
}
return 0;
}
|
Enter a positive integer n of 4,000 or less, with a pair of integers a, b, c, d in the range 0-1000.
a + b + c + d = n
Create a program that outputs the number of combinations that satisfy the conditions.
Input
Given multiple datasets. Each dataset is given n on one row. Please process until the end of the input.
The number of datasets does not exceed 50.
Output
For each data set, output the number of combinations of a, b, c, and d on one line.
Example
Input
2
3
35
Output
10
20
8436
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
private static BufferedReader br = null;
static {
br = new BufferedReader(new InputStreamReader(System.in));
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int map[] = new int[2001];
int num = -1;
for(int a = 0; a <= 1000; a++) {
for(int b = 0; b <= 1000; b++) {
// 0から2000までの組み合わせをカウント
map[a+b]++;
}
}
while((num = parseNum()) != -1) {
long cnt = 0;
for(int a = 0; a <= 2000; a++) {
if (a > num) {
// 数値Aが目的値を超えたらこれ以上カウントしない
break;
}
for(int b = 0; b <= 2000; b++) {
if (a + b == num) {
cnt += (long)map[a]*(long)map[b];
} else if (a + b > num || num - a > 2000) {
// 合計が目的値を超えたらこれ以上カウントしない
// 数値Aに2000を足しても目的値に届かない場合はこれ以上カウントしない
break;
}
}
}
System.out.println(cnt);
}
}
private static int parseNum() {
int param = -1;
String strin = null;
if ((strin = parseStdin()) != null) {
param = Integer.parseInt(strin);
}
return param;
}
private static String parseStdin() {
String stdin = null;
try {
String tmp = br.readLine();
if (tmp != null) {
if (!tmp.isEmpty()) {
stdin = tmp;
}
}
}
catch (IOException e) {}
return stdin;
}
}
|
The screen that displays digital numbers that you often see on calculators is called a "7-segment display" because the digital numbers consist of seven parts (segments).
The new product to be launched by Wakamatsu will incorporate a 7-segment display into the product, and as an employee, you will create a program to display the given number on the 7-segment display.
This 7-segment display will not change until the next switch instruction is sent. By sending a signal consisting of 7 bits, the display information of each corresponding segment can be switched. Bits have a value of 1 or 0, where 1 stands for "switch" and 0 stands for "as is".
The correspondence between each bit and segment is shown in the figure below. The signal sends 7 bits in the order of "gfedcba". For example, in order to display "0" from the hidden state, "0111111" must be sent to the display as a signal. To change from "0" to "5", send "1010010". If you want to change "5" to "1" in succession, send "1101011".
<image>
Create a program that takes n (1 ≤ n ≤ 100) numbers that you want to display and outputs the signal sequence required to correctly display those numbers di (0 ≤ di ≤ 9) on the 7-segment display. please. It is assumed that the initial state of the 7-segment display is all hidden.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of -1. Each dataset is given in the following format:
n
d1
d2
::
dn
The number of datasets does not exceed 120.
Output
For each input dataset, output the sequence of signals needed to properly output the numbers to the display.
Example
Input
3
0
5
1
1
0
-1
Output
0111111
1010010
1101011
0111111
|
#include <algorithm>
#include <iostream>
using namespace std;
// g, f, e, d, c, b, a
int ss[10][7] = {
{ 0, 1, 1, 1, 1, 1, 1 },
{ 0, 0, 0, 0, 1, 1, 0 },
{ 1, 0, 1, 1, 0, 1, 1 },
{ 1, 0, 0, 1, 1, 1, 1 },
{ 1, 1, 0, 0, 1, 1, 0 },
{ 1, 1, 0, 1, 1, 0, 1 },
{ 1, 1, 1, 1, 1, 0, 1 },
{ 0, 1, 0, 0, 1, 1, 1 },
{ 1, 1, 1, 1, 1, 1, 1 },
{ 1, 1, 0, 1, 1, 1, 1 }
};
int main() {
for (;;) {
int n;
cin >> n;
if (n == -1) return 0;
int d[7];
fill(d, d+7, 0);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
for (int j = 0; j < 7; j++) {
cout << (d[j] ^ ss[x][j]);
d[j] = ss[x][j];
}
cout << endl;
}
}
}
|
$N$ sages are sitting around a round table with $N$ seats. Each sage holds chopsticks with his dominant hand to eat his dinner. The following happens in this situation.
* If sage $i$ is right-handed and a left-handed sage sits on his right, a level of frustration $w_i$ occurs to him. A right-handed sage on his right does not cause such frustration at all.
* If sage $i$ is left-handed and a right-handed sage sits on his left, a level of frustration $w_i$ occurs to him. A left-handed sage on his left does not cause such frustration at all.
You wish you could minimize the total amount of frustration by clever sitting order arrangement.
Given the number of sages with his dominant hand information, make a program to evaluate the minimum frustration achievable.
Input
The input is given in the following format.
$N$
$a_1$ $a_2$ $...$ $a_N$
$w_1$ $w_2$ $...$ $w_N$
The first line provides the number of sages $N$ ($3 \leq N \leq 10$). The second line provides an array of integers $a_i$ (0 or 1) which indicate if the $i$-th sage is right-handed (0) or left-handed (1). The third line provides an array of integers $w_i$ ($1 \leq w_i \leq 1000$) which indicate the level of frustration the $i$-th sage bears.
Output
Output the minimum total frustration the sages bear.
Examples
Input
5
1 0 0 1 0
2 3 5 1 2
Output
3
Input
3
0 0 0
1 2 3
Output
0
|
#include<iostream>
#include<vector>
#include<algorithm>
#define REP(i,n) for(int i=0;i<n;i++)
#define FOR(i,s,e) for(int i=s;i<e;i++)
using namespace std;
int main(void) {
int N, MINR = 1001, MINL = 1001;
cin >> N;
vector<int> a(N);
vector<int> w(N);
REP(i, N)cin >> a[i];
REP(i, N)cin >> w[i];
REP(i, N) {
if (a[i] == 0 && w[i] < MINR)MINR = w[i];
else if (a[i] == 1 && w[i] < MINL)MINL = w[i];
}
if (MINL == 1001 || MINR == 1001)cout << 0 << endl;
else cout << MINL + MINR << endl;
return 0;
}
|
Dr. Asimov, a robotics researcher, loves to research, but hates houseworks and his house were really dirty. So, he has developed a cleaning robot.
As shown in the following figure, his house has 9 rooms, where each room is identified by an alphabet:
<image>
The robot he developed operates as follows:
* If the battery runs down, the robot stops.
* If not so, the robot chooses a direction from four cardinal points with the equal probability, and moves to the room in that direction. Then, the robot clean the room and consumes 1 point of the battery.
* However, if there is no room in that direction, the robot does not move and remains the same room. In addition, there is a junk room in the house where the robot can not enter, and the robot also remains when it tries to enter the junk room. The robot also consumes 1 point of the battery when it remains the same place.
A battery charger for the robot is in a room. It would be convenient for Dr. Asimov if the robot stops at the battery room when its battery run down.
Your task is to write a program which computes the probability of the robot stopping at the battery room.
Constraints
* Judge data includes at most 100 data sets.
* n ≤ 15
* s, t, b are distinct.
Input
The input consists of several datasets. Each dataset consists of:
n
s t b
n is an integer that indicates the initial battery point. s, t, b are alphabets respectively represent the room where the robot is initially, the battery room, and the junk room.
The input ends with a dataset which consists of single 0 for n. Your program should not output for this dataset.
Output
For each dataset, print the probability as a floating point number in a line. The answer may not have an error greater than 0.000001.
Example
Input
1
E A C
1
E B C
2
E A B
0
Output
0.00000000
0.25000000
0.06250000
|
#include <vector>
#include <list>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <algorithm>
#include <utility>
#include <functional>
#include <sstream>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <climits>
#include <cassert>
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define EACH(t,i,c) for(t::iterator i=(c).begin(); i!=(c).end(); ++i)
const double EPS = 1e-10;
const double PI = acos(-1.0);
typedef vector<double> vd;
typedef vector<vd> vvd;
int dx[]={-1,0,1,0},dy[]={0,-1,0,1};
char roomChar[3][3]={{'A','B','C'},{'D','E','F'},{'G','H','I'}};
char getRoomChar(int x,int y){
return roomChar[y][x];
}
pii getRoomLoc(char c){
REP(x,3){
REP(y,3){
if(roomChar[y][x]==c){
return make_pair(x,y);
}
}
}
}
int main(){
int n;
while(cin>>n,n){
char s,t,b;
cin>>s>>t>>b;
vector<vvd> p(n+1,vvd(3,vd(3)));
pii sl=getRoomLoc(s);
p[0][sl.first][sl.second]=1;
REP(i,n){
REP(x,3){
REP(y,3){
REP(d,4){
int xx=x+dx[d];
int yy=y+dy[d];
if(xx>=0&&yy>=0&&xx<3&&yy<3&&getRoomChar(xx,yy)!=b){
p[i+1][xx][yy]+=p[i][x][y]/4;
}else{
p[i+1][x][y]+=p[i][x][y]/4;
}
}
}
}
}
pii tl=getRoomLoc(t);
printf("%.10f\n",p[n][tl.first][tl.second]);
}
}
|
Consider car trips in a country where there is no friction. Cars in this country do not have engines. Once a car started to move at a speed, it keeps moving at the same speed. There are acceleration devices on some points on the road, where a car can increase or decrease its speed by 1. It can also keep its speed there. Your job in this problem is to write a program which determines the route with the shortest time to travel from a starting city to a goal city.
There are several cities in the country, and a road network connecting them. Each city has an acceleration device. As mentioned above, if a car arrives at a city at a speed v , it leaves the city at one of v - 1, v , or v + 1. The first road leaving the starting city must be run at the speed 1. Similarly, the last road arriving at the goal city must be run at the speed 1.
The starting city and the goal city are given. The problem is to find the best route which leads to the goal city going through several cities on the road network. When the car arrives at a city, it cannot immediately go back the road it used to reach the city. No U-turns are allowed. Except this constraint, one can choose any route on the road network. It is allowed to visit the same city or use the same road multiple times. The starting city and the goal city may be visited during the trip.
For each road on the network, its distance and speed limit are given. A car must run a road at a speed less than or equal to its speed limit. The time needed to run a road is the distance divided by the speed. The time needed within cities including that for acceleration or deceleration should be ignored.
Input
The input consists of multiple datasets, each in the following format.
> n m
> s g
> x 1 y 1 d 1 c 1
> ...
> xm ym dm cm
>
Every input item in a dataset is a non-negative integer. Input items in the same line are separated by a space.
The first line gives the size of the road network. n is the number of cities in the network. You can assume that the number of cities is between 2 and 30, inclusive. m is the number of roads between cities, which may be zero.
The second line gives the trip. s is the city index of the starting city. g is the city index of the goal city. s is not equal to g . You can assume that all city indices in a dataset (including the above two) are between 1 and n , inclusive.
The following m lines give the details of roads between cities. The i -th road connects two cities with city indices xi and yi , and has a distance di (1 ≤ i ≤ m ). You can assume that the distance is between 1 and 100, inclusive. The speed limit of the road is specified by ci . You can assume that the speed limit is between 1 and 30, inclusive.
No two roads connect the same pair of cities. A road never connects a city with itself. Each road can be traveled in both directions.
The last dataset is followed by a line containing two zeros (separated by a space).
Output
For each dataset in the input, one line should be output as specified below. An output line should not contain extra characters such as spaces.
If one can travel from the starting city to the goal city, the time needed for the best route (a route with the shortest time) should be printed. The answer should not have an error greater than 0.001. You may output any number of digits after the decimal point, provided that the above accuracy condition is satisfied.
If it is impossible to reach the goal city, the string "`unreachable`" should be printed. Note that all the letters of "`unreachable`" are in lowercase.
Sample Input
2 0
1 2
5 4
1 5
1 2 1 1
2 3 2 2
3 4 2 2
4 5 1 1
6 6
1 6
1 2 2 1
2 3 2 1
3 6 2 1
1 4 2 30
4 5 3 30
5 6 2 30
6 7
1 6
1 2 1 30
2 3 1 30
3 1 1 30
3 4 100 30
4 5 1 30
5 6 1 30
6 4 1 30
0 0
Output for the Sample Input
unreachable
4.00000
5.50000
11.25664
Example
Input
2 0
1 2
5 4
1 5
1 2 1 1
2 3 2 2
3 4 2 2
4 5 1 1
6 6
1 6
1 2 2 1
2 3 2 1
3 6 2 1
1 4 2 30
4 5 3 30
5 6 2 30
6 7
1 6
1 2 1 30
2 3 1 30
3 1 1 30
3 4 100 30
4 5 1 30
5 6 1 30
6 4 1 30
0 0
Output
unreachable
4.00000
5.50000
11.25664
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m,s,g;
while(cin>>n>>m,n||m){
cin>>s>>g;
s--;g--;
int d[n][n],c[n][n];
memset(d,-1,sizeof(d));
memset(c,-1,sizeof(c));
int i,j,k,l,x,y;
for(i=0;i<m;i++){
cin>>x>>y>>j>>k;
x--;y--;
d[x][y]=d[y][x]=j;
c[x][y]=c[y][x]=k;
}
double v[n][50][n];
double inf=1<<28,p,ans=inf;
for(i=0;i<n;i++) for(j=0;j<50;j++) for(k=0;k<n;k++) v[i][j][k]=inf;
typedef pair<int,int> PPP;
typedef pair<int,PPP> P;
typedef pair<double,P> PP;
priority_queue<PP,vector<PP>,greater<PP> > q;
q.push(PP(0,P(s,PPP(1,-1))));
while(!q.empty()){
x=q.top().second.first;
y=q.top().second.second.first;
k=q.top().second.second.second;
p=q.top().first;q.pop();
if(v[x][y][k]<=p) continue;
v[x][y][k]=p;
if(x==g&&y==1) break;
for(i=0;i<n;i++){
if(!~d[x][i]||i==k) continue;
for(j=-1;j<=1;j++){
if(k==-1&&j!=0) continue;
if(y+j<=0||c[x][i]<y+j) continue;
q.push(PP(p+(double)d[x][i]/(y+j),P(i,PPP(y+j,x))));
}
}
}
for(i=0;i<n;i++) ans=min(ans,v[g][1][i]);
if(ans!=inf) printf("%.8f\n",ans);
else printf("unreachable\n");
}
return 0;
}
|
ICPC (International Connecting Points Company) starts to sell a new railway toy. It consists of a toy tramcar and many rail units on square frames of the same size. There are four types of rail units, namely, straight (S), curve (C), left-switch (L) and right-switch (R) as shown in Figure 9. A switch has three ends, namely, branch/merge-end (B/M-end), straight-end (S-end) and curve-end (C-end).
<image>
A switch is either in "through" or "branching" state. When the tramcar comes from B/M-end, and if the switch is in the through-state, the tramcar goes through to S-end and the state changes to branching; if the switch is in the branching-state, it branches toward C-end and the state changes to through. When the tramcar comes from S-end or C-end, it goes out from B/M-end regardless of the state. The state does not change in this case.
Kids are given rail units of various types that fill a rectangle area of w × h, as shown in Fig- ure 10(a). Rail units meeting at an edge of adjacent two frames are automatically connected. Each rail unit may be independently rotated around the center of its frame by multiples of 90 degrees in order to change the connection of rail units, but its position cannot be changed.
Kids should make "valid" layouts by rotating each rail unit, such as getting Figure 10(b) from Figure 10(a). A layout is valid when all rails at three ends of every switch are directly or indirectly connected to an end of another switch or itself. A layout in Figure 10(c) is invalid as well as Figure 10(a). Invalid layouts are frowned upon.
When a tramcar runs in a valid layout, it will eventually begin to repeat the same route forever. That is, we will eventually find the tramcar periodically comes to the same running condition, which is a triple of the tramcar position in the rectangle area, its direction, and the set of the states of all the switches.
<image>
A periodical route is a sequence of rail units on which the tramcar starts from a rail unit with a running condition and returns to the same rail unit with the same running condition for the first time. A periodical route through a switch or switches is called the "fun route", since kids like the rattling sound the tramcar makes when it passes through a switch. The tramcar takes the same unit time to go through a rail unit, not depending on the types of the unit or the tramcar directions. After the tramcar starts on a rail unit on a “fun route”, it will come back to the same unit with the same running condition, sooner or later. The fun time T of a fun route is the number of time units that the tramcar takes for going around the route.
Of course, kids better enjoy layouts with longer fun time. Given a variety of rail units placed on a rectangular area, your job is to rotate the given rail units appropriately and to find the fun route with the longest fun time in the valid layouts.
For example, there is a fun route in Figure 10(b). Its fun time is 24. Let the toy tramcar start from B/M-end at (1, 2) toward (1, 3) and the states of all the switches are the through-states. It goes through (1, 3), (1, 4), (1, 5), (2, 5), (2, 4), (1, 4), (1, 3), (1, 2), (1, 1), (2, 1), (2, 2) and (1, 2). Here, the tramcar goes through (1, 2) with the same position and the same direction, but with the different states of the switches. Then the tramcar goes through (1, 3), (1, 4), (2, 4), (2, 5), (1, 5), (1, 4), (1, 3), (1, 2), (2, 2), (2, 1), (1, 1) and (1, 2). Here, the tramcar goes through (1, 2) again, but with the same switch states as the initial ones. Counting the rail units the tramcar visited, the tramcar should have run 24 units of time after its start, and thus the fun time is 24.
There may be many valid layouts with the given rail units. For example, a valid layout containing a fun route with the fun time 120 is shown in Figure 11(a). Another valid layout containing a fun route with the fun time 148 derived from that in Figure 11(a) is shown in Figure 11(b). The four rail units whose rotations are changed from Figure 11(a) are indicated by the thick lines.
A valid layout depicted in Figure 12(a) contains two fun routes, where one consists of the rail units (1, 1), (2, 1), (3, 1), (4, 1), (4, 2), (3, 2), (2, 2), (1, 2) with T = 8, and the other consists of all the remaining rail units with T = 18.
<image>
Another valid layout depicted in Figure 12(b) has two fun routes whose fun times are T = 12 and T = 20. The layout in Figure 12(a) is different from that in Figure 12(b) at the eight rail units rotated by multiples of 90 degrees. There are other valid layouts with some rotations of rail units but there is no fun route with the fun time longer than 20, so that the longest fun time for this example (Figure 12) is 20.
<image>
Note that there may be simple cyclic routes that do not go through any switches in a valid layout, which are not counted as the fun routes. In Figure 13, there are two fun routes and one simple cyclic route. Their fun times are 12 and 14, respectively. The required time for going around the simple cyclic route is 20 that is greater than fun times of the fun routes. However, the longest fun time is still 14.
<image>
Input
The input consists of multiple datasets, followed by a line containing two zeros separated by a space. Each dataset has the following format.
w h
a11 ... a1w
...
ah1 ... ahw
w is the number of the rail units in a row, and h is the number of those in a column. aij (1 ≤ i ≤ h, 1 ≤ j ≤ w) is one of uppercase letters 'S', 'C', 'L' and 'R', which indicate the types of the rail unit at (i, j) position, i.e., straight, curve, left-switch and right-switch, respectively. Items in a line are separated by a space. You can assume that 2 ≤ w ≤ 6, 2 ≤ h ≤ 6 and the sum of the numbers of left-switches and right-switches is greater than or equal to 2 and less than or equal to 6.
Output
For each dataset, an integer should be printed that indicates the longest fun time of all the fun routes in all the valid layouts with the given rail units. When there is no valid layout according to the given rail units, a zero should be printed.
Example
Input
5 2
C L S R C
C C S C C
6 4
C C C C C C
S L R R C S
S S S L C S
C C C C C C
6 6
C L S S S C
C C C S S C
C C C S S C
C L C S S C
C C L S S C
C S L S S C
6 6
C S S S S C
S C S L C S
S C S R C S
S C L S C S
S C R S C S
C S S S S C
4 4
S C C S
S C L S
S L C S
C C C C
6 4
C R S S L C
C R L R L C
C S C C S C
C S S S S C
0 0
Output
24
20
148
14
0
178
|
#include<iostream>
#include<cassert>
using namespace std;
#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define N 0
#define E 1
#define S 2
#define W 3
int dx[]={0,1,0,-1};
int dy[]={-1,0,1,0};
int curdir[]={S,W,N,E};
int sd[2][4]={//S default:0 -
-1,W,-1,E,
S,-1,N,-1,
};
int cd[4][4]={//C default:0 -^
W,-1,-1,N,
E,N,-1,-1,
-1,S,E,-1,
-1,-1,W,S,
};
int ld[4][2][4]={//if switch == 0 ld[i][0], switch == 1 ld[i][1]
//ST //CURVE
W,W,-1,E, W,W,-1,N,
S,N,N,-1, E,N,N,-1,
-1,W,E,E, -1,S,E,E,
S,-1,N,S, S,-1,W,S
/*
{W,W,-1,E},{W,W,-1,N},
{S,N,N,-1},{E,N,N,-1},
{-1,W,E,E},{-1,S,E,E},
{S,-1,N,S},{S,-1,W,S}
*/
};
int rd[4][2][4]={//if switch == 0 ld[i][0], switch == 1 ld[i][1]
//ST //CURVE
-1,W,W,E, -1,W,W,S,
S,-1,N,N, W,-1,N,N,
E,W,-1,E, E,N,-1,E,
S,S,N,-1, S,S,E,-1
/*
{-1,W,W,E},{-1,W,W,S},
{S,-1,N,N},{W,-1,N,N},
{E,W,-1,E},{E,N,-1,E},
{S,S,N,-1},{S,S,E,-1}
*/
};
int switchid[6][6];
int rot[6][6];
char m[6][6];
int cost[6][6][4][(1<<6)];
int visited[6][6][4][(1<<6)];
int ans;
void dfs(int r,int c,int y,int x,int d,int state,int visnow,int length){
if (length != 0)d=curdir[d];
if (x == -1||y == -1||x==c||y==r)return;
if (visited[y][x][d][state] == -1){
}else if (visited[y][x][d][state] == visnow){
ans=max(ans,length-cost[y][x][d][state]);
return;
}else {
return;
}
visited[y][x][d][state]=visnow;
cost[y][x][d][state] =length;
int nextd;
int curgrid=rot[y][x];
if (m[y][x] == 'S'){
nextd=sd[curgrid][d];
dfs(r,c,y+dy[nextd],x+dx[nextd],nextd,state,visnow,length+1);
}else if( m[y][x] == 'C'){
nextd=cd[curgrid][d];
dfs(r,c,y+dy[nextd],x+dx[nextd],nextd,state,visnow,length+1);
}else if (m[y][x] == 'L'){
bool isswitch=(((1<<switchid[y][x])&state)!=0);
nextd=ld[curgrid][isswitch][d];
if ((rot[y][x]+3)%4 == d){
if (isswitch)state-=(1<<switchid[y][x]);
else state+=(1<<switchid[y][x]);
}
dfs(r,c,y+dy[nextd],x+dx[nextd],nextd,state,visnow,length+1);
}else if (m[y][x] == 'R'){
bool isswitch=(((1<<switchid[y][x])&state)!=0);
nextd=rd[curgrid][isswitch][d];
if ((rot[y][x]+3)%4==d){
if (isswitch)state-=(1<<switchid[y][x]);
else state+=(1<<switchid[y][x]);
}
dfs(r,c,y+dy[nextd],x+dx[nextd],nextd,state,visnow,length+1);
}
}
void solve(int r,int c,int index){
rep(i,r){
rep(j,c){
rep(k,4){
rep(l,(1<<index)){
visited[i][j][k][l]=-1;
}
}
}
}
int visnow=0;
rep(i,r){
rep(j,c){
if (m[i][j] == 'R'||m[i][j] == 'L'){
if (rot[i][j] == 0){
dfs(r,c,i,j,W,0,visnow,0);
}else if (rot[i][j] == 1){
dfs(r,c,i,j,N,0,visnow,0);
}else if (rot[i][j] == 2){
dfs(r,c,i,j,E,0,visnow,0);
}else if (rot[i][j] == 3){
dfs(r,c,i,j,S,0,visnow,0);
}
visnow++;
}
}
}
}
//if rot[i][j] == -1 unvisited
void search(int r,int c,int index,int now,int num,//num -> 3 position of L or R
int y,int x,int d,int *posx,int *posy,bool tonext){
if (tonext && num == 0 && index == now+1){
solve(r,c,index);
return;
}
if (tonext){
if (num == 0){//straight
now++;
y = posy[now];
x = posx[now];
d = (rot[y][x]+3)%4;
search(r,c,index,now,1,posy[now]+dy[d],posx[now]+dx[d],
d,posx,posy,false);
}else if (num == 1){
y = posy[now];
x = posx[now];
d=(rot[y][x]+1)%4;
search(r,c,index,now,2,posy[now]+dy[d],posx[now]+dx[d],
d,posx,posy,false);
}else if (num == 2){//curve
y = posy[now];
x = posx[now];
if (m[y][x] == 'R'){
d=(rot[y][x]+2)%4;
}else if (m[posy[now]][posx[now]]=='L'){
d=rot[y][x];
}
search(r,c,index,now,0,posy[now]+dy[d],posx[now]+dx[d],
d,posx,posy,false);
}
return;
}
if (x == -1 || y == -1||x==c||y==r)return;
d=curdir[d];
if (m[y][x] == 'S'){
if (rot[y][x] == -1){
if (d == E || d == W)rot[y][x]=0;
else if (d == S || d == N)rot[y][x]=1;
search(r,c,index,now,num,y+dy[sd[rot[y][x]][d]],x+dx[sd[rot[y][x]][d]],
sd[rot[y][x]][d],posx,posy,false);
rot[y][x]=-1;
return;
}else if (rot[y][x] != -1){
if (sd[rot[y][x]][d] == -1)return;
else search(r,c,index,now,num,-1,-1,-1,posx,posy,true);
}
}else if(m[y][x] == 'C'){
if (rot[y][x] == -1){
if (d == E)rot[y][x]=1;
else if (d == W)rot[y][x]=3;
else if (d == S)rot[y][x]=2;
else if (d == N)rot[y][x]=0;
search(r,c,index,now,num,y+dy[cd[rot[y][x]][d]],x+dx[cd[rot[y][x]][d]],
cd[rot[y][x]][d],posx,posy,false);
if (d == E)rot[y][x]=2;
else if (d == W)rot[y][x]=0;
else if (d == S)rot[y][x]=3;
else if (d == N)rot[y][x]=1;
search(r,c,index,now,num,y+dy[cd[rot[y][x]][d]],x+dx[cd[rot[y][x]][d]],
cd[rot[y][x]][d],posx,posy,false);
rot[y][x]=-1;
}else if (rot[y][x] != -1){
if (cd[rot[y][x]][d] == -1)return;
else search(r,c,index,now,num,-1,-1,-1,posx,posy,true);
}
}else if (m[y][x] == 'L'){
if (ld[rot[y][x]][0][d] == -1)return;
search(r,c,index,now,num,-1,-1,-1,posx,posy,true);
}else if (m[y][x] == 'R'){
if (rd[rot[y][x]][0][d] == -1)return;
search(r,c,index,now,num,-1,-1,-1,posx,posy,true);
}
}
void decide(int r,int c,int index,int now,int *posx,int *posy){
if (now == index){
search(r,c,index,-1,0,-1,-1,-1,posx,posy,true);
return;
}
rep(i,4){
rot[posy[now]][posx[now]]=i;
decide(r,c,index,now+1,posx,posy);
}
}
int main(){
int r,c;
while(cin>>c>>r && c){
int index =0;
int posx[6],posy[6];
rep(i,r){
rep(j,c){
cin>>m[i][j];
rot[i][j]=-1;
if (m[i][j] == 'R'||m[i][j]=='L'){
switchid[i][j]=index;
posy[index]=i;
posx[index]=j;
index++;
}
}
}
ans = 0;
decide(r,c,index,0,posx,posy);
cout << ans << endl;
}
}
|
Problem
In this problem, a straight line passing through a certain point X and a certain point Y in the three-dimensional space is written as a straight line XY.
A cone and a point P inside the cone are given in three-dimensional space. Let point Q be the intersection of a straight line passing through point P and perpendicular to the bottom of the cone and the bottom of the cone. At this time, the center of the bottom surface of the cone is O, and the intersection of the straight line OQ and the circumference of the bottom surface of the cone is point A and point B from the side closer to point Q (however, point O and point Q are the same point). In the case of, let points A and B be the intersections of any straight line passing through point O and the circumference of the bottom of the cone.) Also, in a plane that includes the bottom surface of the cone, let points C and D be the intersections of the straight line that passes through point O and intersects the straight line AB perpendicularly with the circumference of the bottom surface of the cone (however, points C and D). Can be replaced).
The figure below is a view of the bottom surface of the cone as seen from the direction of the apex of the cone.
View of the bottom of the cone as seen from the apex of the cone
Let the intersection of the straight line AP and the cone of the straight line BP (in the case of the straight line AP, the intersection that is not the point A. The same applies to the straight line BP) be the point A'and the point B', and pass through the points A'and B'. Cut the cone at the plane S parallel to the straight line CD. At this time, output the volume of the figure including the vertices after cutting and the volume of the other figure separated by blanks.
Input
X coordinate y coordinate z coordinate of the apex of the cone
X coordinate y coordinate z coordinate of the center of the base of the cone Radius of the base of the cone
X coordinate y coordinate z coordinate of point P
Each value on each row is given separated by spaces.
Constraint
All input values are integers, the absolute value of which is less than or equal to 1000.
The height of the cone and the radius of its base are greater than or equal to 1, and the distance between point P and the cone is greater than or equal to 10-5.
Output
Output the volume of the figure including the vertices after cutting and the volume of the other figure separated by blanks.
However, it must not contain an error greater than 10-5.
Sample Input 1
0 0 10
0 0 0 4
0 0 1
Sample Output 1
91.769438 75.782170
Sample Input 2
0 0 10
0 0 0 4
1 1 1
Sample Output 2
84.050413 83.501195
Sample Input 3
0 0 0
8 9 10 5
1 1 1
Sample Output 3
0.071663 409.709196
Example
Input
0 0 10
0 0 0 4
0 0 1
Output
91.769438 75.782170
|
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cstring>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <bitset>
#include <numeric>
#include <utility>
#include <iomanip>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long ll;
typedef vector<int> vint;
typedef vector<long long> vll;
typedef pair<int,int> pint;
typedef pair<long long, long long> pll;
#define MP make_pair
#define PB push_back
#define ALL(s) (s).begin(),(s).end()
#define EACH(i, s) for (__typeof__((s).begin()) i = (s).begin(); i != (s).end(); ++i)
#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<class T1, class T2> ostream& operator << (ostream &s, pair<T1,T2> P)
{ return s << '<' << P.first << ", " << P.second << '>'; }
template<class T> ostream& operator << (ostream &s, vector<T> P)
{ for (int i = 0; i < P.size(); ++i) { if (i > 0) { s << " "; } s << P[i]; } return s; }
template<class T> ostream& operator << (ostream &s, vector<vector<T> > P)
{ for (int i = 0; i < P.size(); ++i) { s << endl << P[i]; } return s << endl; }
template<class T1, class T2> ostream& operator << (ostream &s, map<T1,T2> P)
{ EACH(it, P) { s << "<" << it->first << "->" << it->second << "> "; } return s; }
typedef double DD;
const DD INF = 1LL<<60;
const DD EPS = 1e-10;
const DD PI = acos(-1.0);
DD torad(int deg) {return (DD)(deg) * PI / 180;}
DD todeg(DD ang) {return ang * 180 / PI;}
struct Point {
DD x, y;
Point(DD x = 0.0, DD y = 0.0) : x(x), y(y) {}
friend ostream& operator << (ostream &s, const Point &p) {return s << '(' << p.x << ", " << p.y << ')';}
};
Point operator + (const Point &p, const Point &q) {return Point(p.x + q.x, p.y + q.y);}
Point operator - (const Point &p, const Point &q) {return Point(p.x - q.x, p.y - q.y);}
Point operator * (const Point &p, DD a) {return Point(p.x * a, p.y * a);}
Point operator * (DD a, const Point &p) {return Point(a * p.x, a * p.y);}
Point operator * (const Point &p, const Point &q) {return Point(p.x * q.x - p.y * q.y, p.x * q.y + p.y * q.x);}
Point operator / (const Point &p, DD a) {return Point(p.x / a, p.y / a);}
Point conj(const Point &p) {return Point(p.x, -p.y);}
Point rot(const Point &p, DD ang) {return Point(cos(ang) * p.x - sin(ang) * p.y, sin(ang) * p.x + cos(ang) * p.y);}
Point rot90(const Point &p) {return Point(-p.y, p.x);}
DD cross(const Point &p, const Point &q) {return p.x * q.y - p.y * q.x;}
DD dot(const Point &p, const Point &q) {return p.x * q.x + p.y * q.y;}
DD norm(const Point &p) {return dot(p, p);}
DD abs(const Point &p) {return sqrt(dot(p, p));}
DD amp(const Point &p) {DD res = atan2(p.y, p.x); if (res < 0) res += PI*2; return res;}
bool eq(const Point &p, const Point &q) {return abs(p - q) < EPS;}
bool operator < (const Point &p, const Point &q) {return (abs(p.x - q.x) > EPS ? p.x < q.x : p.y < q.y);}
bool operator > (const Point &p, const Point &q) {return (abs(p.x - q.x) > EPS ? p.x > q.x : p.y > q.y);}
Point operator / (const Point &p, const Point &q) {return p * conj(q) / norm(q);}
int ccw(const Point &a, const Point &b, const Point &c) {
if (cross(b-a, c-a) > EPS) return 1;
if (cross(b-a, c-a) < -EPS) return -1;
if (dot(b-a, c-a) < -EPS) return 2;
if (norm(b-a) < norm(c-a) - EPS) return -2;
return 0;
}
struct Line : vector<Point> {
Line(Point a = Point(0.0, 0.0), Point b = Point(0.0, 0.0)) {
this->push_back(a);
this->push_back(b);
}
friend ostream& operator << (ostream &s, const Line &l) {return s << '{' << l[0] << ", " << l[1] << '}';}
};
struct Circle : Point {
DD r;
Circle(Point p = Point(0.0, 0.0), DD r = 0.0) : Point(p), r(r) {}
friend ostream& operator << (ostream &s, const Circle &c) {return s << '(' << c.x << ", " << c.y << ", " << c.r << ')';}
};
Point proj(Point p, Line l) {
DD t = dot(p - l[0], l[1] - l[0]) / norm(l[1] - l[0]);
return l[0] + (l[1] - l[0]) * t;
}
vector<Point> crosspoint(Line l, Line m) {
vector<Point> res;
DD d = cross(m[1] - m[0], l[1] - l[0]);
if (abs(d) < EPS) return vector<Point>();
res.push_back(l[0] + (l[1] - l[0]) * cross(m[1] - m[0], m[1] - l[0]) / d);
return res;
}
vector<Point> crosspoint(Circle e, Circle f) {
vector<Point> res;
DD d = abs(e - f);
if (d < EPS) return vector<Point>();
if (d > e.r + f.r + EPS) return vector<Point>();
if (d < abs(e.r - f.r) - EPS) return vector<Point>();
DD rcos = (d * d + e.r * e.r - f.r * f.r) / (2.0 * d), rsin;
if (e.r - abs(rcos) < EPS) rsin = 0;
else rsin = sqrt(e.r * e.r - rcos * rcos);
Point dir = (f - e) / d;
Point p1 = e + dir * Point(rcos, rsin);
Point p2 = e + dir * Point(rcos, -rsin);
res.push_back(p1);
if (!eq(p1, p2)) res.push_back(p2);
return res;
}
vector<Point> crosspoint(Circle e, Line l) {
vector<Point> res;
Point p = proj(e, l);
DD rcos = abs(e - p), rsin;
if (rcos > e.r + EPS) return vector<Point>();
else if (e.r - rcos < EPS) rsin = 0;
else rsin = sqrt(e.r * e.r - rcos * rcos);
Point dir = (l[1] - l[0]) / abs(l[1] - l[0]);
Point p1 = p + dir * rsin;
Point p2 = p - dir * rsin;
res.push_back(p1);
if (!eq(p1, p2)) res.push_back(p2);
return res;
}
struct Point3D {
DD x, y, z;
Point3D(DD x = 0.0, DD y = 0.0, DD z = 0.0) : x(x), y(y), z(z) {}
friend ostream& operator << (ostream &s, const Point3D &p) {return s << '(' << p.x << ", " << p.y << ", " << p.z << ')';}
};
Point3D operator + (const Point3D &p, const Point3D &q) {return Point3D(p.x + q.x, p.y + q.y, p.z + q.z);}
Point3D operator - (const Point3D &p, const Point3D &q) {return Point3D(p.x - q.x, p.y - q.y, p.z - q.z);}
Point3D operator * (const Point3D &p, DD a) {return Point3D(p.x * a, p.y * a, p.z * a);}
Point3D operator * (DD a, const Point3D &p) {return Point3D(a * p.x, a * p.y, a * p.z);}
Point3D operator * (const Point3D &p, const Point3D &q) {
return Point3D(p.y * q.z - p.z * q.y, p.z * q.x - p.x * q.z, p.x * q.y - p.y * q.x);
}
Point3D operator / (const Point3D &p, DD a) {return Point3D(p.x / a, p.y / a), p.z / a;}
DD dot(const Point3D &p, const Point3D &q) {return p.x * q.x + p.y * q.y + p.z * q.z;}
DD norm(const Point3D &p) {return dot(p, p);}
DD abs(const Point3D &p) {return sqrt(dot(p, p));}
bool eq(const Point3D &p, const Point3D &q) {return abs(p - q) < EPS;}
struct Line3D : vector<Point3D> {
Line3D(Point3D a = Point3D(0.0, 0.0, 0.0), Point3D b = Point3D(0.0, 0.0, 0.0)) {
this->push_back(a);
this->push_back(b);
}
friend ostream& operator << (ostream &s, const Line3D &l) {return s << '{' << l[0] << ", " << l[1] << '}';}
};
struct Circle3D : Point3D {
DD r;
Circle3D(Point3D p = Point3D(0.0, 0.0), DD r = 0.0) : Point3D(p), r(r) {}
friend ostream& operator << (ostream &s, const Circle3D &c) {return s << '(' << c.x << ", " << c.y << ", " << c.r << ')';}
};
Point3D proj(Point3D p, Line3D l) {
DD t = dot(p - l[0], l[1] - l[0]) / norm(l[1] - l[0]);
return l[0] + (l[1] - l[0]) * t;
}
Point3D proj(Point3D v, Point3D d) {
DD t = dot(v, d) / norm(d);
return v * t;
}
Point3D refl(Point3D p, Line3D l) {
return p + (proj(p, l) - p) * 2;
}
bool isinterPL(Point3D p, Line3D l) {
return (abs(p - proj(p, l)) < EPS);
}
DD distancePL(Point3D p, Line3D l) {
return abs(p - proj(p, l));
}
DD distanceLL(Line3D l, Line3D m) {
Point3D nv = (l[1] - l[0]) * (m[1] - m[0]);
if (abs(nv) < EPS) return distancePL(l[0], m);
Point3D p = m[0] - l[0];
return abs(dot(nv, p)) / abs(nv);
}
Point3D X, Y, P;
DD r;
int main() {
//freopen( "/Users/macuser/Dropbox/Contest/input.in", "r", stdin );
while (cin >> X.x >> X.y >> X.z >> Y.x >> Y.y >> Y.z >> r >> P.x >> P.y >> P.z) {
Line3D l(X, Y);
Point3D PH = proj(P, l);
Point x(0, abs(X - Y));
Point y(0, 0);
Point p(abs(P-PH), abs(PH-Y));
Point a(r, 0);
Point b(-r, 0);
vector<Point> vc = crosspoint(Line(p, a), Line(x, b));
Point c = vc[0];
vector<Point> vd = crosspoint(Line(p, b), Line(x, a));
Point d = vd[0];
Point m = (c + d)/2;
Point h = proj(x, Line(c, d));
DD tsr = r * abs(x.y - m.y) / abs(x - y);
DD sr = sqrt(tsr * tsr - m.x * m.x);
DD tot = PI * r * r * abs(x-y) / 3;
DD sol = PI * abs(c - d) * sr * abs(x - h) / 6;
// COUT(X);
// COUT(Y);
// COUT(P);
// COUT(PH);
// COUT(x);
// COUT(y);
// COUT(p);
// COUT(a);
// COUT(b);
// COUT(c);
// COUT(d);
// COUT(m);
// COUT(h);
// COUT(sr);
// COUT(tot);
// COUT(sol);
cout << fixed << setprecision(9) << sol << " " << tot-sol << endl;
}
return 0;
}
|
Princess in Danger
Princess crisis
English text is not available in this practice contest.
A brave princess in a poor country's tomboy is married to another country for a political marriage. However, a villain who was trying to kill the princess attacked him on the way to his wife, and the princess was seriously injured and was taken to a nearby hospital. However, the villain used a special poison to make sure the princess was dead. Therefore, in order to help the princess, she had to hurry to bring special medicine and frozen relatives' blood from her home country.
This blood is transported frozen, but must be re-frozen in a blood freezing facility within up to M minutes of the previous freezing to keep it fresh. However, there are only a few places where refrigeration facilities are installed.
Blood is safe for M minutes from a fully frozen state without refreezing. If the remaining time without refrigeration is S minutes and the product is transported without freezing for T minutes, the remaining time without refrigeration is S-T minutes. The remaining time that does not require refreezing can be restored up to M minutes by refreezing. The time it takes to refreeze blood depends on how much it is frozen. Every minute the blood is frozen in a freezing facility, the remaining time that does not need to be re-frozen recovers by 1 minute.
At the time of departure from the capital of the home country, the remaining time without refrigerating the blood is M minutes.
As a princess's servant, you must calculate the route to keep the blood fresh from the capital of your home country to the hospital where the princess was transported, in order to save the life of your precious lord. Yes, your mission is to figure out the shortest route from your home capital to the hospital and find the shortest time.
Input
The input consists of multiple datasets. The first row of each dataset contains six non-negative integers N (2 ≤ N ≤ 100), M (1 ≤ M ≤ 100), L (0 ≤ L ≤ N-2), K, A (0 ≤). A <N) and H (0 ≤ H <N) are given. These are the number of towns, the time limit for refrigeration, the number of towns with freezing facilities, the number of roads connecting towns directly, the number representing the capital of the home country, and the hospital where the princess was transported. Represents the town number. The capital of the home country and the hospital where the princess was transported are different towns. It is assumed that the towns are assigned numbers from 0 to N-1. The following lines are given L non-negative integers separated by a single space. These represent the numbers of the towns where the freezing facilities are located. The capital of the home country and the hospital where the princess was transported are not included in this list, but it can be considered that there is a freezing facility. The following line K gives information on the roads connecting the towns. In the i-th line, three non-negative integers X, Y, and T are given separated by one space, which means that there is a direct connection between town X and town Y, and it takes time T to move. Represents that. This road is bidirectional. Also, there is at most one road that directly connects town X and town Y.
The input ends when N = M = L = K = A = H = 0, which is not included in the dataset.
Output
For each dataset, output the shortest time that blood can be delivered while maintaining its freshness. If it cannot be delivered, output "Help!".
Sample Input
2 1 0 1 0 1
0 1 2
3 1 1 2 0 1
2
0 2 1
1 2 1
3 2 1 2 0 1
2
0 2 1
1 2 1
4 4 1 4 1 3
2
0 1 2
1 2 4
0 2 1
3 0 3
5 3 2 6 0 3
1 2
2 1 2
1 0 1
3 4 1
2 4 1
4 1 2
2 0 2
5 4 2 6 0 3
1 2
4 2 4
2 1 2
4 3 1
0 1 5
1 4 2
2 0 3
0 0 0 0 0 0
Output for the Sample Input
Help!
3
2
Ten
Five
12
Example
Input
2 1 0 1 0 1
0 1 2
3 1 1 2 0 1
2
0 2 1
1 2 1
3 2 1 2 0 1
2
0 2 1
1 2 1
4 4 1 4 1 3
2
0 1 2
1 2 4
0 2 1
3 0 3
5 3 2 6 0 3
1 2
2 1 2
1 0 1
3 4 1
2 4 1
4 1 2
2 0 2
5 4 2 6 0 3
1 2
4 2 4
2 1 2
4 3 1
0 1 5
1 4 2
2 0 3
0 0 0 0 0 0
Output
Help!
3
2
10
5
12
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
int dp[110][110];
int dp2[110][110];
int main(){
int n,m,L,K,A,H;
while(cin>>n>>m>>L>>K>>A>>H,n){
rep(i,n) rep(j,n) dp[i][j] = dp2[i][j] = 1e9;
vector<int> ll(L);
rep(i,L) cin>>ll[i];
ll.push_back(A);
ll.push_back(H);
L+=2;
sort(ll.begin(), ll.end());
rep(i,K){
int a,b,c;
cin>>a>>b>>c;
dp[a][b] = dp[b][a] = c;
}
rep(i,n) dp[i][i] = 0;
rep(k,n) rep(i,n) rep(j,n) dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]);
rep(i,L){
rep(j,L){
dp2[i][j] = (dp[ll[i]][ll[j]] > m ? 1e9: dp[ll[i]][ll[j]]);
}
}
rep(i,L) dp2[i][i] = 0;
rep(k,L) rep(i,L) rep(j,L) dp2[i][j] = min(dp2[i][j], dp2[i][k] + dp2[k][j]);
int a,h;
rep(i,L){
if(ll[i]==A) a=i;
if(ll[i]==H) h=i;
}
if(dp2[h][a]>1e8){
cout<<"Help!"<<endl;
}
else{
int t = dp2[h][a];
if(t < m) cout<<t<<endl;
else cout<<t+(t-m)<<endl;
}
}
}
|
Peter is a person with erratic sleep habits. He goes to sleep at twelve o'lock every midnight. He gets up just after one hour of sleep on some days; he may even sleep for twenty-three hours on other days. His sleeping duration changes in a cycle, where he always sleeps for only one hour on the first day of the cycle.
Unfortunately, he has some job interviews this month. No doubt he wants to be in time for them. He can take anhydrous caffeine to reset his sleeping cycle to the beginning of the cycle anytime. Then he will wake up after one hour of sleep when he takes caffeine. But of course he wants to avoid taking caffeine as possible, since it may affect his health and accordingly his very important job interviews.
Your task is to write a program that reports the minimum amount of caffeine required for Peter to attend all his interviews without being late, where the information about the cycle and the schedule of his interviews are given. The time for move to the place of each interview should be considered negligible.
Input
The input consists of multiple datasets. Each dataset is given in the following format:
T
t1 t2 ... tT
N
D1 M1
D2 M2
...
DN MN
T is the length of the cycle (1 ≤ T ≤ 30); ti (for 1 ≤ i ≤ T ) is the amount of sleep on the i-th day of the cycle, given in hours (1 ≤ ti ≤ 23); N is the number of interviews (1 ≤ N ≤ 100); Dj (for 1 ≤ j ≤ N) is the day of the j-th interview (1 ≤ Dj ≤ 100); Mj (for 1 ≤ j ≤ N) is the hour when the j-th interview starts (1 ≤ Mj ≤ 23).
The numbers in the input are all integers. t1 is always 1 as stated above. The day indicated by 1 is the first day in the cycle of Peter's sleep.
The last dataset is followed by a line containing one zero. This line is not a part of any dataset and should not be processed.
Output
For each dataset, print the minimum number of times Peter needs to take anhydrous caffeine.
Example
Input
2
1 23
3
1 1
2 1
3 1
0
Output
2
|
#define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
#define all(c) (c).begin(), (c).end()
#define loop(i,a,b) for(ll i=a; i<ll(b); i++)
#define rep(i,b) loop(i,0,b)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
#define lb lower_bound
#define ub upper_bound
#ifdef DEBUG
#define dump(...) (cerr<<#__VA_ARGS__<<" = "<<(DUMP(),__VA_ARGS__).str()<<" ["<<__LINE__<<"]"<<endl)
struct DUMP:ostringstream{template<class T>DUMP &operator,(const T&t){if(this->tellp())*this<<", ";*this<<t;return *this;}};
#else
#define dump(...)
#endif
template<class T> ostream& operator<<(ostream& os, vector<T> const& v){
rep(i,v.size()) os << v[i] << (i+1==v.size()?"":" ");
return os;
}
int T, t[40];
int N;
int M[200];
int last, dp[200];
int rec(int x){
if(x >= last) return 0;
int & res = dp[x];
if(res != -1) return res;
res = 1<<29;
bool ok = true;
for(int i=x; i<=last; i++){
if(M[i] < t[(i-x)%T]) ok = false;
}
if(ok) res = 0;
for(int i=x+1; i<=last; i++){
res = min(1+rec(i) , res);
if(M[i] < t[(i-x)%T]) break;
}
return res;
}
int main(){
while(cin>>T && T){
memset(dp,-1,sizeof(dp));
rep(i,200) M[i] = 24;
rep(i,T) cin >> t[i];
cin >> N;
rep(i,N){
int x,y;
cin >> x >> y;
M[x] = min(M[x],y);
last = max(last, x);
}
cout << rec(1) << endl;
}
}
|
You have a lot of cats at home. Your daily routine is to take a picture of your cat in a clay pot and taking a nap (commonly known as a cat pot). The appearance of some cats curling up and sleeping together in a pot is really lovely.
Each cat has a "weight" mi and a "Cute" ci defined. Cute is a numerical value that comprehensively evaluates loveliness, innocence, suppleness, softness, and deliciousness when you see only one cat, and the larger it is, the more the cat is. It's attractive.
In addition, the numerical value "UnCute" is defined for the cat pot. This is a value that expresses the unbalance of the cat pot as a whole, and contrary to Cute, the smaller the cat pot, the better the cat pot. UnCute of the cat pot is expressed as Cmax --Cmin by using the maximum value Cmax and the minimum value Cmin of the cute of the cat inside. In other words, a cat pot that all the cats inside have the same cuteness is a good cat pot.
Considering the case of carrying a cat pot, the weight of the cat pot (= the total weight of the cats inside) must be less than or equal to the limit value W. I want to make the UnCute of the cat pot smaller by selecting the cat to be put in the cat pot so as to meet this condition, but how small can it be?
It was a past story that I was completely satisfied with solving the problem.
The other day, when you were organizing your warehouse, you found an old clay pot in the warehouse. There are two clay pots in your house. Yes, it's the age of dual cat pots! Just a cat pot is old!
In the dual cat pot, clay pot A is for male cats only, and the other clay pot B is for female cats only. Also, when defining UnCute for dual cat pots, it is necessary to take into account not only the imbalance of Cute but also the imbalance of the weights of the two cat pots. Specifically, if the weight of the heavier cat pot is Mmax and the weight of the lighter cat pot is Mmin (Mmax = Mmin when the weights of the two cat pots are the same), the dual cat pot UnCute
max {Mmax --Mmin, Cmax --Cmin}
Is expressed. Note that Cmax and Cmin here are the maximum and minimum values of the Cute of the cat in the cat pot A or the cat pot B.
Considering when carrying a cat pot, Mmax must be less than or equal to the limit value W. I want to make the UnCute of the dual cat pot smaller by selecting the cat to be put in the dual cat pot so as to meet this condition, but how small can it be?
Input
NA NB W
mA, 1 cA, 1
mA, 2 cA, 2
..
..
..
mA, NA cA, NA
mB, 1 cB, 1
mB, 2 cB, 2
..
..
..
mB, NB cB, NB
On the first line of the input, the integer NA (1 ≤ NA ≤ 500), the integer NB (1 ≤ NB ≤ 500), and the integer W (1 ≤ W ≤ 10,000) are written separated by blanks. This means that you have a total of NA male cats and a total of NB female cats. W is the limit of the weight of the cat pot.
On the following NA line, the integers mA, i (1 ≤ mA, i ≤ 10,000) and the integers cA, i (1 ≤ cA, i ≤ 1,000,000,000) are written separated by blanks. The integers mA, i and cA, i written on the 1 + i line indicate that the weight of the i-th male cat is mA, i and Cute is cA, i.
On the following NB line, the integers mB, i (1 ≤ mB, i ≤ 10,000) and the integers cB, i (1 ≤ cB, i ≤ 1,000,000,000) are written separated by blanks. The integers mB, i and cB, i written on the 1 + NA + i line indicate that the weight of the i-th female cat is mB, i and Cute is cB, i.
It may be assumed that there is one or more cats weighing W or less in both male and female cats.
Output
Output the minimum UnCute value for the dual cat pot, provided that Mmax does not exceed W. However, both cat pots must contain at least one cat.
Examples
Input
4 3 12
3 6
2 4
7 9
10 1
6 5
8 4
15 19
Output
2
Input
1 3 10
1 15
6 8
5 9
8 7
Output
6
Input
8 6 65
30 98
27 51
4 74
65 87
49 19
27 48
43 7
35 28
43 69
8 47
64 75
18 23
54 29
40 43
Output
8
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(ll (i) = (0);(i) < (n);++i)
#define REV(i,n) for(ll (i) = (n) - 1;(i) >= 0;--i)
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v,n) {REP(WW,n)cerr << v[WW] << ' ';cerr << endl << endl;}
#define SHOW2d(v,WW,HH) {REP(W_,WW){REP(H_,HH)cerr << v[W_][H_] << ' ';cerr << endl;}cerr << endl;}
#define ALL(v) v.begin(),v.end()
#define Decimal fixed<<setprecision(20)
#define INF 1000000000
#define LLINF 1000000000000000000LL
#define MOD 998244353
typedef long long ll;
typedef pair<ll,ll> P;
ll ans = LLINF;
ll dp[2][11111];
void init(){
REP(i, 2)REP(j, 11111)dp[i][j] = -LLINF;
REP(i, 2)dp[i][0] = LLINF;
}
void check(ll c_max, int a, int b, int w){
deque<P> deq;
ll r = 1;
for(ll i = 1;i <= w;i++){
while(r < i)r++;
while(r <= w && (c_max - dp[b][r] > r - i)){
while(!deq.empty() && deq.back().FI < dp[b][r]){
deq.pop_back();
}
if(dp[b][r] != -LLINF)deq.push_back(MP(dp[b][r], r));
r++;
}
while(!deq.empty() && deq.front().SE < i)deq.pop_front();
if(dp[a][i] == -LLINF)continue;
if(!deq.empty()) {
ans = min(ans, c_max - min(dp[a][i], deq.front().FI));
}
if(r <= w && dp[b][r] != -INF){
ans = min(ans, max(r - i, c_max - dp[a][i]));
}
}
}
void query(P cat, ll type, ll w){
REV(i, 11111){
if(i + cat.SE >= 11111)continue;
if(dp[type][i] == -LLINF)continue;
dp[type][i + cat.SE] = max(dp[type][i + cat.SE], min(dp[type][i], cat.FI));
}
check(cat.FI, 0, 1, w);
check(cat.FI, 1, 0, w);
}
int main(){
cin.tie(0);cout.tie(0);ios::sync_with_stdio(false);
init();
ll na, nb, w;cin >> na >> nb >> w;
vector<pair<P, ll>> v;
REP(i, na){
ll m, c;cin >> m >> c;
v.EB(MP(c, m), 0);
}
REP(i, nb){
ll m, c;cin >> m >> c;
v.EB(MP(c, m), 1);
}
sort(ALL(v));
REP(i, v.size()){
query(v[i].FI, v[i].SE, w);
}
cout << ans << endl;
return 0;
}
|
replace replace
Problem Statement
Given the string S. The following processing is performed in the order of Q pieces.
* Replace all the characters c_i contained in S with the character string p_i at the same time.
Finally, output (1-indexed) from the A character to the B character of the character string S.
Constraints
* 1 ≤ Q ≤ 3 \ times 10 ^ 5
* 1 ≤ A ≤ B ≤ 10 ^ {18}
* B-A ≤ 10 ^ 5
* 1 ≤ | S | ≤ 10
* 1 ≤ | p_i | ≤ 10
* S is a character string consisting of lowercase alphabets.
* c_i is one lowercase alphabetic character.
* p_i is a string consisting of one "." (Period) or a lowercase alphabet. When p_i = "." (Period), treat p_i as an empty string.
Input
Input follows the following format. All given numbers are integers.
S
Q A B
c_1 p_1
...
c_Q p_Q
Output
After performing Q processes in order, if B is larger than | S |, output "." (Period) on one line.
In other cases, output (1-indexed) from the A character to the B character of the character string S.
Examples
Input
abaz
3 1 5
a cab
b .
c x
Output
xaxaz
Input
original
1 2 5
x notchange
Output
rigi
Input
aaaa
2 1 1
a .
a nothing
Output
.
|
#include <iostream>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <climits>
#include <algorithm>
#include <cctype>
#include <cstdlib>
using namespace std;
typedef long long LL;
const LL inf = LLONG_MAX / 2;
struct node{
char ch;
LL refcnt;
LL len;
vector<node*> to;
node(char c, LL r = 0, LL len = -1)
: ch(c), refcnt(r), len(len) {}
};
struct state{
int stnum;
node *nd;
LL a, b;
size_t cntr;
state(int s, node *nd, LL a, LL b, size_t c)
: stnum(s), nd(nd), a(a), b(b), cntr(c) {}
};
node *alp[26];
node emp(0, inf, 0);
string ans;
node *getnode(int c){
if(c == '.'){ return &emp; }
node *&ret = alp[c - 'a'];
if(!ret){ ret = new node(c); }
return ret;
}
void delnode(node *nd){
queue<node*> q;
q.push(nd);
while(q.empty()){
nd = q.front();
q.pop();
for(size_t i = 0; i < nd->to.size(); ++i){
node *next = nd->to[i];
if(!--next->refcnt){
q.push(next);
}
}
delete nd;
}
}
void dfs(node *nd0, LL a0, LL b0){
stack<state> stk;
stk.push(state(0, nd0, a0, b0, 0));
while(!stk.empty()){
state &tp = stk.top();
int &num = tp.stnum;
node *&nd = tp.nd;
LL &a = tp.a;
LL &b = tp.b;
size_t &cntr = tp.cntr;
if(num == 0){
if(a >= b){
stk.pop();
continue;
}
if(nd->ch){
nd->len = 1;
if(a == 0){
ans += nd->ch;
}
stk.pop();
continue;
}
if(nd->len >= 0 && nd->len <= a){
stk.pop();
continue;
}
nd->len = 0;
num = 1;
}
else if(num == 1){
if(cntr >= nd->to.size()){
stk.pop();
continue;
}
node *next = nd->to[cntr];
while(next->to.size() == 1){
node *tmp = next;
nd->to[cntr] = next->to[0];
next = next->to[0];
if(--tmp->refcnt){
++next->refcnt;
break;
}
delete tmp;
}
num = 2;
stk.push(state(0, next, a, b, 0));
}
else if(num == 2){
node *next = nd->to[cntr];
LL olen = next->len;
a = max(a - olen, 0LL);
b = max(b - olen, 0LL);
nd->len = min(nd->len + olen, inf);
if(next->len == 0){
nd->to.erase(nd->to.begin() + cntr);
--cntr;
if(!--next->refcnt){
delnode(next);
}
}
++cntr;
num = 1;
}
}
}
int main(){
ios::sync_with_stdio(false);
string s;
LL q, a, b;
char c;
cin >> s >> q >> a >> b;
--a;
node *root = new node(0);
root->to.resize(s.size());
for(size_t i = 0; i < s.size(); ++i){
node *next = getnode(s[i]);
root->to[i] = next;
++next->refcnt;
}
for(LL i = 0; i < q; ++i){
cin >> c >> s;
node *nd = alp[c - 'a'];
if(!nd){ continue; }
alp[c - 'a'] = 0;
nd->ch = 0;
nd->to.resize(s.size());
for(size_t j = 0; j < s.size(); ++j){
node *next = getnode(s[j]);
nd->to[j] = next;
++next->refcnt;
}
}
dfs(root, a, b);
if(ans.size() < b - a){
ans = ".";
}
cout << ans << '\n';
delnode(root);
}
|
Problem statement
We played an AI soccer match between Country A and Country B. You have a table that records the player who had the ball at a certain time and its position. The table consists of N rows, and the i-th row from the top consists of the following elements.
* Number of frames f_i
* The uniform number of the player who has the ball a_i
* The team to which the player belongs t_i
* Coordinates representing the player's position x_i, y_i
The number of frames is an integer that is set to 0 at the start time of the game and is incremented by 1 every 1/60 second. For example, just 1.5 seconds after the game starts, the number of frames is 90. The uniform number is an integer uniquely assigned to 11 players in each team. Furthermore, in two consecutive records in the table, when players with different numbers on the same team have the ball, a "pass" is made between them. Frames that do not exist in the recording need not be considered.
Now, as an engineer, your job is to find the distance of the longest distance (Euclidean distance) between the players of each team and the time it took. If there are multiple paths with the longest distance, output the one with the shortest time.
input
The input is given in the following format. When t_i = 0, it represents country A, and when t_i = 1, it represents country B.
N
f_0 a_0 t_0 x_0 y_0
...
f_ {N−1} a_ {N−1} t_ {N−1} x_ {N−1} y_ {N−1}
Constraint
* All inputs are integers
* 1 \ ≤ N \ ≤ 100
* 0 \ ≤ f_i \ lt f_ {i + 1} \ ≤ 324 \,000
* 1 \ ≤ a_i \ ≤ 11
* t_i = 0,1
* 0 \ ≤ x_i \ ≤ 120
* 0 \ ≤ y_i \ ≤ 90
output
Output the distance and time taken for the longest path in country A and the distance and time taken for the longest path in country B on one line each. Time is in seconds, and absolute errors of 10 ^ {−3} or less are allowed for both distance and time. If the pass has never been made, output -1 for both.
sample
Sample input 1
Five
0 1 0 3 4
30 1 0 3 4
90 2 0 6 8
120 1 1 1 1
132 2 1 2 2
Sample output 1
5.00000000 1.00000000
1.41421356 0.20000000
Country A had a 5 length path at 30 frames and 60 frames = 1 second, and Country B had a √2 length path at 120 frames and 12 frames = 0.2 seconds. These are the longest paths for each.
Sample input 2
2
0 1 0 0 0
10 1 1 0 0
Sample output 2
-1 -1
-1 -1
Sample input 3
3
0 1 0 0 0
30 2 0 1 1
40 1 0 2 2
Sample output 3
1.4142135624 0.1666666667
-1 -1
Sample input 4
3
0 1 0 0 0
10 2 0 1 1
40 1 0 3 3
Sample output 4
2.8284271247 0.5000000000
-1 -1
Example
Input
5
0 1 0 3 4
30 1 0 3 4
90 2 0 6 8
120 1 1 1 1
132 2 1 2 2
Output
5.00000000 1.00000000
1.41421356 0.20000000
|
#define _USE_MATH_DEFINES
#define _CRT_SECURE_NO_DEPRECATE
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <cassert>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
#include <list>
#include <iomanip>
#include <fstream>
#include <iterator>
#include <bitset>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
#define FOR(i,n) for(int i = 0; i < (n); i++)
#define sz(c) ((int)(c).size())
#define ten(x) ((int)1e##x)
#define tenll(x) ((ll)1e##x)
int main(){
int n; cin >> n;
vector<tuple<int, int, int, int, int>> v;
FOR(i, n){
int f, a, t, x, y;
cin >> f >> a >> t >> x >> y;
v.emplace_back(f, a, t, x, y);
}
double ans[2][2];
ans[0][0] = ans[0][1] = ans[1][0] = ans[1][1] = -1;
FOR(i, n - 1){
int pf, pa, pt, px, py;
int f, a, t, x, y;
tie(pf, pa, pt, px, py) = v[i];
tie(f, a, t, x, y) = v[i+1];
if (pt == t && a != pa) {
double nt = sqrt(pow(x - px, 2) + pow(y - py, 2));
if (ans[t][0] <= nt) {
if (abs(ans[t][0] - nt) < 1e-6) {
ans[t][1] = min<double>(ans[t][1], (f - pf) / 60.);
} else {
ans[t][1] = (f - pf)/60.;
}
ans[t][0] = nt;
}
}
}
FOR(i, 2) printf("%.10lf %.10lf\n", ans[i][0], ans[i][1]);
}
|
C: Mod! Mod!
story
That's right! I'm looking for eyewitness testimony! A phantom thief has appeared in Aizu! Everyone's horse stick was stolen! Who is the culprit! ?? Unravel! Mod! Mod!
Problem statement
"Eyes" ... it's a miracle bud that swells in the hearts of the chosen ones ... You can steal anything with the special ability "Eyes".
Aizu Maru, the biggest phantom thief in Aizu, decides to steal a "horse stick" from n detectives in order to fill the world with a mystery. Umauma sticks are just sweets that Maru loves, and each of the n detectives has several horse sticks. Also, because Aizumaru is greedy, when he steals a horse stick from each detective, he steals all the horse sticks that the detective has.
Aizumaru, who is addicted to eating three horse sticks at the same time, when he has three or more horse sticks at hand, he keeps three horse sticks until he loses the temptation and has less than three horse sticks. I will eat it. However, Aizumaru loses his eyes in shock if he does not have a horse stick at hand, and he cannot steal any more horse sticks. In other words, in order to steal a horse horse stick, it is necessary to have one or more horse horse sticks on hand, and when it reaches 0, it becomes impossible to steal any more horse horse sticks.
Aizuma, who wants to steal horse sticks from as many detectives as possible, noticed that the number of detectives who can steal horse sticks depends on which detective steals the horse sticks in order. However, I don't know how difficult it is to get together. "Hate?" Aizumaru's excellent subordinate, you decided to write a program to ask how many detectives you can steal a horse stick instead of Aizumaru.
Since the number of detectives n and how many horse sticks to steal from each of n detectives are given, when stealing horse sticks from detectives in the optimum order, it is possible to steal horse sticks from up to how many detectives. Create a program that outputs what you can do. However, although the number of horse sticks on hand at the beginning is 0, it is assumed that the horse sticks can be stolen even if the number of horse sticks on hand is 0 only at the beginning.
Input format
The input consists of two lines and is given in the following format.
n
a_1 a_2… a_n
The first line is given the integer n, which is the number of detectives stealing horse sticks. On the second line, n number of horse sticks to steal from each detective are given, separated by blanks.
Constraint
* 1 ≤ n ≤ 500 {,} 000
* 1 ≤ a_i ≤ 9 (1 ≤ i ≤ n)
Output format
When you steal a horse stick from a detective in the optimal order, print out in one line how many detectives you can steal a horse stick from.
Input example 1
6
2 5 2 5 2 1
Output example 1
Five
If you steal in the order of 2 5 1 2 5, you can steal from 5 people. No matter what order you steal, you cannot steal from six people.
Input example 2
3
3 6 9
Output example 2
1
No matter which one you steal from, the number of horse sticks you have will be 0 and you will lose your eyes.
Input example 3
6
1 2 3 4 5 6
Output example 3
6
Example
Input
6
2 5 2 5 2 1
Output
5
|
#include "bits/stdc++.h"
using namespace std;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define rer(i,l,u) for(int (i)=(int)(l);(i)<=(int)(u);++(i))
#define reu(i,l,u) for(int (i)=(int)(l);(i)<(int)(u);++(i))
static const int INF = 0x3f3f3f3f; static const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
typedef vector<int> vi; typedef pair<int, int> pii; typedef vector<pair<int, int> > vpii; typedef long long ll;
template<typename T, typename U> static void amin(T &x, U y) { if(y < x) x = y; }
template<typename T, typename U> static void amax(T &x, U y) { if(x < y) x = y; }
int main() {
int n;
while(~scanf("%d", &n)) {
const int K = 3;
vector<int> v[K];
rep(i, n) {
int a;
scanf("%d", &a);
v[a % 3].push_back(a);
}
rep(k, 3)
sort(v[k].begin(), v[k].end());
int ans = 0;
rer(first, 1, 2) if(!v[first].empty()) {
vector<int> rem[3];
rer(k, 1, 2) rem[k] = v[k];
int sum = 1;
rem[first].pop_back();
sum += v[0].size();
int r = first;
while(!rem[r].empty()) {
++ sum;
rem[r].pop_back();
(r += r) %= K;
}
if(!rem[3 - r].empty())
++ sum;
amax(ans, sum);
}
if(!v[0].empty())
amax(ans, 1);
printf("%d\n", ans);
}
return 0;
}
|
problem
I want to put as many rectangular tiles as possible on a rectangular wall with a size of $ h $ in height and $ w $ in width, and a size of $ a $ in height and $ b $ in width.
The following conditions must be met when attaching tiles.
* Do not stack tiles.
* Do not apply tiles diagonally, that is, any edge of the tile is parallel or perpendicular to any edge of the wall.
* Do not change the orientation of the tiles, that is, do not swap the vertical and horizontal directions.
When as many tiles as possible are pasted, find the sum of the areas not covered by the tiles.
output
Output the total area of the part not covered by the tile. Also, output a line break at the end.
Example
Input
5 8
2 2
Output
8
|
h,w=map(int,input().split())
a,b=map(int,input().split())
high=(h//a)*a
wide=(w//b)*b
print(h*w-high*wide)
|
problem
Given $ N $ strings $ S_i $.
Find the maximum number of "AOR" in the string obtained by connecting $ S_i $ in any order.
output
Output the maximum number of "AOR" contained in the character string obtained by connecting $ S_i $ in any order. Also, output a line feed at the end.
Example
Input
2
AORA
OR
Output
2
|
#include <iostream>
#include <string>
using namespace std;
int n;
string s[100005];
int main(void)
{
cin >> n;
for(int i = 1; i <= n; i++) cin >> s[i];
int ans = 0;
for(int i = 1; i <= n; i++){
for(int j = 0; j+2 < s[i].size(); j++){
if(s[i].substr(j, 3) == "AOR") ans++;
}
}
int Ocnt = 0, _A = 0, _AO = 0, R_ = 0, OR_ = 0, R_A = 0, OR_A = 0, R_AO = 0, OR_AO = 0;
for(int i = 1; i <= n; i++){
int l = s[i].size();
if(s[i] == "O") Ocnt++;
if(s[i].substr(l-1, 1) == "A")_A++;
if(l >= 2 && s[i].substr(l-2, 2) == "AO") _AO++;
if(s[i].substr(0, 1) == "R") R_++;
if(l >= 2 && s[i].substr(0, 2) == "OR") OR_++;
if(l >= 2 && s[i].substr(0, 1) == "R" && s[i].substr(l-1, 1) == "A") R_A++;
if(l >= 3 && s[i].substr(0, 2) == "OR" && s[i].substr(l-1, 1) == "A") OR_A++;
if(l >= 3 && s[i].substr(0, 1) == "R" && s[i].substr(l-2, 2) == "AO") R_AO++;
if(l >= 4 && s[i].substr(0, 2) == "OR" && s[i].substr(l-2, 2) == "AO") OR_AO++;
}
int gomi = _A+_AO+R_+OR_ - (R_A+OR_A+R_AO+OR_AO) + Ocnt;
gomi = n - gomi;
int mx = 0;
for(int i = 0; i <= min(Ocnt, _A); i++){
int tmp1 = min(_A-i, OR_);
if(tmp1 && OR_A == _A && OR_A == OR_ && i == 0) tmp1--;
int tmp2 = min(_AO+i, R_);
if(tmp2 && R_AO == _AO && R_AO == R_ && i == 0) tmp2--;
mx = max(mx, tmp1+tmp2);
//cout << tmp1 << " " << tmp2 << endl;
}
if(mx && mx == n-(Ocnt+gomi)) mx--;
ans += mx;
cout << ans << endl;
return 0;
}
|
For a given weighted directed graph G(V, E), find the distance of the shortest route that meets the following criteria:
* It is a closed cycle where it ends at the same point it starts.
* It visits each vertex exactly once.
Constraints
* 2 ≤ |V| ≤ 15
* 0 ≤ di ≤ 1,000
* There are no multiedge
Input
|V| |E|
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1
|V| is the number of vertices and |E| is the number of edges in the graph. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively.
si and ti represent source and target vertices of i-th edge (directed) and di represents the distance between si and ti (the i-th edge).
Output
Print the shortest distance in a line. If there is no solution, print -1.
Examples
Input
4 6
0 1 2
1 2 3
1 3 9
2 0 1
2 3 6
3 2 4
Output
16
Input
3 3
0 1 1
1 2 1
0 2 1
Output
-1
|
import java.util.Map.Entry;
import java.io.*;
import java.util.*;
public class Main {
static int[][] dp;
static int N;
static int[][] graph;
static int INF = 16000;
public static void main(String[] args) throws IOException {
FastScanner sc = new FastScanner(System.in);
N = sc.nextInt();
int M = sc.nextInt();
graph = new int[N][N];
for(int i = 0; i < N; i++) Arrays.fill(graph[i], INF);
for(int i = 0; i < M; i++){
int s = sc.nextInt();
int t = sc.nextInt();
int d = sc.nextInt();
graph[s][t] = d;
}
dp = new int[1 << N][N];
for(int i = 0; i < 1 << N; i++) Arrays.fill(dp[i], -1);
//どこからスタートしても1周分のコストは変わらない
dp[(1 << N) - 1][0] = 0;
int ans = solve(0, 0);
if(ans == INF)
System.out.println(-1);
else
System.out.println(ans);
}
public static int solve(int S, int v){
if(dp[S][v] != -1) return dp[S][v];
int d = INF;
for(int i = 0; i < N; i++){
if(((S >> i) & 1) == 0 && graph[v][i] != INF){
d = Math.min(d, solve((S | 1 << i), i) + graph[v][i]);
}
}
dp[S][v] = d;
return dp[S][v];
}
}
class Pair{
int to;
int dist;
public Pair(int t, int d){
to = t;
dist = d;
}
}
class FastScanner {
private InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
public FastScanner(InputStream in) {
this.in = in;
}
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());
}
}
|
For given integers m and n, compute mn (mod 1,000,000,007). Here, A (mod M) is the remainder when A is divided by M.
Constraints
* 1 ≤ m ≤ 100
* 1 ≤ n ≤ 109
Input
m n
Two integers m and n are given in a line.
Output
Print mn (mod 1,000,000,007) in a line.
Examples
Input
2 3
Output
8
Input
5 8
Output
390625
|
#include<iostream>
#include<cstdio>
using namespace std;
typedef long long LL;
LL mod_pow(LL n, LL m, LL mod) {
LL res = 1;
while (m > 0) {
if (m & 1)
res = res * n % mod;
n = n * n % mod;
m >>= 1;
}
return res;
}
int main()
{
LL n, m;
LL mod = 1000000007;
scanf("%lld %lld", &n, &m);
printf("%d\n", mod_pow(n, m , mod));
return 0;
}
|
Akhil has many balls of white and black colors. One day, he was playing with them. During the play, he arranged the balls into two rows both consisting of N number of balls. These two rows of balls are given to you in the form of strings X, Y. Both these string consist of 'W' and 'B', where 'W' denotes a white colored ball and 'B' a black colored.
Other than these two rows of balls, Akhil has an infinite supply of extra balls of each color. he wants to create another row of N balls, Z in such a way that the sum of hamming distance between X and Z, and hamming distance between Y and Z is maximized.
Hamming Distance between two strings X and Y is defined as the number of positions where the color of balls in row X differs from the row Y ball at that position. e.g. hamming distance between "WBB", "BWB" is 2, as at position 1 and 2, corresponding colors in the two strings differ..
As there can be multiple such arrangements of row Z, Akhil wants you to find the lexicographically smallest arrangement which will maximize the above value.
Input
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows:
First line of each test case will contain a string X denoting the arrangement of balls in first row
Second line will contain the string Y denoting the arrangement of balls in second row.
Output
For each test case, output a single line containing the string of length N denoting the arrangement of colors of the balls belonging to row Z.
Constraints
1 ≤ T ≤ 3
Example
Input:
1
WBWB
WBBB
Output:
BWBW
Explanation
Example case 1. As we know, Hamming Distance(WBWB, BWBW) + Hamming Distance(WBBB, BWBW) = 4 + 3 = 7.
You can try any other value for string Z, it will never exceed 6.
|
testCases = input()
for j in range(testCases):
x = raw_input()
y = raw_input()
N = len(x)
result= ''
for i in range(N):
if x[i]==y[i]:
if x[i] == 'W':
result=result + 'B'
else:
result=result + 'W'
else:
result = result + 'B'
print result
|
Chef is stuck in a two dimensional maze having N rows and M columns. He needs to get out of the maze as soon as possible and arrive at the kitchen in order to serve his hungry customers. But, he can get out of the maze only if he is able to successfully find any magical path in the given maze.
A path is defined as magical if it starts from any of the cell (a,b) of the maze and ends at the cell (c,d) such that the following conditions are satisfied :-
|a - c| + |b - d| = 1
All the cells in the maze are traversed exactly once.
It is allowed to move only in the four directions - up, down, left and right from the current cell.
Input
First line of the input contains an integer T denoting the number of different types of scenarios.
Each of the next T lines will contain two integers N, M denoting the dimensions of the maze.
Output
For each of the T scenarios, output a single line containing "Yes" or "No" (without quotes) denoting whether the Chef can get out of the maze or not.
Constraints
1 ≤ T ≤ 10^5
1 ≤ N, M ≤ 10^18
Example
Input:
1
2 2
Output:
Yes
Explanation
Example case 1.
Chef can start from (1,1), move down to (2,1), then move right to (2,2) and finally move upwards to reach (1,2). As, he is able to visit all the cells exactly once and sum of absolute differences of corresponding x and y dimension is 1, we can call this path a magical path.
|
val=raw_input()
t=int(val)
for i in range(t):
lens=list()
stri=raw_input()
lens=stri.split()
n=int(lens[0])
m=int(lens[1])
if n%2==0 and m%2==1 and m!=1:
print 'Yes'
elif m%2==0 and n%2==1 and n!=1:
print 'Yes'
elif n%2==0 and m%2==0:
print 'Yes'
elif n%2==1 and m%2==1 and n!=1 and m!=1:
print 'No'
elif (n==1 and m==2) or (m==1 and n==2):
print 'Yes'
else:
print 'No'
|
Dilku and Bhopu live in Artland. Dilku loves Bhopu and he writes a message :
“iloveyou”
on paper and wishes to send it to Bhopu. As Dilku is busy making an artwork, he asks his friend Raj to send the message to Bhopu. However Raj has a condition that he may add/remove some characters and jumble the letters of the message.
As Bhopu understands Dilku, she can read “iloveyou” from the message if all the characters of the string “iloveyou” are in the message received by her. Bhopu is happy if she can read “iloveyou” from the message. Otherwise, she is sad. Tell whether Bhopu is happy or sad.
Input
Input contains a string S, where S is the message received by Bhopu. String S consists of only lowercase letters.
Output
Output “happy” if Bhopu is happy and “sad” if Bhopu is sad.
Constraints
1 ≤ |S| ≤ 100
Where |S| denotes length of message string S
Example
Input 1:
iloveyou
Output 1:
happy
Input 2:
ulrvysioqjifo
Output 2:
sad
Input 3:
abcvleouioydef
Output 3:
happy
|
inp,ans,ph=set(raw_input()),['sad','happy'],set('iloveyou')
print ans[len(inp.intersection(ph)) == len(ph)]
|
On a Planet where people are obssessed with Numbers, they have human definitions for relation among Numbers. In one such case, they have designated a father number to be a number formed by the sum of the child number's digits along with the child number itself.
For example, for number 481, (4+8+1+481=)494 is the father.
It is of course evident, every son will have a father, but a person (number) may have any number of children, even zero.
Your task is to write a program to find the smallest child of a given integer, should it exist.
Input
Your first line of input consists of 'K' (1 ≤ K ≤ 50) test cases. The number of test cases 'K' is given in the first line of the input followed by a blank line. Each test case takes one line containing an integer N , (20 ≤ N ≤ 100,000).
Output
The output of your program will print exactly one line for each test case. The line is to contain a child of N for each test case. If X has more than one child, print the smallest. If X, however, does not have any children, print "NONE". The following shows sample input and output for three test cases.
Example
Input:
3
216
121
2005
Output:
198
NONE
1979
|
t=raw_input()
t=int(t)
while t:
t-=1
n=raw_input()
n=int(n)
for i in xrange(1,n):
j=i
sum=i
while j:
sum+=j%10
j/=10
if sum==n:
j=-1
break
if j!=-1:
print "NONE"
else:
print i
|
To protect people from evil,
a long and tall wall was constructed a few years ago.
But just a wall is not safe, there should also be soldiers on it,
always keeping vigil.
The wall is very long and connects the left and the right towers.
There are exactly N spots (numbered 1 to N) on the wall for soldiers.
The K^th spot is K miles far from the left tower and (N+1-K) miles from the right tower.
Given a permutation of spots P of {1, 2, ..., N}, soldiers occupy the N spots in that order.
The P[i]^th spot is occupied before the P[i+1]^th spot.
When a soldier occupies a spot, he is connected to his nearest soldier already placed to his left.
If there is no soldier to his left, he is connected to the left tower. The same is the case with right side.
A connection between two spots requires a wire of length equal to the distance between the two.
The realm has already purchased a wire of M miles long from Nokia,
possibly the wire will be cut into smaller length wires.
As we can observe, the total length of the used wire depends on the permutation of the spots P. Help the realm in minimizing the length of the unused wire. If there is not enough wire, output -1.
Input
First line contains an integer T (number of test cases, 1 ≤ T ≤ 10 ). Each of the next T lines contains two integers N M, as explained in the problem statement (1 ≤ N ≤ 30 , 1 ≤ M ≤ 1000).
Output
For each test case, output the minimum length of the unused wire, or -1 if the the wire is not sufficient.
Example
Input:
4
3 8
3 9
2 4
5 25
Output:
0
0
-1
5
Explanation:
In the 1st case, for example, the permutation P = {2, 1, 3} will use the exact 8 miles wires in total.
In the 2nd case, for example, the permutation P = {1, 3, 2} will use the exact 9 miles wires in total.
To understand the first two cases, you can see the following figures:
In the 3rd case, the minimum length of wire required is 5, for any of the permutations {1,2} or {2,1}, so length 4 is not sufficient.
In the 4th case, for the permutation {1, 2, 3, 4, 5} we need the maximum length of the wire = 20. So minimum possible unused wire length = 25 - 20 = 5.
|
d=[None,(2,2),(5,5),(8,9),(12,14),(16,20),(20,27),(24,35),(29,44),(34,54),(39,65),(44,77),(49,90),(54,104),(59,119),(64,135),(70,152),(76,170),(82,189),(88,209),(94,230),(100,252),(106,275),(112,299),(118,324),(124,350),(130,377),(136,405),(142,434),(148,464),(154,495)]
for i in range(input()):
n,m=map(int,raw_input().split())
x,y=d[n]
if (m>=y):print m-y
elif(m<x):print -1
else:print 0
|
Sereja conducted a voting about N of his opinions. Ai percent of people voted for opinion number i.
This statistics is called valid if sum of all Ai is equal to 100.
Now let us define rounding up of a statistics A.
If Ai is not an integer, it will be rounded up to next integer.
Otherwise it will be left as it is.
e.g. 4.1 became 5, 4.9 became 5 but 6 will still be 6.
Now let us consider a statistics B of size N in which each of Bi is an integer. Now he wants to know whether there exists some valid statistic A of size N (may contain real numbers) such that after rounding it up, it becomes same as B?
Input
First line of input contain integer T - number of test cases.
For each test, case first line contains integer N - number of opinions.
Next line contains N integers B1, B2, ..., BN as defined in the problem.
Output
For each test case, output YES or NO denoting the answer of the problem, i.e. if there exists some statistics A which could be rounded to make it B, print YES otherwise NO.
Constraints
1 ≤ T ≤ 50
1 ≤ N ≤ 10000
0 ≤ Bi ≤ 1000
Sub tasks
Example
Input:
3
3
30 30 30
4
25 25 25 25
2
50 51
Output:
NO
YES
YES
Explanation
In test case 1, There can not be any A which could be rounded up to get B. Hence answer is NO.
In test case 2, In this case A = {25, 25, 25, 25}. After rounding we get {25, 25, 25, 25} which is equal to B. Hence answer is YES.
In test case 3, A = {49.5, 50.5}. After rounding up we get {50, 51} which is equal to B. Hence answer is YES.
|
from pprint import pprint as pp
def GI(): return int(raw_input())
def GIS(): return map(int, raw_input().split())
def main():
T = GI()
for t in xrange(T):
N = GI()
B = GIS()
excess = sum(B) - 100
if excess < 0:
print 'NO'
elif excess < N - B.count(0):
print 'YES'
else:
print 'NO'
main()
|
The heat during the last few days has been really intense. Scientists from all over the Berland study how the temperatures and weather change, and they claim that this summer is abnormally hot. But any scientific claim sounds a lot more reasonable if there are some numbers involved, so they have decided to actually calculate some value which would represent how high the temperatures are.
Mathematicians of Berland State University came up with a special heat intensity value. This value is calculated as follows:
Suppose we want to analyze the segment of n consecutive days. We have measured the temperatures during these n days; the temperature during i-th day equals a_i.
We denote the average temperature of a segment of some consecutive days as the arithmetic mean of the temperature measures during this segment of days. So, if we want to analyze the average temperature from day x to day y, we calculate it as \frac{∑ _{i = x}^{y} a_i}{y - x + 1} (note that division is performed without any rounding). The heat intensity value is the maximum of average temperatures over all segments of not less than k consecutive days. For example, if analyzing the measures [3, 4, 1, 2] and k = 3, we are interested in segments [3, 4, 1], [4, 1, 2] and [3, 4, 1, 2] (we want to find the maximum value of average temperature over these segments).
You have been hired by Berland State University to write a program that would compute the heat intensity value of a given period of days. Are you up to this task?
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 5000) — the number of days in the given period, and the minimum number of days in a segment we consider when calculating heat intensity value, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 5000) — the temperature measures during given n days.
Output
Print one real number — the heat intensity value, i. e., the maximum of average temperatures over all segments of not less than k consecutive days.
Your answer will be considered correct if the following condition holds: |res - res_0| < 10^{-6}, where res is your answer, and res_0 is the answer given by the jury's solution.
Example
Input
4 3
3 4 1 2
Output
2.666666666666667
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const ll INF = 1e18;
template <typename A, typename B>
inline void prt(pair<A, B> p) {
cout << "(" << p.first << ", " << p.second << ")\n";
}
template <typename A, typename B, typename C>
inline void prt(tuple<A, B, C> p) {
cout << "(" << get<0>(p) << ", " << get<1>(p) << ", " << get<2>(p) << ")\n";
}
inline void prt(bool p) {
if (p)
cout << "True" << '\n';
else
cout << "False" << '\n';
}
template <typename T>
inline void prt(vector<T> v) {
cout << '{';
for (ll i = 0; i < v.size(); i++) {
cout << v[i];
if (i < v.size() - 1) cout << ", ";
}
cout << '}' << '\n';
}
template <typename T>
inline void prt(deque<T> v) {
cout << '{';
for (ll i = 0; i < v.size(); i++) {
cout << v[i];
if (i < v.size() - 1) cout << ", ";
}
cout << '}' << '\n';
}
template <typename A, typename B>
inline void prt(map<A, B> v) {
cout << '{';
ll c = 0;
for (auto& p : v) {
cout << p.first << ":" << p.second;
c++;
if (c != v.size()) cout << ", ";
}
cout << '}' << '\n';
}
template <typename A, typename B>
inline void prt(unordered_map<A, B> v) {
cout << '{';
ll c = 0;
for (auto& p : v) {
cout << p.first << ":" << p.second;
c++;
if (c != v.size()) cout << ", ";
}
cout << '}' << '\n';
}
template <typename T>
inline void prt(set<T> v) {
cout << '{';
for (auto i = v.begin(); i != v.end(); i++) {
cout << *i;
if (i != --v.end()) cout << ", ";
}
cout << '}' << '\n';
}
template <typename T>
inline void prt(multiset<T> v) {
cout << '{';
for (auto i = v.begin(); i != v.end(); i++) {
cout << *i;
if (i != --v.end()) cout << ", ";
}
cout << '}' << '\n';
}
int main() {
ll n, k;
cin >> n >> k;
vector<ll> a(n);
for (ll i = 0; i < (n); ++i) cin >> a[i];
vector<ll> r(n + 1, 0);
for (ll i = 0; i < (n); ++i) {
r[i + 1] = r[i] + a[i];
}
double ans = 0;
for (ll i = 0; i < (n); ++i) {
for (int j = i + k; j <= n; j++) {
double now = (r[j] - r[i]) / double(j - i);
chmax(ans, now);
}
}
printf("%.16lf\n", ans);
return 0;
}
|
Medicine faculty of Berland State University has just finished their admission campaign. As usual, about 80\% of applicants are girls and majority of them are going to live in the university dormitory for the next 4 (hopefully) years.
The dormitory consists of n rooms and a single mouse! Girls decided to set mouse traps in some rooms to get rid of the horrible monster. Setting a trap in room number i costs c_i burles. Rooms are numbered from 1 to n.
Mouse doesn't sit in place all the time, it constantly runs. If it is in room i in second t then it will run to room a_i in second t + 1 without visiting any other rooms inbetween (i = a_i means that mouse won't leave room i). It's second 0 in the start. If the mouse is in some room with a mouse trap in it, then the mouse get caught into this trap.
That would have been so easy if the girls actually knew where the mouse at. Unfortunately, that's not the case, mouse can be in any room from 1 to n at second 0.
What it the minimal total amount of burles girls can spend to set the traps in order to guarantee that the mouse will eventually be caught no matter the room it started from?
Input
The first line contains as single integers n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of rooms in the dormitory.
The second line contains n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 10^4) — c_i is the cost of setting the trap in room number i.
The third line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — a_i is the room the mouse will run to the next second after being in room i.
Output
Print a single integer — the minimal total amount of burles girls can spend to set the traps in order to guarantee that the mouse will eventually be caught no matter the room it started from.
Examples
Input
5
1 2 3 2 10
1 3 4 3 3
Output
3
Input
4
1 10 2 10
2 4 2 2
Output
10
Input
7
1 1 1 1 1 1 1
2 2 2 3 6 7 6
Output
2
Note
In the first example it is enough to set mouse trap in rooms 1 and 4. If mouse starts in room 1 then it gets caught immideately. If mouse starts in any other room then it eventually comes to room 4.
In the second example it is enough to set mouse trap in room 2. If mouse starts in room 2 then it gets caught immideately. If mouse starts in any other room then it runs to room 2 in second 1.
Here are the paths of the mouse from different starts from the third example:
* 1 → 2 → 2 → ...;
* 2 → 2 → ...;
* 3 → 2 → 2 → ...;
* 4 → 3 → 2 → 2 → ...;
* 5 → 6 → 7 → 6 → ...;
* 6 → 7 → 6 → ...;
* 7 → 6 → 7 → ...;
So it's enough to set traps in rooms 2 and 6.
|
#include <bits/stdc++.h>
using namespace std;
inline void prep() {
cin.tie(0);
cin.sync_with_stdio(0);
};
const int mod = (int)1e9 + 7;
const int MX = (int)2e5 + 20;
int mn[MX];
vector<int> g[MX], comp_g[MX];
int pre[MX];
int low[MX];
int id[MX];
stack<int> stk;
int cntr, scc;
void tarjan(int x) {
if (pre[x] != -1) return;
stk.push(x);
pre[x] = cntr++;
low[x] = pre[x];
for (auto& y : g[x]) {
if (pre[y] == -1) tarjan(y);
low[x] = min(low[x], low[y]);
}
if (pre[x] == low[x]) {
while (true) {
int y = stk.top();
stk.pop();
low[y] = MX;
id[y] = scc;
if (y == x) break;
}
scc++;
}
}
int main() {
prep();
int n;
cin >> n;
int c[n];
for (int i = 0; i < n; ++i) {
cin >> c[i];
mn[i] = (int)2e9;
}
for (int i = 0, x; i < n; ++i) {
cin >> x;
g[i].push_back(--x);
}
memset(pre, 0xff, sizeof pre);
memset(id, 0xff, sizeof id);
for (int i = 0; i < n; ++i) {
tarjan(i);
}
for (int i = 0; i < n; ++i) {
mn[id[i]] = min(mn[id[i]], c[i]);
}
for (int i = 0; i < n; ++i) {
for (auto& x : g[i]) {
if (id[x] != id[i]) comp_g[id[i]].push_back(id[x]);
}
}
int res = 0;
for (int i = 0; i < scc; ++i) {
if (comp_g[i].size() == 0) res += mn[i];
}
cout << res << '\n';
return 0;
}
|
Formula 1 officials decided to introduce new competition. Cars are replaced by space ships and number of points awarded can differ per race.
Given the current ranking in the competition and points distribution for the next race, your task is to calculate the best possible ranking for a given astronaut after the next race. It's guaranteed that given astronaut will have unique number of points before the race.
Input
The first line contains two integer numbers N (1 ≤ N ≤ 200000) representing number of F1 astronauts, and current position of astronaut D (1 ≤ D ≤ N) you want to calculate best ranking for (no other competitor will have the same number of points before the race).
The second line contains N integer numbers S_k (0 ≤ S_k ≤ 10^8, k=1...N), separated by a single space, representing current ranking of astronauts. Points are sorted in non-increasing order.
The third line contains N integer numbers P_k (0 ≤ P_k ≤ 10^8, k=1...N), separated by a single space, representing point awards for the next race. Points are sorted in non-increasing order, so winner of the race gets the maximum number of points.
Output
Output contains one integer number — the best possible ranking for astronaut after the race. If multiple astronauts have the same score after the race, they all share the best ranking.
Example
Input
4 3
50 30 20 10
15 10 7 3
Output
2
Note
If the third ranked astronaut wins the race, he will have 35 points. He cannot take the leading position, but he can overtake the second position if the second ranked astronaut finishes the race at the last position.
|
import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
import static java.lang.Math.*;
import static java.util.Comparator.reverseOrder;
public class SpaceFormula implements Closeable {
private InputReader in = new InputReader(System.in);
private PrintWriter out = new PrintWriter(System.out);
public void solve() {
int n = in.ni(), d = in.ni();
int[] points = new int[n + 1];
for (int i = 1; i <= n; i++) {
points[i] = in.ni();
}
int[] awards = new int[n + 1];
for (int i = 0; i < n; i++) {
awards[i + 1] = in.ni();
}
int pos = 1;
points[d] += awards[1];
PriorityQueue<Integer> less = new PriorityQueue<>(reverseOrder());
for (int i = 1; i <= d - 1; i++) {
if (points[i] <= points[d]) {
less.add(points[i]);
} else {
pos++;
}
}
int idx = n;
while (!less.isEmpty()) {
int top = less.poll();
if (top + awards[idx--] > points[d]) {
pos++;
}
}
out.println(pos);
}
@Override
public void close() throws IOException {
in.close();
out.close();
}
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 ni() {
return Integer.parseInt(next());
}
public long nl() {
return Long.parseLong(next());
}
public void close() throws IOException {
reader.close();
}
}
public static void main(String[] args) throws IOException {
try (SpaceFormula instance = new SpaceFormula()) {
instance.solve();
}
}
}
|
Berkomnadzor — Federal Service for Supervision of Communications, Information Technology and Mass Media — is a Berland federal executive body that protects ordinary residents of Berland from the threats of modern internet.
Berkomnadzor maintains a list of prohibited IPv4 subnets (blacklist) and a list of allowed IPv4 subnets (whitelist). All Internet Service Providers (ISPs) in Berland must configure the network equipment to block access to all IPv4 addresses matching the blacklist. Also ISPs must provide access (that is, do not block) to all IPv4 addresses matching the whitelist. If an IPv4 address does not match either of those lists, it's up to the ISP to decide whether to block it or not. An IPv4 address matches the blacklist (whitelist) if and only if it matches some subnet from the blacklist (whitelist). An IPv4 address can belong to a whitelist and to a blacklist at the same time, this situation leads to a contradiction (see no solution case in the output description).
An IPv4 address is a 32-bit unsigned integer written in the form a.b.c.d, where each of the values a,b,c,d is called an octet and is an integer from 0 to 255 written in decimal notation. For example, IPv4 address 192.168.0.1 can be converted to a 32-bit number using the following expression 192 ⋅ 2^{24} + 168 ⋅ 2^{16} + 0 ⋅ 2^8 + 1 ⋅ 2^0. First octet a encodes the most significant (leftmost) 8 bits, the octets b and c — the following blocks of 8 bits (in this order), and the octet d encodes the least significant (rightmost) 8 bits.
The IPv4 network in Berland is slightly different from the rest of the world. There are no reserved or internal addresses in Berland and use all 2^{32} possible values.
An IPv4 subnet is represented either as a.b.c.d or as a.b.c.d/x (where 0 ≤ x ≤ 32). A subnet a.b.c.d contains a single address a.b.c.d. A subnet a.b.c.d/x contains all IPv4 addresses with x leftmost (most significant) bits equal to x leftmost bits of the address a.b.c.d. It is required that 32 - x rightmost (least significant) bits of subnet a.b.c.d/x are zeroes.
Naturally it happens that all addresses matching subnet a.b.c.d/x form a continuous range. The range starts with address a.b.c.d (its rightmost 32 - x bits are zeroes). The range ends with address which x leftmost bits equal to x leftmost bits of address a.b.c.d, and its 32 - x rightmost bits are all ones. Subnet contains exactly 2^{32-x} addresses. Subnet a.b.c.d/32 contains exactly one address and can also be represented by just a.b.c.d.
For example subnet 192.168.0.0/24 contains range of 256 addresses. 192.168.0.0 is the first address of the range, and 192.168.0.255 is the last one.
Berkomnadzor's engineers have devised a plan to improve performance of Berland's global network. Instead of maintaining both whitelist and blacklist they want to build only a single optimised blacklist containing minimal number of subnets. The idea is to block all IPv4 addresses matching the optimised blacklist and allow all the rest addresses. Of course, IPv4 addresses from the old blacklist must remain blocked and all IPv4 addresses from the old whitelist must still be allowed. Those IPv4 addresses which matched neither the old blacklist nor the old whitelist may be either blocked or allowed regardless of their accessibility before.
Please write a program which takes blacklist and whitelist as input and produces optimised blacklist. The optimised blacklist must contain the minimal possible number of subnets and satisfy all IPv4 addresses accessibility requirements mentioned above.
IPv4 subnets in the source lists may intersect arbitrarily. Please output a single number -1 if some IPv4 address matches both source whitelist and blacklist.
Input
The first line of the input contains single integer n (1 ≤ n ≤ 2⋅10^5) — total number of IPv4 subnets in the input.
The following n lines contain IPv4 subnets. Each line starts with either '-' or '+' sign, which indicates if the subnet belongs to the blacklist or to the whitelist correspondingly. It is followed, without any spaces, by the IPv4 subnet in a.b.c.d or a.b.c.d/x format (0 ≤ x ≤ 32). The blacklist always contains at least one subnet.
All of the IPv4 subnets given in the input are valid. Integer numbers do not start with extra leading zeroes. The provided IPv4 subnets can intersect arbitrarily.
Output
Output -1, if there is an IPv4 address that matches both the whitelist and the blacklist. Otherwise output t — the length of the optimised blacklist, followed by t subnets, with each subnet on a new line. Subnets may be printed in arbitrary order. All addresses matching the source blacklist must match the optimised blacklist. All addresses matching the source whitelist must not match the optimised blacklist. You can print a subnet a.b.c.d/32 in any of two ways: as a.b.c.d/32 or as a.b.c.d.
If there is more than one solution, output any.
Examples
Input
1
-149.154.167.99
Output
1
0.0.0.0/0
Input
4
-149.154.167.99
+149.154.167.100/30
+149.154.167.128/25
-149.154.167.120/29
Output
2
149.154.167.99
149.154.167.120/29
Input
5
-127.0.0.4/31
+127.0.0.8
+127.0.0.0/30
-195.82.146.208/29
-127.0.0.6/31
Output
2
195.0.0.0/8
127.0.0.4/30
Input
2
+127.0.0.1/32
-127.0.0.1
Output
-1
|
#include <bits/stdc++.h>
using namespace std;
class TrieNode {
public:
bool postive, leaf;
TrieNode *zero, *one;
TrieNode() {
postive = leaf = 0;
zero = one = NULL;
}
};
void add(string &s, int idx, bool postive, TrieNode *cur) {
cur->postive |= postive;
if (idx == s.size()) {
cur->leaf = 1;
return;
}
if (s[idx] == '1') {
if (cur->one == NULL) cur->one = new TrieNode();
add(s, idx + 1, postive, cur->one);
} else {
if (cur->zero == NULL) cur->zero = new TrieNode();
add(s, idx + 1, postive, cur->zero);
}
if (cur->one != NULL && cur->zero != NULL && cur->one->leaf &&
cur->zero->leaf) {
cur->leaf = 1;
}
}
bool search(string &s, int idx, bool postive, TrieNode *cur) {
if (cur->leaf) return 1;
if (idx == s.size()) return postive;
if (s[idx] == '1') {
if (cur->one == NULL) return 0;
return search(s, idx + 1, postive, cur->one);
} else {
if (cur->zero == NULL) return 0;
return search(s, idx + 1, postive, cur->zero);
}
}
vector<string> ips;
void solve(string &s, TrieNode *cur) {
if (!cur->postive) {
ips.push_back(s);
return;
}
if (cur->zero != NULL) {
s += '0';
solve(s, cur->zero);
s.pop_back();
}
if (cur->one != NULL) {
s += '1';
solve(s, cur->one);
s.pop_back();
}
}
string to_binary(int num) {
string ret;
while (num != 0) {
ret += (num % 2) + '0';
num /= 2;
}
while (ret.size() < 8) ret += '0';
reverse(ret.begin(), ret.end());
return ret;
}
string convert(string s) {
int bs = -1;
vector<int> sub;
int cur = 0;
for (int i = 1; i < s.size(); i++) {
if (s[i] == 47) {
bs = i;
break;
}
if (s[i] == '.') {
sub.push_back(cur);
cur = 0;
} else {
cur *= 10;
cur += (s[i] - '0');
}
}
sub.push_back(cur);
string ret;
for (auto &x : sub) ret += to_binary(x);
if (bs != -1) {
cur = 0;
for (int i = bs + 1; i < s.size(); i++) {
cur *= 10;
cur += s[i] - '0';
}
ret = ret.substr(0, cur);
}
return ret;
}
string to_number(string s) {
int mul = 1;
int ret = 0;
for (int i = s.size() - 1; i >= 0; i--) {
ret += mul * (s[i] - '0');
mul *= 2;
}
string ret2;
if (ret == 0) ret2 = "0";
while (ret != 0) {
ret2 += (ret % 10) + '0';
ret /= 10;
}
reverse(ret2.begin(), ret2.end());
return ret2;
}
string tostring(int number) {
if (number == 0) return "0";
string ret;
while (number != 0) {
ret += (number % 10) + '0';
number /= 10;
}
reverse(ret.begin(), ret.end());
return ret;
}
void to_ip() {
for (auto &s : ips) {
string cur = s;
int r = s.size();
while (cur.size() < 32) cur += '0';
s = "";
for (int i = 0; i < 32; i += 8) {
string sub = cur.substr(i, 8);
if (i) s += '.';
s += to_number(sub);
}
s += 47;
s += tostring(r);
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
TrieNode *root = new TrieNode();
vector<string> black, white;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s[0] == '-')
black.push_back(s);
else
white.push_back(s);
}
for (auto &x : black) {
string cur = convert(x);
if (!search(cur, 0, 0, root)) add(cur, 0, 0, root);
}
for (auto &x : white) {
string cur = convert(x);
if (search(cur, 0, 1, root)) {
cout << -1;
return 0;
}
}
for (auto &x : white) {
string cur = convert(x);
if (!search(cur, 0, 1, root)) add(cur, 0, 1, root);
}
string s;
solve(s, root);
to_ip();
cout << ips.size() << '\n';
for (auto &x : ips) cout << x << '\n';
}
|
Bob is a duck. He wants to get to Alice's nest, so that those two can duck!
<image> Duck is the ultimate animal! (Image courtesy of See Bang)
The journey can be represented as a straight line, consisting of n segments. Bob is located to the left of the first segment, while Alice's nest is on the right of the last segment. Each segment has a length in meters, and also terrain type: grass, water or lava.
Bob has three movement types: swimming, walking and flying. He can switch between them or change his direction at any point in time (even when he is located at a non-integer coordinate), and doing so doesn't require any extra time. Bob can swim only on the water, walk only on the grass and fly over any terrain. Flying one meter takes 1 second, swimming one meter takes 3 seconds, and finally walking one meter takes 5 seconds.
Bob has a finite amount of energy, called stamina. Swimming and walking is relaxing for him, so he gains 1 stamina for every meter he walks or swims. On the other hand, flying is quite tiring, and he spends 1 stamina for every meter flown. Staying in place does not influence his stamina at all. Of course, his stamina can never become negative. Initially, his stamina is zero.
What is the shortest possible time in which he can reach Alice's nest?
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of segments of terrain.
The second line contains n integers l_1, l_2, ..., l_n (1 ≤ l_i ≤ 10^{12}). The l_i represents the length of the i-th terrain segment in meters.
The third line contains a string s consisting of n characters "G", "W", "L", representing Grass, Water and Lava, respectively.
It is guaranteed that the first segment is not Lava.
Output
Output a single integer t — the minimum time Bob needs to reach Alice.
Examples
Input
1
10
G
Output
30
Input
2
10 10
WL
Output
40
Input
2
1 2
WL
Output
8
Input
3
10 10 10
GLW
Output
80
Note
In the first sample, Bob first walks 5 meters in 25 seconds. Then he flies the remaining 5 meters in 5 seconds.
In the second sample, Bob first swims 10 meters in 30 seconds. Then he flies over the patch of lava for 10 seconds.
In the third sample, the water pond is much smaller. Bob first swims over the water pond, taking him 3 seconds. However, he cannot fly over the lava just yet, as he only has one stamina while he needs two. So he swims back for half a meter, and then half a meter forward, taking him 3 seconds in total. Now he has 2 stamina, so he can spend 2 seconds flying over the lava.
In the fourth sample, he walks for 50 seconds, flies for 10 seconds, swims for 15 seconds, and finally flies for 5 seconds.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t n;
cin >> n;
vector<int64_t> a(n), water(n, 0), land(n, 0);
int64_t time = 0;
for (int64_t i = 0; i < n; i++) {
cin >> a[i];
a[i] *= 4;
time += a[i];
}
string s__;
cin >> s__;
for (int64_t i = 0; i < n; i++) {
water[i] = ((s__[i] == 'W') ? a[i] : 0);
land[i] = ((s__[i] == 'G') ? a[i] : 0);
if (i != 0) {
water[i] += water[i - 1];
land[i] += land[i - 1];
}
}
int64_t timePlus = 0;
int64_t usedWater = 0;
int64_t usedLand = 0;
for (int64_t i = 0; i < n; i++) {
int64_t avaWater = water[i] - usedWater;
int64_t avaLand = land[i] - usedLand;
int64_t need = a[i] / 2;
if (avaWater >= need) {
usedWater += need;
timePlus += need * 2;
} else {
need -= avaWater;
usedWater += avaWater;
timePlus += avaWater * 2;
if (avaLand >= need) {
usedLand += need;
timePlus += need * 4;
} else {
need -= avaLand;
usedLand += avaLand;
timePlus += avaLand * 4;
if (water[i] > 0)
timePlus += (need * 2) * 3;
else
timePlus += (need * 2) * 5;
}
}
}
cout << (timePlus + time) / 4;
return 0;
}
|
You are playing a game of Jongmah. You don't need to know the rules to solve this problem. You have n tiles in your hand. Each tile has an integer between 1 and m written on it.
To win the game, you will need to form some number of triples. Each triple consists of three tiles, such that the numbers written on the tiles are either all the same or consecutive. For example, 7, 7, 7 is a valid triple, and so is 12, 13, 14, but 2,2,3 or 2,4,6 are not. You can only use the tiles in your hand to form triples. Each tile can be used in at most one triple.
To determine how close you are to the win, you want to know the maximum number of triples you can form from the tiles in your hand.
Input
The first line contains two integers integer n and m (1 ≤ n, m ≤ 10^6) — the number of tiles in your hand and the number of tiles types.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ m), where a_i denotes the number written on the i-th tile.
Output
Print one integer: the maximum number of triples you can form.
Examples
Input
10 6
2 3 3 3 4 4 4 5 5 6
Output
3
Input
12 6
1 5 3 3 3 4 3 5 3 2 3 3
Output
3
Input
13 5
1 1 5 1 2 3 3 2 4 2 3 4 5
Output
4
Note
In the first example, we have tiles 2, 3, 3, 3, 4, 4, 4, 5, 5, 6. We can form three triples in the following way: 2, 3, 4; 3, 4, 5; 4, 5, 6. Since there are only 10 tiles, there is no way we could form 4 triples, so the answer is 3.
In the second example, we have tiles 1, 2, 3 (7 times), 4, 5 (2 times). We can form 3 triples as follows: 1, 2, 3; 3, 3, 3; 3, 4, 5. One can show that forming 4 triples is not possible.
|
#include <bits/stdc++.h>
using namespace std;
int a[1000005], dp[1000005][3][3];
const int inf = 0x3f3f3f3f;
int main() {
int n, m, d;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &d), a[d]++;
for (int i = 0; i <= m + 1; i++)
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++) dp[i][j][k] = -inf;
dp[1][0][0] = 0;
for (int i = 1; i <= m; i++)
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++)
for (int l = 0; l < 3; l++)
if (j + k + l <= a[i])
dp[i + 1][j][k] = max(dp[i + 1][j][k],
dp[i][k][l] + l + (a[i] - (j + k + l)) / 3);
cout << dp[m + 1][0][0] << endl;
return 0;
}
|
Ivan recently bought a detective book. The book is so interesting that each page of this book introduces some sort of a mystery, which will be explained later. The i-th page contains some mystery that will be explained on page a_i (a_i ≥ i).
Ivan wants to read the whole book. Each day, he reads the first page he didn't read earlier, and continues to read the following pages one by one, until all the mysteries he read about are explained and clear to him (Ivan stops if there does not exist any page i such that Ivan already has read it, but hasn't read page a_i). After that, he closes the book and continues to read it on the following day from the next page.
How many days will it take to read the whole book?
Input
The first line contains single integer n (1 ≤ n ≤ 10^4) — the number of pages in the book.
The second line contains n integers a_1, a_2, ..., a_n (i ≤ a_i ≤ n), where a_i is the number of page which contains the explanation of the mystery on page i.
Output
Print one integer — the number of days it will take to read the whole book.
Example
Input
9
1 3 3 6 7 6 8 8 9
Output
4
Note
Explanation of the example test:
During the first day Ivan will read only the first page. During the second day Ivan will read pages number 2 and 3. During the third day — pages 4-8. During the fourth (and the last) day Ivan will read remaining page number 9.
|
import sys
#p = [[] for i in range(N)]
#for i in range(N):
# p[i] += map(int, sys.stdin.readline().split())
#Q = input()
#for i in range(Q):
# print(list(map(int, sys.stdin.readline().split())))
n = int(input())
a = [int(c) for c in sys.stdin.readline().split()]
aktmax, d = 0, 0
for i, c in enumerate(a, start=1):
aktmax = max(aktmax, c)
if aktmax <= i:
d += 1
print(d)
|
It is an interactive problem.
Vasya enjoys solving quizzes. He found a strange device and wants to know how it works.
This device encrypted with the tree (connected undirected graph without cycles) with n vertices, numbered with integers from 1 to n. To solve this quiz you should guess this tree.
Fortunately, this device can make one operation, using which you should guess the cipher. You can give the device an array d_1, d_2, …, d_n of non-negative integers. On the device, there are n lamps, i-th of them is connected with i-th vertex of the tree. For all i the light will turn on the i-th lamp, if there exist such vertex of the tree with number j ≠ i that dist(i, j) ≤ d_j. Let's define dist(i, j) as the distance between vertices i and j in tree or number of edges on the simple path between vertices i and j.
Vasya wants to solve this quiz using ≤ 80 operations with the device and guess the tree. Help him!
Interaction
In the beginning, your program should read one integer n — the number of vertices of the tree which encrypts the device (2 ≤ n ≤ 1000).
After that, you can make several operations in the following format. To do operation print a symbol"?" (without quotes) and n integers d_1, d_2, …, d_n, separated by spaces after it. Please note, that for all i you can only use the numbers, satisfying the inequality 0 ≤ d_i < n. After that, you should read a string s with length n, consisting of symbols "0" and "1" (without quotes). For all i the symbol s_i is equal to "0", if the lamp on the device, connected with i-th vertex of the tree is switched off and "1" otherwise.
After several operations, you should print guessed tree. To do it print the only symbol "!" (without quotes). In the next n-1 lines print 2 integers a_i, b_i — indexes of the vertices connected by i-th edge of the tree. This numbers should satisfy the conditions 1 ≤ a_i, b_i ≤ n and a_i ≠ b_i. This edges should form a tree, which is equal to the hidden tree. After that, your program should terminate.
It is guaranteed, that in each test the tree is fixed before and won't change depending on your program's operations.
Your program can make from 0 to 80 operations with the device and after that guess the tree equal with the hidden.
If your program will make more than 80 operations it can get any verdict, because it will continue reading from closed input. If your program will make operation or print the answer in the incorrect format, it can get any verdict too. Be careful.
Don't forget to flush the output after printing questions and answers.
To flush the output, you can use:
* fflush(stdout) in C++.
* System.out.flush() in Java.
* stdout.flush() in Python.
* flush(output) in Pascal.
* See the documentation for other languages.
Hacks:
The first line should contain one integer n — the number of vertices in the tree (2 ≤ n ≤ 1000). Next n-1 lines should contain 2 integers a_i, b_i — indexes of the vertices connected by i-th edge of the tree (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i). All edges should form a tree. Be careful, extra spaces or line breaks are not allowed.
Example
Input
5
00000
11011
11100
10010
Output
? 0 0 0 0 0
? 1 1 2 0 2
? 0 0 0 1 0
? 0 1 0 0 1
!
4 2
1 5
3 4
4 1
Note
It is a picture of the tree which encrypt the device from the first test:
<image>
It is a table of pairwise distances between vertices in this tree:
<image>
* If you make operation where d = [0, 0, 0, 0, 0], no lamp will switch on, because dist(i, j) > 0 for all i ≠ j.
* If you make operation where d = [1, 1, 2, 0, 2], all lamps except the lamp connected with the 3-rd vertex will switch on. For example, lamp connected with the 1-st vertex will switch on, because dist(1, 5) = 1 ≤ 2 = d_5.
* If you make operation where d = [0, 0, 0, 1, 0], all lamps except lamps connected with the 4-th and 5-th vertices will switch on.
* If you make operation where d = [0, 1, 0, 0, 1], only lamps connected with the 1-st and 4-th vertices will switch on.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1100;
struct Edge {
int to, next;
} edge[N * 2];
int head[N], num;
void add_edge(int a, int b) { edge[++num] = (Edge){b, head[a]}, head[a] = num; }
int n, q[N], a[N], a0[N], ccc;
char s[N];
void dfs(int x, int d, int f, int ff) {
if (x != ff) a[x] = 1;
if (!d) return;
for (int i = head[x]; i; i = edge[i].next)
if (edge[i].to != f) dfs(edge[i].to, d - 1, x, ff);
}
void wen() {
printf("? ");
for (int i = 1; i <= n; i++) printf("%d ", min(q[i], n - 1));
printf("\n");
fflush(stdout);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) a[i] = s[i] - '0';
}
bool vis[N], vv[N];
vector<int> t[N], tt[N], nt[N], td[3];
int st[N], dep[N], ea[N], ce;
pair<int, int> ee[N];
int main() {
scanf("%d", &n);
t[0].push_back(1);
for (int i = 1; i <= n; i++) tt[0].push_back(i);
int cnt = n - 1;
vis[0] = vis[1022] = vv[1] = true;
int la;
while (cnt) {
if (la == 20) break;
la++;
int top = 0;
for (int i = 0; i <= 1022; i++)
if (vis[i]) st[++top] = i;
for (int i = 1; i <= top - 1; i++)
if ((i & 1) && tt[st[i]].size()) {
int tmp = (st[i + 1] - st[i]) / 2;
vis[st[i] + tmp] = true;
for (int j = 0; j <= t[st[i]].size() - 1; j++) q[t[st[i]][j]] = tmp;
}
wen();
for (int i = 1; i <= n; i++) {
a0[i] = a[i];
if (q[i]) q[i]--;
}
wen();
memset(q, 0, sizeof(q));
for (int i = 1; i <= top - 1; i++)
if ((i & 1) && tt[st[i]].size()) {
int tmp = (st[i + 1] - st[i]) / 2;
for (int j = 0; j <= tt[st[i]].size() - 1; j++) {
if (vv[tt[st[i]][j]] || a[tt[st[i]][j]])
nt[st[i]].push_back(tt[st[i]][j]);
else
nt[st[i] + tmp].push_back(tt[st[i]][j]);
if (!vv[tt[st[i]][j]] && a0[tt[st[i]][j]] && !a[tt[st[i]][j]])
cnt--, vv[tt[st[i]][j]] = true,
t[st[i] + tmp].push_back(tt[st[i]][j]);
}
}
for (int i = 1; i <= top - 1; i++)
if (!(i & 1) && tt[st[i]].size()) {
int tmp = (st[i + 1] - st[i]) / 2;
vis[st[i] + tmp] = true;
for (int j = 0; j <= t[st[i]].size() - 1; j++) q[t[st[i]][j]] = tmp;
}
wen();
for (int i = 1; i <= n; i++) {
a0[i] = a[i];
if (q[i]) q[i]--;
}
wen();
memset(q, 0, sizeof(q));
for (int i = 1; i <= top - 1; i++)
if (!(i & 1) && tt[st[i]].size()) {
int tmp = (st[i + 1] - st[i]) / 2;
for (int j = 0; j <= tt[st[i]].size() - 1; j++) {
if (vv[tt[st[i]][j]] || a[tt[st[i]][j]])
nt[st[i]].push_back(tt[st[i]][j]);
else
nt[st[i] + tmp].push_back(tt[st[i]][j]);
if (!vv[tt[st[i]][j]] && a0[tt[st[i]][j]] && !a[tt[st[i]][j]])
cnt--, vv[tt[st[i]][j]] = true,
t[st[i] + tmp].push_back(tt[st[i]][j]);
}
}
for (int i = 0; i <= n; i++) {
tt[i] = nt[i];
nt[i].clear();
}
}
for (int i = 0; i <= n; i++)
if (t[i].size())
for (int j = 0; j <= t[i].size() - 1; j++) {
dep[t[i][j]] = i, td[i % 3].push_back(t[i][j]);
}
for (int i = 0; i <= 2; i++)
if (td[i].size()) {
for (int j = 1; j <= 10; j++) {
for (int k = 0; k <= td[i].size() - 1; k++)
if (td[i][k] & (1 << (j - 1))) q[td[i][k]] = 1;
wen();
memset(q, 0, sizeof(q));
for (int k = 1; k <= n; k++)
if (a[k] && dep[k] % 3 == (i + 1) % 3) ea[k] |= (1 << (j - 1));
}
for (int j = 1; j <= n; j++)
if (dep[j] % 3 == (i + 1) % 3 && ea[j]) ee[++ce] = make_pair(ea[j], j);
}
printf("!\n");
for (int i = 1; i <= n - 1; i++) {
printf("%d %d", ee[i].first, ee[i].second);
if (i != n - 1) printf("\n");
}
return 0;
}
|
This morning Tolik has understood that while he was sleeping he had invented an incredible problem which will be a perfect fit for Codeforces! But, as a "Discuss tasks" project hasn't been born yet (in English, well), he decides to test a problem and asks his uncle.
After a long time thinking, Tolik's uncle hasn't any ideas on how to solve it. But, he doesn't want to tell Tolik about his inability to solve it, so he hasn't found anything better than asking you how to solve this task.
In this task you are given a cell field n ⋅ m, consisting of n rows and m columns, where point's coordinates (x, y) mean it is situated in the x-th row and y-th column, considering numeration from one (1 ≤ x ≤ n, 1 ≤ y ≤ m). Initially, you stand in the cell (1, 1). Every move you can jump from cell (x, y), which you stand in, by any non-zero vector (dx, dy), thus you will stand in the (x+dx, y+dy) cell. Obviously, you can't leave the field, but also there is one more important condition — you're not allowed to use one vector twice. Your task is to visit each cell of the field exactly once (the initial cell is considered as already visited).
Tolik's uncle is a very respectful person. Help him to solve this task!
Input
The first and only line contains two positive integers n, m (1 ≤ n ⋅ m ≤ 10^{6}) — the number of rows and columns of the field respectively.
Output
Print "-1" (without quotes) if it is impossible to visit every cell exactly once.
Else print n ⋅ m pairs of integers, i-th from them should contain two integers x_i, y_i (1 ≤ x_i ≤ n, 1 ≤ y_i ≤ m) — cells of the field in order of visiting, so that all of them are distinct and vectors of jumps between them are distinct too.
Notice that the first cell should have (1, 1) coordinates, according to the statement.
Examples
Input
2 3
Output
1 1
1 3
1 2
2 2
2 3
2 1
Input
1 1
Output
1 1
Note
The vectors from the first example in the order of making jumps are (0, 2), (0, -1), (1, 0), (0, 1), (0, -2).
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long a = 0, b = 0, c, d, e, f = 0, l, g, m, n, k, i, j, t, p, q;
cin >> m >> n;
for (i = 1; i <= n / 2; i++) {
for (j = 1; j <= m; j++) {
cout << j << ' ' << i << '\n';
cout << m - j + 1 << ' ' << n - i + 1 << '\n';
}
}
if (n % 2) {
d = n / 2 + 1;
for (i = 1; i <= m / 2; i++) {
cout << i << ' ' << d << '\n';
cout << m - i + 1 << ' ' << d << '\n';
}
if (m % 2) {
cout << m / 2 + 1 << ' ' << d << '\n';
}
}
return 0;
}
|
There is a country with n citizens. The i-th of them initially has a_{i} money. The government strictly controls the wealth of its citizens. Whenever a citizen makes a purchase or earns some money, they must send a receipt to the social services mentioning the amount of money they currently have.
Sometimes the government makes payouts to the poor: all citizens who have strictly less money than x are paid accordingly so that after the payout they have exactly x money. In this case the citizens don't send a receipt.
You know the initial wealth of every citizen and the log of all events: receipts and payouts. Restore the amount of money each citizen has after all events.
Input
The first line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the numer of citizens.
The next line contains n integers a_1, a_2, ..., a_n (0 ≤ a_{i} ≤ 10^{9}) — the initial balances of citizens.
The next line contains a single integer q (1 ≤ q ≤ 2 ⋅ 10^{5}) — the number of events.
Each of the next q lines contains a single event. The events are given in chronological order.
Each event is described as either 1 p x (1 ≤ p ≤ n, 0 ≤ x ≤ 10^{9}), or 2 x (0 ≤ x ≤ 10^{9}). In the first case we have a receipt that the balance of the p-th person becomes equal to x. In the second case we have a payoff with parameter x.
Output
Print n integers — the balances of all citizens after all events.
Examples
Input
4
1 2 3 4
3
2 3
1 2 2
2 1
Output
3 2 3 4
Input
5
3 50 2 1 10
3
1 2 0
2 8
1 3 20
Output
8 8 20 8 10
Note
In the first example the balances change as follows: 1 2 3 4 → 3 3 3 4 → 3 2 3 4 → 3 2 3 4
In the second example the balances change as follows: 3 50 2 1 10 → 3 0 2 1 10 → 8 8 8 8 10 → 8 8 20 8 10
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class payoff {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
Reader.init(System.in);
int n = Reader.nextInt();
int[] arr = new int[n];
int[] posmax = new int[n];
for(int i=0;i<n;i++) {
arr[i]=Reader.nextInt();
}
int q = Reader.nextInt();
int[] maxv= new int[q];
for(int i=0;i<q;i++) {
int a = Reader.nextInt();
if(a==1) {
int b = Reader.nextInt();
int c = Reader.nextInt();
arr[b-1]=c;
posmax[b-1]=i;
}
else {
int b = Reader.nextInt();
maxv[i]=b;
}
}
for(int i=maxv.length-2;i>=0;i--) {
maxv[i]=Math.max(maxv[i], maxv[i+1]);
}
for(int i=0;i<n;i++) {
System.out.print(Math.max(arr[i], maxv[posmax[i]])+" ");
}
}
}
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(
new InputStreamReader(input) );
tokenizer = new StringTokenizer("");
}
/** get next word */
static String next() throws IOException {
while ( ! tokenizer.hasMoreTokens() ) {
//TODO add check for eof if necessary
tokenizer = new StringTokenizer(
reader.readLine() );
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt( next() );
}
static double nextDouble() throws IOException {
return Double.parseDouble( next() );
}
static long nextLong() throws IOException {
return Long.parseLong( next() );
}
}
|
There is a white sheet of paper lying on a rectangle table. The sheet is a rectangle with its sides parallel to the sides of the table. If you will take a look from above and assume that the bottom left corner of the table has coordinates (0, 0), and coordinate axes are left and bottom sides of the table, then the bottom left corner of the white sheet has coordinates (x_1, y_1), and the top right — (x_2, y_2).
After that two black sheets of paper are placed on the table. Sides of both black sheets are also parallel to the sides of the table. Coordinates of the bottom left corner of the first black sheet are (x_3, y_3), and the top right — (x_4, y_4). Coordinates of the bottom left corner of the second black sheet are (x_5, y_5), and the top right — (x_6, y_6).
<image> Example of three rectangles.
Determine if some part of the white sheet can be seen from the above after the two black sheets are placed. The part of the white sheet can be seen if there is at least one point lying not strictly inside the white sheet and strictly outside of both black sheets.
Input
The first line of the input contains four integers x_1, y_1, x_2, y_2 (0 ≤ x_1 < x_2 ≤ 10^{6}, 0 ≤ y_1 < y_2 ≤ 10^{6}) — coordinates of the bottom left and the top right corners of the white sheet.
The second line of the input contains four integers x_3, y_3, x_4, y_4 (0 ≤ x_3 < x_4 ≤ 10^{6}, 0 ≤ y_3 < y_4 ≤ 10^{6}) — coordinates of the bottom left and the top right corners of the first black sheet.
The third line of the input contains four integers x_5, y_5, x_6, y_6 (0 ≤ x_5 < x_6 ≤ 10^{6}, 0 ≤ y_5 < y_6 ≤ 10^{6}) — coordinates of the bottom left and the top right corners of the second black sheet.
The sides of each sheet of paper are parallel (perpendicular) to the coordinate axes.
Output
If some part of the white sheet can be seen from the above after the two black sheets are placed, print "YES" (without quotes). Otherwise print "NO".
Examples
Input
2 2 4 4
1 1 3 5
3 1 5 5
Output
NO
Input
3 3 7 5
0 0 4 6
0 0 7 4
Output
YES
Input
5 2 10 5
3 1 7 6
8 1 11 7
Output
YES
Input
0 0 1000000 1000000
0 0 499999 1000000
500000 0 1000000 1000000
Output
YES
Note
In the first example the white sheet is fully covered by black sheets.
In the second example the part of the white sheet can be seen after two black sheets are placed. For example, the point (6.5, 4.5) lies not strictly inside the white sheet and lies strictly outside of both black sheets.
|
a=list(map(int,input().split()))
x1,y1,x2,y2=a[0],a[1],a[2],a[3]
a=list(map(int,input().split()))
x3,y3,x4,y4=a[0],a[1],a[2],a[3]
a=list(map(int,input().split()))
x5,y5,x6,y6=a[0],a[1],a[2],a[3]
l1=l2=l3=l4=1
if (x1>=x5 and x2<=x6 and y1>=y5 and y1<=y6) or (x1>=x3 and x2<=x4 and y1>=y3 and y1<=y4) or (y1>=y5 and y1<=y6 and y1>=y3 and y1<=y4 and x1>=min(x3,x5) and x2<=max(x4,x6) and x4>=x5 and x3<=x6):
l1=0
if (y1>=y5 and y2<=y6 and x1>=x5 and x1<=x6) or (y1>=y3 and y2<=y4 and x1>=x3 and x1<=x4) or (x1>=x5 and x1<=x6 and x1>=x3 and x1<=x4 and y1>=min(y3,y5) and y2<=max(y4,y6) and y4>=y5 and y3<=y6):
l2=0
if (x1>=x5 and x2<=x6 and y2>=y5 and y2<=y6) or (x1>=x3 and x2<=x4 and y2>=y3 and y2<=y4) or (y2>=y5 and y2<=y6 and y2>=y3 and y2<=y4 and x1>=min(x3,x5) and x2<=max(x4,x6) and x4>=x5 and x3<=x6):
l3=0
if (y1>=y5 and y2<=y6 and x2>=x5 and x2<=x6) or (y1>=y3 and y2<=y4 and x2>=x3 and x2<=x4) or (x2>=x5 and x2<=x6 and x2>=x3 and x2<=x4 and y1>=min(y3,y5) and y2<=max(y4,y6) and y4>=y5 and y3<=y6):
l4=0
if l1 or l2 or l3 or l4: print('YES')
else: print('NO')
|
In the Catowice city next weekend the cat contest will be held. However, the jury members and the contestants haven't been selected yet. There are n residents and n cats in the Catowice, and each resident has exactly one cat living in his house. The residents and cats are numbered with integers from 1 to n, where the i-th cat is living in the house of i-th resident.
Each Catowice resident is in friendship with several cats, including the one living in his house. In order to conduct a contest, at least one jury member is needed and at least one cat contestant is needed. Of course, every jury member should know none of the contestants. For the contest to be successful, it's also needed that the number of jury members plus the number of contestants is equal to n.
Please help Catowice residents to select the jury and the contestants for the upcoming competition, or determine that it's impossible to do.
Input
The first line contains an integer t (1 ≤ t ≤ 100 000), the number of test cases. Then description of t test cases follow, where each description is as follows:
The first line contains integers n and m (1 ≤ n ≤ m ≤ 10^6), the number of Catowice residents and the number of friendship pairs between residents and cats.
Each of the next m lines contains integers a_i and b_i (1 ≤ a_i, b_i ≤ n), denoting that a_i-th resident is acquaintances with b_i-th cat. It's guaranteed that each pair of some resident and some cat is listed at most once.
It's guaranteed, that for every i there exists a pair between i-th resident and i-th cat.
Different test cases are separated with an empty line.
It's guaranteed, that the sum of n over all test cases is at most 10^6 and that the sum of m over all test cases is at most 10^6.
Output
For every test case print:
* "No", if it's impossible to select the jury and contestants.
* Otherwise print "Yes".
In the second line print two integers j and p (1 ≤ j, 1 ≤ p, j + p = n) — the number of jury members and the number of contest participants.
In the third line print j distinct integers from 1 to n, the indices of the residents forming a jury.
In the fourth line print p distinct integers from 1 to n, the indices of the cats, which will participate in the contest.
In case there are several correct answers, print any of them.
Example
Input
4
3 4
1 1
2 2
3 3
1 3
3 7
1 1
1 2
1 3
2 2
3 1
3 2
3 3
1 1
1 1
2 4
1 1
1 2
2 1
2 2
Output
Yes
2 1
1 3
2
Yes
1 2
2
1 3
No
No
Note
In the first test case, we can select the first and the third resident as a jury. Both of them are not acquaintances with a second cat, so we can select it as a contestant.
In the second test case, we can select the second resident as a jury. He is not an acquaintances with a first and a third cat, so they can be selected as contestants.
In the third test case, the only resident is acquaintances with the only cat, so they can't be in the contest together. So it's not possible to make a contest with at least one jury and at least one cat.
In the fourth test case, each resident is acquaintances with every cat, so it's again not possible to make a contest with at least one jury and at least one cat.
|
#include <bits/stdc++.h>
using namespace std;
int t;
int n, m;
vector<int> adj[1000005];
vector<int> adj_r[1000005];
bool use[1000005];
bool use_r[1000005];
vector<int> ans;
void dfs(int node, stack<int> &s) {
use[node] = 1;
for (auto it : adj[node]) {
if (use[it] == 0) {
dfs(it, s);
}
}
s.push(node);
return;
}
void dfs_r(int node, stack<int> &sr) {
use_r[node] = 1;
for (auto it : adj_r[node]) {
if (use_r[it] == 0) {
dfs_r(it, sr);
}
}
sr.push(node);
return;
}
void init(int n) {
memset(use, 0, sizeof(bool) * n);
memset(use_r, 0, sizeof(bool) * n);
ans.clear();
for (int i = 0; i < n; i++) {
adj[i].clear();
adj_r[i].clear();
}
return;
}
int main() {
scanf("%d", &t);
for (int i = 0; i < t; i++) {
scanf("%d%d", &n, &m);
for (int j = 0; j < m; j++) {
int jm, cm;
scanf("%d%d", &jm, &cm);
if (jm == cm) continue;
adj[jm].push_back(cm);
adj_r[cm].push_back(jm);
}
stack<int> s;
dfs(1, s);
if (s.size() < n) {
int ss = s.size();
for (int j = 0; j < ss; j++) {
ans.push_back(s.top());
s.pop();
}
printf("Yes\n");
printf("%d %d\n", ans.size(), n - ans.size());
sort(ans.begin(), ans.end());
for (int j = 0; j < ans.size(); j++) {
printf("%d ", ans[j]);
}
printf("\n");
for (int j = 1; j <= n; j++) {
if (use[j] == 0) printf("%d ", j);
}
printf("\n");
init(n + 1);
continue;
}
int count = 0;
unordered_set<int> off;
for (int j = 0; j < n; j++) {
int idx = s.top();
s.pop();
if (use_r[idx]) continue;
stack<int> sr;
dfs_r(idx, sr);
if (sr.size() == n) {
printf("No\n");
init(n + 1);
break;
} else {
count += sr.size();
if (count == n) {
int ssr = sr.size();
for (int k = 0; k < ssr; k++) {
ans.push_back(sr.top());
off.insert(sr.top());
sr.pop();
}
sort(ans.begin(), ans.end());
printf("Yes\n");
printf("%d %d\n", ans.size(), n - ans.size());
for (int j = 0; j < ans.size(); j++) {
printf("%d ", ans[j]);
}
printf("\n");
for (int j = 1; j <= n; j++) {
if (off.find(j) == off.end()) {
printf("%d ", j);
}
}
printf("\n");
init(n + 1);
break;
}
}
}
}
return 0;
}
|
Let's call two numbers similar if their binary representations contain the same number of digits equal to 1. For example:
* 2 and 4 are similar (binary representations are 10 and 100);
* 1337 and 4213 are similar (binary representations are 10100111001 and 1000001110101);
* 3 and 2 are not similar (binary representations are 11 and 10);
* 42 and 13 are similar (binary representations are 101010 and 1101).
You are given an array of n integers a_1, a_2, ..., a_n. You may choose a non-negative integer x, and then get another array of n integers b_1, b_2, ..., b_n, where b_i = a_i ⊕ x (⊕ denotes bitwise XOR).
Is it possible to obtain an array b where all numbers are similar to each other?
Input
The first line contains one integer n (2 ≤ n ≤ 100).
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 2^{30} - 1).
Output
If it is impossible to choose x so that all elements in the resulting array are similar to each other, print one integer -1.
Otherwise, print any non-negative integer not exceeding 2^{30} - 1 that can be used as x so that all elements in the resulting array are similar.
Examples
Input
2
7 2
Output
1
Input
4
3 17 6 0
Output
5
Input
3
1 2 3
Output
-1
Input
3
43 12 12
Output
1073709057
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 123;
int a[maxn], b[maxn];
int vis[maxn];
int n;
struct P {
int a[101];
bool operator<(const P &t) const {
for (int i = 0; i < n; i++) {
if (a[i] != t.a[i]) return a[i] < t.a[i];
}
return false;
}
};
P t;
map<P, int> m;
int main() {
cin >> n;
int tmp = (1 << 15) - 1;
for (int i = 0; i < n; i++)
scanf("%d", a + i), b[i] = a[i] >> 15, a[i] = a[i] & tmp;
for (int i = 0; i <= tmp; i++) {
int mx = 34;
for (int j = 0; j < n; j++) {
t.a[j] = __builtin_popcount(a[j] ^ i);
mx = min(mx, t.a[j]);
}
for (int j = 0; j < n; j++) t.a[j] -= mx;
m[t] = i;
}
for (int i = 0; i <= tmp; i++) {
int mx = 0;
for (int j = 0; j < n; j++) {
t.a[j] = __builtin_popcount(b[j] ^ i);
mx = max(mx, t.a[j]);
}
for (int j = 0; j < n; j++) t.a[j] = mx - t.a[j];
if (m.count(t) != 0) return 0 * printf("%d", m[t] + (i << 15));
}
printf("-1");
}
|
We just discovered a new data structure in our research group: a suffix three!
It's very useful for natural language processing. Given three languages and three suffixes, a suffix three can determine which language a sentence is written in.
It's super simple, 100% accurate, and doesn't involve advanced machine learning algorithms.
Let us tell you how it works.
* If a sentence ends with "po" the language is Filipino.
* If a sentence ends with "desu" or "masu" the language is Japanese.
* If a sentence ends with "mnida" the language is Korean.
Given this, we need you to implement a suffix three that can differentiate Filipino, Japanese, and Korean.
Oh, did I say three suffixes? I meant four.
Input
The first line of input contains a single integer t (1 ≤ t ≤ 30) denoting the number of test cases. The next lines contain descriptions of the test cases.
Each test case consists of a single line containing a single string denoting the sentence. Spaces are represented as underscores (the symbol "_") for ease of reading. The sentence has at least 1 and at most 1000 characters, and consists only of lowercase English letters and underscores. The sentence has no leading or trailing underscores and no two consecutive underscores. It is guaranteed that the sentence ends with one of the four suffixes mentioned above.
Output
For each test case, print a single line containing either "FILIPINO", "JAPANESE", or "KOREAN" (all in uppercase, without quotes), depending on the detected language.
Example
Input
8
kamusta_po
genki_desu
ohayou_gozaimasu
annyeong_hashimnida
hajime_no_ippo
bensamu_no_sentou_houhou_ga_okama_kenpo
ang_halaman_doon_ay_sarisari_singkamasu
si_roy_mustang_ay_namamasu
Output
FILIPINO
JAPANESE
JAPANESE
KOREAN
FILIPINO
FILIPINO
JAPANESE
JAPANESE
Note
The first sentence ends with "po", so it is written in Filipino.
The second and third sentences end with "desu" and "masu", so they are written in Japanese.
The fourth sentence ends with "mnida", so it is written in Korean.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n--) {
string s;
cin >> s;
int i = 0, count = 0;
while (s[i] != '\0') {
count++;
i++;
}
if (s[count - 2] == 's' && s[count - 1] == 'u') cout << "JAPANESE" << endl;
if (s[count - 2] == 'p' && s[count - 1] == 'o') cout << "FILIPINO" << endl;
if (s[count - 2] == 'd' && s[count - 1] == 'a') cout << "KOREAN" << endl;
}
}
|
You are given three strings a, b and c of the same length n. The strings consist of lowercase English letters only. The i-th letter of a is a_i, the i-th letter of b is b_i, the i-th letter of c is c_i.
For every i (1 ≤ i ≤ n) you must swap (i.e. exchange) c_i with either a_i or b_i. So in total you'll perform exactly n swap operations, each of them either c_i ↔ a_i or c_i ↔ b_i (i iterates over all integers between 1 and n, inclusive).
For example, if a is "code", b is "true", and c is "help", you can make c equal to "crue" taking the 1-st and the 4-th letters from a and the others from b. In this way a becomes "hodp" and b becomes "tele".
Is it possible that after these swaps the string a becomes exactly the same as the string b?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a string of lowercase English letters a.
The second line of each test case contains a string of lowercase English letters b.
The third line of each test case contains a string of lowercase English letters c.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding 100.
Output
Print t lines with answers for all test cases. For each test case:
If it is possible to make string a equal to string b print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
Example
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
Note
In the first test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
In the second test case, you should swap c_i with a_i for all possible i. After the swaps a becomes "bca", b becomes "bca" and c becomes "abc". Here the strings a and b are equal.
In the third test case, you should swap c_1 with a_1, c_2 with b_2, c_3 with b_3 and c_4 with a_4. Then string a becomes "baba", string b becomes "baba" and string c becomes "abab". Here the strings a and b are equal.
In the fourth test case, it is impossible to do the swaps so that string a becomes exactly the same as string b.
|
t = int(input())
for T in range(t):
a = input()
b = input()
c = input()
n = len(a)
count = 0
for i in range(n):
if a[i] == c[i] or b[i] == c[i]:
count += 1
if count == n:
print("YES")
else:
print("NO")
|
You are given a positive integer x. Find any such 2 positive integers a and b such that GCD(a,b)+LCM(a,b)=x.
As a reminder, GCD(a,b) is the greatest integer that divides both a and b. Similarly, LCM(a,b) is the smallest integer such that both a and b divide it.
It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Each testcase consists of one line containing a single integer, x (2 ≤ x ≤ 10^9).
Output
For each testcase, output a pair of positive integers a and b (1 ≤ a, b ≤ 10^9) such that GCD(a,b)+LCM(a,b)=x. It's guaranteed that the solution always exists. If there are several such pairs (a, b), you can output any of them.
Example
Input
2
2
14
Output
1 1
6 4
Note
In the first testcase of the sample, GCD(1,1)+LCM(1,1)=1+1=2.
In the second testcase of the sample, GCD(6,4)+LCM(6,4)=2+12=14.
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class EhAbAndGCD {
public static void main(String argv[]) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int test = Integer.parseInt(br.readLine());
while(test-- > 0) {
int x = Integer.parseInt(br.readLine());
if(x%2==0) {
System.out.println(x/2+" "+ x/2);
} else {
int a=x-1, b = 1;
System.out.println(a+" "+ b);
}
}
}
}
|
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1
|
#include <bits/stdc++.h>
using namespace std;
long long int solver(long long int x, vector<set<long long int> > &v,
long long int n) {
long long int idx = -1, i;
for (i = 0; i < n - 1; i++) {
if (v[i].find(x) != v[i].end()) v[i].erase(x);
if ((long long int)v[i].size() == 1) {
if (idx == -1)
idx = i;
else
return -1;
}
}
return idx;
}
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, i, j, k, l;
cin >> n;
vector<long long int> v[n - 1];
for (i = 0; i < n - 1; i++) {
long long int k;
cin >> k;
for (j = 0; j < k; j++) {
long long int y;
cin >> y;
v[i].push_back(y);
}
}
for (i = 1; i <= n; i++) {
vector<long long int> ans;
vector<set<long long int> > s(n - 1);
for (j = 0; j < n - 1; j++) {
long long int si = v[j].size();
for (k = 0; k < si; k++) s[j].insert(v[j][k]);
}
long long int crr = i;
for (j = 0; j < n; j++) {
ans.push_back(crr);
if (j < n - 1) {
long long int tt = solver(crr, s, n);
if (tt == -1) {
break;
} else {
crr = *s[tt].begin();
}
}
}
if (j != n) continue;
vector<long long int> used(n - 1, 0);
for (j = 1; j < n; j++) {
set<long long int> temp;
temp.insert(ans[j]);
for (k = j - 1; k >= 0; k--) {
temp.insert(ans[k]);
for (l = 0; l < n - 1; l++) {
if (used[l] == 0) {
long long int si_v = v[l].size();
if (si_v == (j - k + 1)) {
set<long long int>::iterator it;
long long int xx = 0;
for (it = temp.begin(); it != temp.end(); it++, xx++) {
if (v[l][xx] != *it) break;
}
if (it == temp.end()) {
used[l] = 1;
break;
}
}
}
}
if (l != n - 1) {
break;
}
}
if (k != -1)
continue;
else {
break;
}
}
if (j != n)
continue;
else {
for (j = 0; j < n; j++) cout << ans[j] << " ";
cout << "\n";
break;
}
}
}
}
|
This is an interactive problem.
Ayush devised yet another scheme to set the password of his lock. The lock has n slots where each slot can hold any non-negative integer. The password P is a sequence of n integers, i-th element of which goes into the i-th slot of the lock.
To set the password, Ayush comes up with an array A of n integers each in the range [0, 2^{63}-1]. He then sets the i-th element of P as the [bitwise OR](https://en.wikipedia.org/wiki/Bitwise_operation#OR) of all integers in the array except A_i.
You need to guess the password. To make a query, you can choose a non-empty subset of indices of the array and ask the bitwise OR all elements of the array with index in this subset. You can ask no more than 13 queries.
Input
The first line of input contains one integer n (2 ≤ n ≤ 1000) — the number of slots in the lock.
Interaction
To ask a query print a single line:
* In the beginning print "? c " (without quotes) where c (1 ≤ c ≤ n) denotes the size of the subset of indices being queried, followed by c distinct space-separated integers in the range [1, n].
For each query, you will receive an integer x — the bitwise OR of values in the array among all the indices queried. If the subset of indices queried is invalid or you exceeded the number of queries then you will get x = -1. In this case, you should terminate the program immediately.
When you have guessed the password, print a single line "! " (without quotes), followed by n space-separated integers — the password sequence.
Guessing the password does not count towards the number of queries asked.
The interactor is not adaptive. The array A does not change with queries.
After printing a query do not forget to output the end of the 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 the documentation for other languages.
Hacks
To hack the solution, use the following test format:
On the first line print a single integer n (2 ≤ n ≤ 1000) — the number of slots in the lock. The next line should contain n space-separated integers in the range [0, 2^{63} - 1] — the array A.
Example
Input
3
1
2
4
Output
? 1 1
? 1 2
? 1 3
! 6 5 3
Note
The array A in the example is \{{1, 2, 4\}}. The first element of the password is bitwise OR of A_2 and A_3, the second element is bitwise OR of A_1 and A_3 and the third element is bitwise OR of A_1 and A_2. Hence the password sequence is \{{6, 5, 3\}}.
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 1 << 10;
int n;
int bitcnt[MX * 10], mp[MX * 10];
int ass[MX * 10], acnt;
long long ret[MX];
int main() {
cin >> n;
for (int i = 1; i < (1 << 13); ++i) {
bitcnt[i] = 1 + bitcnt[i - (i & -i)];
if (bitcnt[i] == 6) ass[++acnt] = i;
}
for (int i = 1; i <= n; ++i) mp[ass[i]] = i;
for (int i = 0; i < 13; ++i) {
int cnt = 0;
for (int j = 1; j <= n; ++j) {
if (((ass[j] >> i) & 1) == 0) {
++cnt;
}
}
if (!cnt) continue;
cout << "? " << cnt << " ";
for (int j = 1; j <= n; ++j) {
if (((ass[j] >> i) & 1) == 0) {
cout << j << " ";
}
}
cout << endl;
cin >> ret[i];
}
cout << "! ";
for (int i = 1; i <= n; ++i) {
long long Ans = 0;
for (int j = 0; j < 13; ++j) {
if ((ass[i] >> j) & 1) {
Ans |= ret[j];
}
}
cout << Ans << " ";
}
cout << endl;
}
|
You are given a table a of size 2 × n (i.e. two rows and n columns) consisting of integers from 1 to n.
In one move, you can choose some column j (1 ≤ j ≤ n) and swap values a_{1, j} and a_{2, j} in it. Each column can be chosen no more than once.
Your task is to find the minimum number of moves required to obtain permutations of size n in both first and second rows of the table or determine if it is impossible to do that.
You have to answer t independent test cases.
Recall that the permutation of size n is such an array of size n that contains each integer from 1 to n exactly once (the order of elements doesn't matter).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of columns in the table. The second line of the test case contains n integers a_{1, 1}, a_{1, 2}, ..., a_{1, n} (1 ≤ a_{1, i} ≤ n), where a_{1, i} is the i-th element of the first row of the table. The third line of the test case contains n integers a_{2, 1}, a_{2, 2}, ..., a_{2, n} (1 ≤ a_{2, i} ≤ n), where a_{2, i} is the i-th element of the second row of the table.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case print the answer: -1 if it is impossible to obtain permutation of size n in both first and the second rows of the table, or one integer k in the first line, where k is the minimum number of moves required to obtain permutations in both rows, and k distinct integers pos_1, pos_2, ..., pos_k in the second line (1 ≤ pos_i ≤ n) in any order — indices of columns in which you need to swap values to obtain permutations in both rows. If there are several answers, you can print any.
Example
Input
6
4
1 2 3 4
2 3 1 4
5
5 3 5 1 4
1 2 3 2 4
3
1 2 1
3 3 2
4
1 2 2 1
3 4 3 4
4
4 3 1 4
3 2 2 1
3
1 1 2
3 2 2
Output
0
2
2 3
1
1
2
3 4
2
3 4
-1
|
#include <bits/stdc++.h>
using namespace std;
long long mo(long long a) { return a % (long long)(1e9 + 7); }
long long po(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y >>= 1;
x = (x * x) % p;
}
return res % p;
}
vector<vector<pair<long long, long long>>> g;
vector<long long> vis, col;
vector<vector<long long>> ty;
void dfs(long long par, long long anc = -1, long long type = -1) {
if (anc == -1) {
col[par] = 0;
ty[col[par]].push_back(par);
} else {
if (type) {
col[par] = !col[anc];
ty[col[par]].push_back(par);
} else {
col[par] = col[anc];
ty[col[par]].push_back(par);
}
}
vis[par] = 1;
for (pair<long long, long long> e : g[par]) {
if (!vis[e.first]) {
dfs(e.first, par, e.second);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<vector<long long>> r(n, vector<long long>(2, -1)),
c(n, vector<long long>(2, -1));
for (long long i = 0; i < 2; i++) {
for (long long j = 0; j < n; j++) {
long long x;
cin >> x;
x--;
if (r[x][0] == -1)
r[x][0] = i;
else
r[x][1] = i;
if (c[x][0] == -1)
c[x][0] = j;
else
c[x][1] = j;
}
}
long long pos = 1;
for (long long i = 0; i < n; i++) {
if (r[i][0] == -1 || r[i][1] == -1) pos = 0;
}
if (!pos) {
cout << -1 << "\n";
continue;
}
g.assign(n, {});
vis.assign(n, 0);
col.assign(n, -1);
ty.assign(2, {});
for (long long i = 0; i < n; i++) {
if (r[i][0] == r[i][1] && c[i][0] != c[i][1]) {
g[c[i][0]].push_back({c[i][1], 1});
g[c[i][1]].push_back({c[i][0], 1});
}
if (r[i][0] != r[i][1] && c[i][0] != c[i][1]) {
g[c[i][1]].push_back({c[i][0], 0});
g[c[i][0]].push_back({c[i][1], 0});
}
}
vector<long long> ans;
for (long long i = 0; i < n; i++) {
if (!vis[i]) {
ty[0].clear();
ty[1].clear();
dfs(i);
if (ty[0].size() > ty[1].size()) swap(ty[0], ty[1]);
for (long long e : ty[0]) ans.push_back(e);
}
}
cout << ans.size() << "\n";
for (long long e : ans) cout << e + 1 << " ";
cout << "\n";
}
return 0;
}
|
Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.
There are n cities in the republic, some of them are connected by m directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city 1, travel to the city n by roads along some path, give a concert and fly away.
As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads — in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from 1 to n, and for security reasons it has to be the shortest possible.
Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from 1 to n or the shortest path's length would be greatest possible.
A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only.
The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.
Input
The first line contains two integers n, m (1 ≤ n ≤ 500000, 0 ≤ m ≤ 500000) — the number of cities and the number of roads.
The i-th of next m lines contains three integers — u_i, v_i and t_i (1 ≤ u_i, v_i ≤ n, t_i ∈ \{0, 1\}) — numbers of cities connected by road and its type, respectively (0 — night road, 1 — morning road).
Output
In the first line output the length of the desired path (or -1, if it's possible to choose such schedule that there's no path from 1 to n).
In the second line output the desired schedule — a string of n digits, where i-th digit is 0, if the i-th city is a night one, and 1 if it's a morning one.
If there are multiple answers, print any.
Examples
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1
Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1
Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0
Output
-1
11111
Note
For the first sample, if we paint city 1 white, the shortest path is 1 → 3. Otherwise, it's 1 → 2 → 3 regardless of other cities' colors.
For the second sample, we should paint city 3 black, and there are both black and white roads going from 2 to 4. Note that there can be a road connecting a city with itself.
|
//make sure to make new file!
import java.io.*;
import java.util.*;
public class E669{
public static void main(String[] args)throws IOException{
BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
StringTokenizer st = new StringTokenizer(f.readLine());
int n = Integer.parseInt(st.nextToken());
int m = Integer.parseInt(st.nextToken());
ArrayList<ArrayList<Edge>> adj = new ArrayList<ArrayList<Edge>>(n+1);
for(int k = 0; k <= n; k++) adj.add(new ArrayList<Edge>());
for(int k = 0; k < m; k++){
st = new StringTokenizer(f.readLine());
int a = Integer.parseInt(st.nextToken());
int b = Integer.parseInt(st.nextToken());
int i = Integer.parseInt(st.nextToken());
if(a == b) continue;
adj.get(b).add(new Edge(a,i)); //put the edge in backwards
}
int[] answer = new int[n+1];
Arrays.fill(answer,-1);
int[] dists = new int[n+1];
Arrays.fill(dists,Integer.MAX_VALUE);
Queue<Integer> q = new LinkedList<Integer>();
HashSet<Integer> seen = new HashSet<Integer>();
q.add(n);
seen.add(n);
dists[n] = 0;
while(!q.isEmpty()){
int v = q.poll();
for(Edge e : adj.get(v)){
if(answer[e.to] == e.i){
if(dists[e.to] > dists[v]+1){
q.add(e.to);
dists[e.to] = dists[v]+1;
}
} else if(answer[e.to] == -1){
answer[e.to] = 1-e.i;
}
}
}
if(dists[1] == Integer.MAX_VALUE){
out.println(-1);
} else {
out.println(dists[1]);
}
StringJoiner sj = new StringJoiner("");
for(int k = 1; k <= n; k++){
if(answer[k] == -1){
sj.add("0");
} else {
sj.add("" + answer[k]);
}
}
out.println(sj.toString());
out.close();
}
public static class Edge{
int to;
int i;
public Edge(int a, int b){
to = a;
i = b;
}
}
}
|
Zookeeper is playing a game. In this game, Zookeeper must use bombs to bomb a string that consists of letters 'A' and 'B'. He can use bombs to bomb a substring which is either "AB" or "BB". When he bombs such a substring, the substring gets deleted from the string and the remaining parts of the string get concatenated.
For example, Zookeeper can use two such operations: AABABBA → AABBA → AAA.
Zookeeper wonders what the shortest string he can make is. Can you help him find the length of the shortest string?
Input
Each test contains multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 20000) — the number of test cases. The description of the test cases follows.
Each of the next t lines contains a single test case each, consisting of a non-empty string s: the string that Zookeeper needs to bomb. It is guaranteed that all symbols of s are either 'A' or 'B'.
It is guaranteed that the sum of |s| (length of s) among all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print a single integer: the length of the shortest string that Zookeeper can make.
Example
Input
3
AAA
BABA
AABBBABBBB
Output
3
2
0
Note
For the first test case, you can't make any moves, so the answer is 3.
For the second test case, one optimal sequence of moves is BABA → BA. So, the answer is 2.
For the third test case, one optimal sequence of moves is AABBBABBBB → AABBBABB → AABBBB → ABBB → AB → (empty string). So, the answer is 0.
|
# from debug import *
import sys;input = sys.stdin.readline
for _ in range(int(input())):
s = input().strip()
stack = []
for i in s:
if stack and i == 'B': stack.pop()
else: stack.append(i)
print(len(stack))
|
Ashish has two strings a and b, each of length n, and an integer k. The strings only contain lowercase English letters.
He wants to convert string a into string b by performing some (possibly zero) operations on a.
In one move, he can either
* choose an index i (1 ≤ i≤ n-1) and swap a_i and a_{i+1}, or
* choose an index i (1 ≤ i ≤ n-k+1) and if a_i, a_{i+1}, …, a_{i+k-1} are all equal to some character c (c ≠ 'z'), replace each one with the next character (c+1), that is, 'a' is replaced by 'b', 'b' is replaced by 'c' and so on.
Note that he can perform any number of operations, and the operations can only be performed on string a.
Help Ashish determine if it is possible to convert string a into b after performing some (possibly zero) operations on it.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases. The description of each test case is as follows.
The first line of each test case contains two integers n (2 ≤ n ≤ 10^6) and k (1 ≤ k ≤ n).
The second line of each test case contains the string a of length n consisting of lowercase English letters.
The third line of each test case contains the string b of length n consisting of lowercase English letters.
It is guaranteed that the sum of values n among all test cases does not exceed 10^6.
Output
For each test case, print "Yes" if Ashish can convert a into b after some moves, else print "No".
You may print the letters of the answer in any case (upper or lower).
Example
Input
4
3 3
abc
bcd
4 2
abba
azza
2 1
zz
aa
6 2
aaabba
ddddcc
Output
No
Yes
No
Yes
Note
In the first test case it can be shown that it is impossible to convert a into b.
In the second test case,
"abba" \xrightarrow{inc} "acca" \xrightarrow{inc} … \xrightarrow{inc} "azza".
Here "swap" denotes an operation of the first type, and "inc" denotes an operation of the second type.
In the fourth test case,
"aaabba" \xrightarrow{swap} "aaabab" \xrightarrow{swap} "aaaabb" \xrightarrow{inc} … \xrightarrow{inc} "ddaabb" \xrightarrow{inc} … \xrightarrow{inc} "ddddbb" \xrightarrow{inc} … \xrightarrow{inc} "ddddcc".
|
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n,k=map(int,input().split())
a=input()
b=input()
l1=[0]*26
l2=[0]*26
for i in range(n):
l1[ord(a[i])-97]+=1
l2[ord(b[i])-97]+=1
f=False
for i in range(25):
z=l1[i]-l2[i]
if(z<0 or z%k):
f=True
break
l1[i]=l2[i]
l1[i+1]+=z
print(['No','Yes'][l1==l2])
|
At the school where Vasya is studying, preparations are underway for the graduation ceremony. One of the planned performances is a ball, which will be attended by pairs of boys and girls.
Each class must present two couples to the ball. In Vasya's class, a boys and b girls wish to participate. But not all boys and not all girls are ready to dance in pairs.
Formally, you know k possible one-boy-one-girl pairs. You need to choose two of these pairs so that no person is in more than one pair.
For example, if a=3, b=4, k=4 and the couples (1, 2), (1, 3), (2, 2), (3, 4) are ready to dance together (in each pair, the boy's number comes first, then the girl's number), then the following combinations of two pairs are possible (not all possible options are listed below):
* (1, 3) and (2, 2);
* (3, 4) and (1, 3);
But the following combinations are not possible:
* (1, 3) and (1, 2) — the first boy enters two pairs;
* (1, 2) and (2, 2) — the second girl enters two pairs;
Find the number of ways to select two pairs that match the condition above. Two ways are considered different if they consist of different pairs.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains three integers a, b and k (1 ≤ a, b, k ≤ 2 ⋅ 10^5) — the number of boys and girls in the class and the number of couples ready to dance together.
The second line of each test case contains k integers a_1, a_2, … a_k. (1 ≤ a_i ≤ a), where a_i is the number of the boy in the pair with the number i.
The third line of each test case contains k integers b_1, b_2, … b_k. (1 ≤ b_i ≤ b), where b_i is the number of the girl in the pair with the number i.
It is guaranteed that the sums of a, b, and k over all test cases do not exceed 2 ⋅ 10^5.
It is guaranteed that each pair is specified at most once in one test case.
Output
For each test case, on a separate line print one integer — the number of ways to choose two pairs that match the condition above.
Example
Input
3
3 4 4
1 1 2 3
2 3 2 4
1 1 1
1
1
2 2 4
1 1 2 2
1 2 1 2
Output
4
0
2
Note
In the first test case, the following combinations of pairs fit:
* (1, 2) and (3, 4);
* (1, 3) and (2, 2);
* (1, 3) and (3, 4);
* (2, 2) and (3, 4).
There is only one pair in the second test case.
In the third test case, the following combinations of pairs fit:
* (1, 1) and (2, 2);
* (1, 2) and (2, 1).
|
import java.io.*;
import java.util.*;
import java.math.*;
public class CFTemplate {
static final long MOD = 1000000007L;
//static final long MOD2 = 1000000009L;
//static final long MOD = 998244353L;
//static final long INF = 500000000000L;
static final int INF = 10000000;
static final int NINF = -100000;
static FastScanner sc;
static PrintWriter pw;
public static void main(String[] args) {
sc = new FastScanner();
pw = new PrintWriter(System.out);
int Q = sc.ni();
for (int q = 0; q < Q; q++) {
int A = sc.ni();
int B = sc.ni();
int K = sc.ni();
int[] boys = new int[A];
int[] girls = new int[B];
int[][] nums = new int[K][2];
for (int i = 0; i < K; i++) {
nums[i][0] = sc.ni()-1;
boys[nums[i][0]] += 1;
}
for (int i = 0; i < K; i++) {
nums[i][1] = sc.ni()-1;
girls[nums[i][1]] += 1;
}
long ans = 0;
for (int[] n: nums) {
int s = K-boys[n[0]]-girls[n[1]]+1;
ans += s;
}
pw.println(ans/2);
}
pw.close();
}
static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner() {
br = new BufferedReader(new InputStreamReader(System.in), 32768);
st = null;
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int ni() {
return Integer.parseInt(next());
}
int[] intArray(int N) {
int[] ret = new int[N];
for (int i = 0; i < N; i++)
ret[i] = ni();
return ret;
}
long nl() {
return Long.parseLong(next());
}
long[] longArray(int N) {
long[] ret = new long[N];
for (int i = 0; i < N; i++)
ret[i] = nl();
return ret;
}
double nd() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
|
It was the third month of remote learning, Nastya got sick of staying at dormitory, so she decided to return to her hometown. In order to make her trip more entertaining, one of Nastya's friend presented her an integer array a.
Several hours after starting her journey home Nastya remembered about the present. To entertain herself she decided to check, are there four different indices x, y, z, w such that a_x + a_y = a_z + a_w.
Her train has already arrived the destination, but she still hasn't found the answer. Can you help her unravel the mystery?
Input
The first line contains the single integer n (4 ≤ n ≤ 200 000) — the size of the array.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 2.5 ⋅ 10^6).
Output
Print "YES" if there are such four indices, and "NO" otherwise.
If such indices exist, print these indices x, y, z and w (1 ≤ x, y, z, w ≤ n).
If there are multiple answers, print any of them.
Examples
Input
6
2 1 5 2 7 4
Output
YES
2 3 1 6
Input
5
1 3 1 9 20
Output
NO
Note
In the first example a_2 + a_3 = 1 + 5 = 2 + 4 = a_1 + a_6. Note that there are other answer, for example, 2 3 4 6.
In the second example, we can't choose four indices. The answer 1 2 2 3 is wrong, because indices should be different, despite that a_1 + a_2 = 1 + 3 = 3 + 1 = a_2 + a_3
|
def show(x, y, z, w):
print("YES")
print(x+1, y+1, z+1, w+1)
exit(0)
n=int(input())
ara=list(int(x) for x in input().split())
n=min(n, 2000)
found={}
for i in range(0, n):
for j in range(i+1, n):
cur_sm=ara[i]+ara[j]
if cur_sm in found.keys() and found[cur_sm][0]!=i and found[cur_sm][1]!=j and found[cur_sm][0]!=j and found[cur_sm][1]!=i:
show(found[cur_sm][0], found[cur_sm][1], i, j);
found[cur_sm]=(i, j)
print("NO")
|
There are n robots driving along an OX axis. There are also two walls: one is at coordinate 0 and one is at coordinate m.
The i-th robot starts at an integer coordinate x_i~(0 < x_i < m) and moves either left (towards the 0) or right with the speed of 1 unit per second. No two robots start at the same coordinate.
Whenever a robot reaches a wall, it turns around instantly and continues his ride in the opposite direction with the same speed.
Whenever several robots meet at the same integer coordinate, they collide and explode into dust. Once a robot has exploded, it doesn't collide with any other robot. Note that if several robots meet at a non-integer coordinate, nothing happens.
For each robot find out if it ever explodes and print the time of explosion if it happens and -1 otherwise.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of testcases.
Then the descriptions of t testcases follow.
The first line of each testcase contains two integers n and m (1 ≤ n ≤ 3 ⋅ 10^5; 2 ≤ m ≤ 10^8) — the number of robots and the coordinate of the right wall.
The second line of each testcase contains n integers x_1, x_2, ..., x_n (0 < x_i < m) — the starting coordinates of the robots.
The third line of each testcase contains n space-separated characters 'L' or 'R' — the starting directions of the robots ('L' stands for left and 'R' stands for right).
All coordinates x_i in the testcase are distinct.
The sum of n over all testcases doesn't exceed 3 ⋅ 10^5.
Output
For each testcase print n integers — for the i-th robot output the time it explodes at if it does and -1 otherwise.
Example
Input
5
7 12
1 2 3 4 9 10 11
R R L L R R R
2 10
1 6
R R
2 10
1 3
L L
1 10
5
R
7 8
6 1 7 2 3 5 4
R L R L L L L
Output
1 1 1 1 2 -1 2
-1 -1
2 2
-1
-1 2 7 3 2 7 3
Note
Here is the picture for the seconds 0, 1, 2 and 3 of the first testcase:
<image>
Notice that robots 2 and 3 don't collide because they meet at the same point 2.5, which is not integer.
After second 3 robot 6 just drive infinitely because there's no robot to collide with.
|
#include <bits/stdc++.h>
typedef long long int ll;
using namespace std;
ll mod = 1e9+7;
#define MAXN 10000001
int spf[MAXN];
vector<int>ans(3e5,0);
int m;
void func(vector<tuple<int,char,int>>&v)
{
vector<tuple<int,char,int>>st;
for(int i=0;i<v.size();i++)
{
if(st.size()==0)
{
st.push_back(v[i]);
}
else if(get<1>(st.back())=='R' && get<1>(v[i]) == 'L')
{
ans[get<2>(st.back())] = abs(get<0>(st.back()) - get<0>(v[i]))/2;
ans[get<2>(v[i])] = abs(get<0>(st.back()) - get<0>(v[i]))/2;
st.pop_back();
}
else{
st.push_back(v[i]);
}
}
vector<tuple<int,char,int>>vl;
vector<tuple<int,char,int>>vr;
for(int i=0;i<st.size();i++)
{
if(get<1>(st[i])=='L')
{
vl.push_back(st[i]);
}
else{
vr.push_back(st[i]);
}
}
for(int i=1;i<vl.size();i=i+2)
{
ans[get<2>(vl[i])] = abs(get<0>(vl[i]) + get<0>(vl[i-1]))/2;
ans[get<2>(vl[i-1])] = abs(get<0>(vl[i]) + get<0>(vl[i-1]))/2;
}
for(int i=vr.size()-1;i>0;i=i-2)
{
ans[get<2>(vr[i])] = abs(get<0>(vr[i]) - get<0>(vr[i-1]))/2 + m - get<0>(vr[i]);
ans[get<2>(vr[i-1])] = abs(get<0>(vr[i]) - get<0>(vr[i-1]))/2 + m - get<0>(vr[i]);
}
if(vl.size()%2 == 1 && vr.size()%2 == 1)
{
ans[get<2>(vr[0])] = (get<0>(vl[vl.size()-1]) - get<0>(vr[0]))/2 + m ;
ans[get<2>(vl[vl.size()-1])] = (get<0>(vl[vl.size()-1]) - get<0>(vr[0]))/2 + m ;
}
else if(vl.size()%2)
{
ans[get<2>(vl[vl.size()-1])]=-1;
}
else if(vr.size()%2)
{
ans[get<2>(vr[0])]=-1;
}
}
int main()
{
int t;
cin>>t;
while(t--)
{
int n;
cin>>n>>m;
vector<tuple<int,char,int>>odd;
vector<tuple<int,char,int>>even;
vector<int>a;
for(int i=0;i<n;i++)
{
int x;
cin>>x;
a.push_back(x);
}
for(int i=0;i<n;i++)
{
char c;
cin>>c;
tuple<int,char,int>p;
get<0>(p) = a[i];
get<1>(p) = c;
get<2>(p) = i;
if(a[i]%2)
{
odd.push_back(p);
}
else{
even.push_back(p);
}
}
sort(odd.begin(),odd.end());
sort(even.begin(),even.end());
func(odd);
func(even);
for(int i=0;i<n;i++)
{
cout<<ans[i]<<" ";
}
cout<<endl;
}
}
|
Mrs. Hudson hasn't made her famous pancakes for quite a while and finally she decided to make them again. She has learned m new recipes recently and she can't wait to try them. Those recipes are based on n special spices. Mrs. Hudson has these spices in the kitchen lying in jars numbered with integers from 0 to n - 1 (each spice lies in an individual jar). Each jar also has the price of the corresponding spice inscribed — some integer ai.
We know three values for the i-th pancake recipe: di, si, ci. Here di and ci are integers, and si is the pattern of some integer written in the numeral system with radix di. The pattern contains digits, Latin letters (to denote digits larger than nine) and question marks. Number x in the di-base numeral system matches the pattern si, if we can replace question marks in the pattern with digits and letters so that we obtain number x (leading zeroes aren't taken into consideration when performing the comparison). More formally: each question mark should be replaced by exactly one digit or exactly one letter. If after we replace all question marks we get a number with leading zeroes, we can delete these zeroes. For example, number 40A9875 in the 11-base numeral system matches the pattern "??4??987?", and number 4A9875 does not.
To make the pancakes by the i-th recipe, Mrs. Hudson should take all jars with numbers whose representation in the di-base numeral system matches the pattern si. The control number of the recipe (zi) is defined as the sum of number ci and the product of prices of all taken jars. More formally: <image> (where j is all such numbers whose representation in the di-base numeral system matches the pattern si).
Mrs. Hudson isn't as interested in the control numbers as she is in their minimum prime divisors. Your task is: for each recipe i find the minimum prime divisor of number zi. If this divisor exceeds 100, then you do not have to find it, print -1.
Input
The first line contains the single integer n (1 ≤ n ≤ 104). The second line contains space-separated prices of the spices a0, a1, ..., an - 1, where ai is an integer (1 ≤ ai ≤ 1018).
The third line contains the single integer m (1 ≤ m ≤ 3·104) — the number of recipes Mrs. Hudson has learned.
Next m lines describe the recipes, one per line. First you are given an integer di, written in the decimal numeral system (2 ≤ di ≤ 16). Then after a space follows the si pattern — a string from 1 to 30 in length, inclusive, consisting of digits from "0" to "9", letters from "A" to "F" and signs "?". Letters from "A" to "F" should be considered as digits from 10 to 15 correspondingly. It is guaranteed that all digits of the pattern (including the digits that are represented by letters) are strictly less than di. Then after a space follows an integer ci, written in the decimal numeral system (1 ≤ ci ≤ 1018).
Please do not use the %lld specificator to read or write 64-bit integers in С++, in is preferred to use cin, cout, strings or the %I64d specificator instead.
Output
For each recipe count by what minimum prime number the control number is divided and print this prime number on the single line. If this number turns out larger than 100, print -1.
Examples
Input
1
1
1
2 ? 1
Output
2
Input
4
2 3 5 7
4
2 ?0 11
2 ?1 13
2 0? 17
2 1? 19
Output
3
2
23
2
Input
1
1000000000000000000
1
16 ?????????????? 1
Output
-1
Note
In the first test any one-digit number in the binary system matches. The jar is only one and its price is equal to 1, the number c is also equal to 1, the control number equals 2. The minimal prime divisor of 2 is 2.
In the second test there are 4 jars with numbers from 0 to 3, and the prices are equal 2, 3, 5 and 7 correspondingly — the first four prime numbers. In all recipes numbers should be two-digit. In the first recipe the second digit always is 0, in the second recipe the second digit always is 1, in the third recipe the first digit must be 0, in the fourth recipe the first digit always is 1. Consequently, the control numbers are as follows: in the first recipe 2 × 5 + 11 = 21 (the minimum prime divisor is 3), in the second recipe 3 × 7 + 13 = 44 (the minimum prime divisor is 2), in the third recipe 2 × 3 + 17 = 23 (the minimum prime divisor is 23) and, finally, in the fourth recipe 5 × 7 + 19 = 54 (the minimum prime divisor is 2).
In the third test, the number should consist of fourteen digits and be recorded in a sixteen-base numeral system. Number 0 (the number of the single bottles) matches, the control number will be equal to 1018 + 1. The minimum prime divisor of this number is equal to 101 and you should print -1.
|
#include <bits/stdc++.h>
using namespace std;
int n, m, t;
const int su[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, -1};
const long long MODER[5] = {223092870ll, 2756205443ll, 907383479ll, 42600829ll,
97ll};
int b[100];
long long a[20000], c, ans;
char ss[100];
vector<long long> f[17][5];
void init() {
for (int i = 2; i <= 16; i++) {
int l = 1;
for (int k = 1; k <= n; k *= i, l *= i + 1)
;
for (int j = 0; j < 5; j++) f[i][j].resize(l, -1);
}
}
int calc(int d, int p) {
int x = 0, y = 0;
for (int i = 0; i < t; i++) x = x * (d + 1) + b[i];
if (f[d][p][x] != -1) return x;
f[d][p][x] = 1;
for (int i = 0; i < t; i++)
if (b[i] == d) {
for (int j = 0; j < d; j++)
b[i] = j, f[d][p][x] = (f[d][p][x] * f[d][p][calc(d, p)]) % MODER[p];
b[i] = d;
return x;
}
for (int i = 0; i < t; i++) y = y * d + b[i];
if (y < n) f[d][p][x] = a[y] % MODER[p];
return x;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%I64d", &a[i]);
scanf("%d", &m);
init();
while (m--) {
int d;
long long c;
scanf("%d%s%I64d", &d, ss, &c);
t = 0;
for (int j = 1; j <= n; t++, j *= d)
;
int len = strlen(ss);
for (int j = 0; j < t; j++)
if (len - t + j >= 0)
b[j] = ((ss[len - t + j]) == '?'
? (d)
: ('0' <= (ss[len - t + j]) && (ss[len - t + j]) <= '9'
? ss[len - t + j] - '0'
: ss[len - t + j] - 'A' + 10));
else
b[j] = 0;
int j;
for (int i = 0; i < 5; i++) {
j = calc(d, i);
ans = (f[d][i][j] + c) % MODER[i];
for (j = 0; j < 25; j++)
if (MODER[i] % su[j] == 0 && ans % su[j] == 0) break;
if (j < 25) break;
}
printf("%d\n", su[j]);
}
}
|
Fibonacci strings are defined as follows:
* f1 = «a»
* f2 = «b»
* fn = fn - 1 fn - 2, n > 2
Thus, the first five Fibonacci strings are: "a", "b", "ba", "bab", "babba".
You are given a Fibonacci string and m strings si. For each string si, find the number of times it occurs in the given Fibonacci string as a substring.
Input
The first line contains two space-separated integers k and m — the number of a Fibonacci string and the number of queries, correspondingly.
Next m lines contain strings si that correspond to the queries. It is guaranteed that strings si aren't empty and consist only of characters "a" and "b".
The input limitations for getting 30 points are:
* 1 ≤ k ≤ 3000
* 1 ≤ m ≤ 3000
* The total length of strings si doesn't exceed 3000
The input limitations for getting 100 points are:
* 1 ≤ k ≤ 1018
* 1 ≤ m ≤ 104
* The total length of strings si doesn't exceed 105
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
For each string si print the number of times it occurs in the given Fibonacci string as a substring. Since the numbers can be large enough, print them modulo 1000000007 (109 + 7). Print the answers for the strings in the order in which they are given in the input.
Examples
Input
6 5
a
b
ab
ba
aba
Output
3
5
3
3
1
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = -1e8;
const double Pi = acos(-1);
bool inline equ(double a, double b) { return fabs(a - b) < EPS; }
const int MAXN = 200010;
const long long MOD = 1000000007ll;
inline long long add(long long a, long long b) { return (a + b) % MOD; }
inline long long mul(long long a, long long b) { return (a * b) % MOD; }
inline long long sub(long long a, long long b) { return (a - b + MOD) % MOD; }
struct Mat {
long long dat[4][4];
long long* operator[](int i) { return dat[i]; }
};
Mat I{{{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}, {0, 0, 0, 1}}};
Mat F{{{1, 1, 1, 0}, {1, 0, 0, 0}, {0, 0, 0, 1}, {0, 0, 1, 0}}};
Mat operator*(Mat A, Mat B) {
Mat C;
for (int i = (0); i <= (3); i++)
for (int j = (0); j <= (3); j++) {
C[i][j] = 0;
for (int k = (0); k <= (3); k++) C[i][j] += mul(A[i][k], B[k][j]);
C[i][j] %= MOD;
}
return C;
}
Mat pw(Mat A, long long x) {
assert(x >= 0);
Mat base = A, ret = I;
while (x > 0) {
if (x & 1) ret = base * ret;
base = base * base;
x >>= 1;
}
return ret;
}
long long K;
int m;
inline int cnt(const string& t, const string& p) {
static int f[MAXN];
if ((int)(p).size() > (int)(t).size()) return 0;
for (int i = 1, j = f[0] = -1; i < (int)(p).size(); i++) {
while (j >= 0 && p[j + 1] != p[i]) j = f[j];
if (p[j + 1] == p[i]) j++;
f[i] = j;
}
int res = 0;
for (int i = 0, j = -1; i < (int)(t).size(); i++) {
while (j >= 0 && p[j + 1] != t[i]) j = f[j];
if (p[j + 1] == t[i]) j++;
if (j == (int)(p).size() - 1) {
res++;
j = f[j];
}
}
return res;
}
string fib[33];
inline long long solve(const string& s) {
if (K == 1) return s == "a";
if (K == 2) return s == "b";
string A = "a", B = "b";
int i;
for (i = 3; i <= K; i++) {
assert(i < 30);
if ((int)(fib[i - 1]).size() >= (int)(s).size() || i == K) {
B = fib[i];
A = fib[i - 1];
break;
}
}
string fip1 = fib[i + 1];
long long CA = cnt(A, s);
long long CB = cnt(B, s);
long long CAB = cnt(A + B, s) - CA - CB;
long long CBB = cnt(B + B, s) - CB - CB;
long long Sip1 = cnt(fip1, s);
if (K == i) return CB;
if (K == i + 1) return Sip1;
Mat Ans = pw(F, K - (long long)(i + 1));
return add(add(mul(Ans[0][0], Sip1), mul(Ans[0][1], CB)),
add(mul(Ans[0][2], CAB), mul(Ans[0][3], CBB)));
}
int main() {
fib[1] = "a";
fib[2] = "b";
for (int i = (3); i <= (30); i++) fib[i] = fib[i - 1] + fib[i - 2];
ios_base::sync_with_stdio(0);
cin >> K >> m;
for (int i = (1); i <= (m); i++) {
string str;
cin >> str;
cout << solve(str) << '\n';
}
}
|
Everyone knows that 2010 FIFA World Cup is being held in South Africa now. By the decision of BFA (Berland's Football Association) next World Cup will be held in Berland. BFA took the decision to change some World Cup regulations:
* the final tournament features n teams (n is always even)
* the first n / 2 teams (according to the standings) come through to the knockout stage
* the standings are made on the following principle: for a victory a team gets 3 points, for a draw — 1 point, for a defeat — 0 points. In the first place, teams are ordered in the standings in decreasing order of their points; in the second place — in decreasing order of the difference between scored and missed goals; in the third place — in the decreasing order of scored goals
* it's written in Berland's Constitution that the previous regulation helps to order the teams without ambiguity.
You are asked to write a program that, by the given list of the competing teams and the results of all the matches, will find the list of teams that managed to get through to the knockout stage.
Input
The first input line contains the only integer n (1 ≤ n ≤ 50) — amount of the teams, taking part in the final tournament of World Cup. The following n lines contain the names of these teams, a name is a string of lower-case and upper-case Latin letters, its length doesn't exceed 30 characters. The following n·(n - 1) / 2 lines describe the held matches in the format name1-name2 num1:num2, where name1, name2 — names of the teams; num1, num2 (0 ≤ num1, num2 ≤ 100) — amount of the goals, scored by the corresponding teams. Accuracy of the descriptions is guaranteed: there are no two team names coinciding accurate to the letters' case; there is no match, where a team plays with itself; each match is met in the descriptions only once.
Output
Output n / 2 lines — names of the teams, which managed to get through to the knockout stage in lexicographical order. Output each name in a separate line. No odd characters (including spaces) are allowed. It's guaranteed that the described regulations help to order the teams without ambiguity.
Examples
Input
4
A
B
C
D
A-B 1:1
A-C 2:2
A-D 1:0
B-C 1:0
B-D 0:3
C-D 0:3
Output
A
D
Input
2
a
A
a-A 2:1
Output
a
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 50 + 10;
int n;
struct tim {
int scr, goal, sub;
string name;
} arr[Maxn];
vector<string> ans;
bool moq(tim a, tim b) {
if (a.scr < b.scr) return true;
if (a.scr > b.scr) return false;
if (a.sub < b.sub) return true;
if (a.sub > b.sub) return false;
if (a.goal < b.goal) return true;
return false;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i].name;
for (int k = 0; k < n * (n - 1) / 2; k++) {
string s1, s2, s, sp;
cin >> s >> sp;
int j = 0;
while (s[j] != '-') {
s1 += s[j];
j++;
}
j++;
while (j < s.size()) {
s2 += s[j];
j++;
}
int g1 = 0, g2 = 0;
j = 0;
while (sp[j] != ':') {
g1 *= 10;
g1 += sp[j] - '0';
j++;
}
j++;
while (j < sp.size()) {
g2 *= 10;
g2 += sp[j] - '0';
j++;
}
for (int i = 0; i < n; i++) {
if (arr[i].name == s1) {
arr[i].goal += g1;
arr[i].sub += g1 - g2;
if (g1 > g2)
arr[i].scr += 3;
else {
if (g1 == g2) arr[i].scr++;
}
}
if (arr[i].name == s2) {
arr[i].goal += g2;
arr[i].sub += g2 - g1;
if (g2 > g1)
arr[i].scr += 3;
else {
if (g1 == g2) arr[i].scr++;
}
}
}
}
sort(arr, arr + n, moq);
for (int i = n / 2; i < n; i++) ans.push_back(arr[i].name);
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) cout << ans[i] << endl;
return 0;
}
|
A subsequence of length |x| of string s = s1s2... s|s| (where |s| is the length of string s) is a string x = sk1sk2... sk|x| (1 ≤ k1 < k2 < ... < k|x| ≤ |s|).
You've got two strings — s and t. Let's consider all subsequences of string s, coinciding with string t. Is it true that each character of string s occurs in at least one of these subsequences? In other words, is it true that for all i (1 ≤ i ≤ |s|), there is such subsequence x = sk1sk2... sk|x| of string s, that x = t and for some j (1 ≤ j ≤ |x|) kj = i.
Input
The first line contains string s, the second line contains string t. Each line consists only of lowercase English letters. The given strings are non-empty, the length of each string does not exceed 2·105.
Output
Print "Yes" (without the quotes), if each character of the string s occurs in at least one of the described subsequences, or "No" (without the quotes) otherwise.
Examples
Input
abab
ab
Output
Yes
Input
abacaba
aba
Output
No
Input
abc
ba
Output
No
Note
In the first sample string t can occur in the string s as a subsequence in three ways: abab, abab and abab. In these occurrences each character of string s occurs at least once.
In the second sample the 4-th character of the string s doesn't occur in any occurrence of string t.
In the third sample there is no occurrence of string t in string s.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
char a[N], b[N];
int last[26];
vector<int> G[26];
bool vis[N];
int lc[N], rc[N];
int main() {
cin >> a >> b;
int m = strlen(b);
for (int i = 0; i < m; i++) G[b[i] - 'a'].push_back(i);
memset(last, -1, sizeof(last));
int n = strlen(a);
for (int i = 0; i < n; i++) {
int x = a[i] - 'a';
lc[i] = last[x];
int p = last[x] + 1;
if (p == G[x].size()) continue;
int pos = G[x][p];
if (0 == pos || vis[pos - 1]) {
lc[i] = ++last[x];
vis[pos] = 1;
}
}
memset(vis, 0, sizeof(vis));
for (int i = 0; i < 26; i++) last[i] = G[i].size();
for (int i = n - 1; i >= 0; i--) {
int x = a[i] - 'a';
rc[i] = last[x];
int p = last[x] - 1;
if (p == -1) continue;
int pos = G[x][p];
if (pos + 1 == m || vis[pos + 1]) {
rc[i] = --last[x];
vis[pos] = 1;
}
}
bool flag = 1;
for (int i = 0; i < n; i++) {
if (lc[i] < rc[i]) flag = 0;
}
puts(flag ? "Yes" : "No");
}
|
Polycarpus got hold of a family tree. The found tree describes the family relations of n people, numbered from 1 to n. Every person in this tree has at most one direct ancestor. Also, each person in the tree has a name, the names are not necessarily unique.
We call the man with a number a a 1-ancestor of the man with a number b, if the man with a number a is a direct ancestor of the man with a number b.
We call the man with a number a a k-ancestor (k > 1) of the man with a number b, if the man with a number b has a 1-ancestor, and the man with a number a is a (k - 1)-ancestor of the 1-ancestor of the man with a number b.
In the tree the family ties do not form cycles. In other words there isn't a person who is his own direct or indirect ancestor (that is, who is an x-ancestor of himself, for some x, x > 0).
We call a man with a number a the k-son of the man with a number b, if the man with a number b is a k-ancestor of the man with a number a.
Polycarpus is very much interested in how many sons and which sons each person has. He took a piece of paper and wrote m pairs of numbers vi, ki. Help him to learn for each pair vi, ki the number of distinct names among all names of the ki-sons of the man with number vi.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 105) — the number of people in the tree. Next n lines contain the description of people in the tree. The i-th line contains space-separated string si and integer ri (0 ≤ ri ≤ n), where si is the name of the man with a number i, and ri is either the number of the direct ancestor of the man with a number i or 0, if the man with a number i has no direct ancestor.
The next line contains a single integer m (1 ≤ m ≤ 105) — the number of Polycarpus's records. Next m lines contain space-separated pairs of integers. The i-th line contains integers vi, ki (1 ≤ vi, ki ≤ n).
It is guaranteed that the family relationships do not form cycles. The names of all people are non-empty strings, consisting of no more than 20 lowercase English letters.
Output
Print m whitespace-separated integers — the answers to Polycarpus's records. Print the answers to the records in the order, in which the records occur in the input.
Examples
Input
6
pasha 0
gerald 1
gerald 1
valera 2
igor 3
olesya 1
5
1 1
1 2
1 3
3 1
6 1
Output
2
2
0
1
0
Input
6
valera 0
valera 1
valera 1
gerald 0
valera 4
kolya 4
7
1 1
1 2
2 1
2 2
4 1
5 1
6 1
Output
1
0
0
0
2
0
0
|
#include <bits/stdc++.h>
using namespace std;
const int kMax = 100010;
struct Query {
int ql, qr, qi;
Query(int _ql, int _qr, int _qi) { ql = _ql, qr = _qr, qi = _qi; }
bool operator<(const Query &rq) const { return qr < rq.qr; }
};
int N, Q;
int si[kMax], di[kMax], lf[kMax], rg[kMax], dfn, max_dpt;
vector<int> tree[kMax], vsi[kMax], vlf[kMax], vrg[kMax];
int qvi[kMax], qki[kMax];
vector<Query> vq[kMax];
int res[kMax], f[kMax];
map<int, int> rm_pos;
void read(void);
void prep(void);
void soups_on(void);
void dfs(int, int);
void update(int, int);
int query_sum(int);
inline int low_bit(int i) { return i & (-i); }
int main() {
ios::sync_with_stdio(false);
read(), prep(), soups_on();
return 0;
}
void read(void) {
string str;
int prn, id_cnt;
map<string, int> name_id;
cin >> N;
id_cnt = 0;
for (int i = 1; i <= N; ++i) {
cin >> str >> prn;
if (name_id.count(str) == 0) name_id[str] = id_cnt++;
si[i] = name_id[str];
tree[prn].push_back(i);
}
cin >> Q;
for (int i = 0; i < Q; ++i) cin >> qvi[i] >> qki[i];
}
void prep(void) {
int vi, ki, d, l, r;
dfs(0, 0);
for (int i = 0; i < Q; ++i) {
vi = qvi[i], ki = qki[i], d = di[vi] + ki;
if (d <= max_dpt) {
l = lower_bound(vlf[d].begin(), vlf[d].end(), lf[vi]) - vlf[d].begin();
r = lower_bound(vrg[d].begin(), vrg[d].end(), rg[vi]) - vrg[d].begin();
vq[d].push_back(Query(l, r, i));
}
}
for (int i = 1; i <= max_dpt; ++i) stable_sort(vq[i].begin(), vq[i].end());
}
void soups_on(void) {
for (int i = 1; i <= max_dpt; ++i) {
int p, q;
p = q = 0;
while (q < int(vq[i].size())) {
Query &rq = vq[i][q];
while (p < rq.qr) {
if (rm_pos.count(vsi[i][p])) update(rm_pos[vsi[i][p]] + 1, -1);
rm_pos[vsi[i][p]] = p;
update(p + 1, 1);
++p;
}
res[rq.qi] = query_sum(rq.qr) - query_sum(rq.ql), ++q;
}
for (map<int, int>::iterator itr = rm_pos.begin(); itr != rm_pos.end();
++itr)
update(itr->second + 1, -1);
rm_pos.clear();
}
for (int i = 0; i < Q; ++i) cout << res[i] << "\n";
}
void dfs(int u, int lv) {
di[u] = lv, vsi[lv].push_back(si[u]), vlf[lv].push_back(lf[u] = dfn), ++dfn;
for (int i = 0; i < int(tree[u].size()); ++i) dfs(tree[u][i], lv + 1);
vrg[lv].push_back(rg[u] = dfn), ++dfn, max_dpt = max(max_dpt, lv);
}
void update(int i, int dlt) {
while (i < kMax) f[i] += dlt, i += low_bit(i);
}
int query_sum(int i) {
int ret = 0;
while (i > 0) ret += f[i], i -= low_bit(i);
return ret;
}
|
Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place.
To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment.
For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place.
Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains n positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show.
The numbers in the lines are separated by a single space.
Output
In a single line print the answer to the problem.
Examples
Input
1
1
Output
3
Input
1
2
Output
2
Input
2
3 5
Output
3
Note
In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend.
In the second sample Dima can show 2 or 4 fingers.
|
while(True):
try:
n = input()
a = raw_input()
b = a.split()
ans = 0
for i in range (0,n):
ans += int(b[i])
n += 1
cnt = 0
for i in range (1,6):
if ((ans+i)%n!=1):
cnt += 1
print cnt
except EOFError:
break
|
One day Greg and his friends were walking in the forest. Overall there were n people walking, including Greg. Soon he found himself in front of a river. The guys immediately decided to get across the river. Luckily, there was a boat by the river bank, just where the guys were standing. We know that the boat can hold people with the total weight of at most k kilograms.
Greg immediately took a piece of paper and listed there the weights of all people in his group (including himself). It turned out that each person weights either 50 or 100 kilograms. Now Greg wants to know what minimum number of times the boat needs to cross the river to transport the whole group to the other bank. The boat needs at least one person to navigate it from one bank to the other. As the boat crosses the river, it can have any non-zero number of passengers as long as their total weight doesn't exceed k.
Also Greg is wondering, how many ways there are to transport everybody to the other side in the minimum number of boat rides. Two ways are considered distinct if during some ride they have distinct sets of people on the boat.
Help Greg with this problem.
Input
The first line contains two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ 5000) — the number of people, including Greg, and the boat's weight limit. The next line contains n integers — the people's weights. A person's weight is either 50 kilos or 100 kilos.
You can consider Greg and his friends indexed in some way.
Output
In the first line print an integer — the minimum number of rides. If transporting everyone to the other bank is impossible, print an integer -1.
In the second line print the remainder after dividing the number of ways to transport the people in the minimum number of rides by number 1000000007 (109 + 7). If transporting everyone to the other bank is impossible, print integer 0.
Examples
Input
1 50
50
Output
1
1
Input
3 100
50 50 100
Output
5
2
Input
2 50
50 50
Output
-1
0
Note
In the first test Greg walks alone and consequently, he needs only one ride across the river.
In the second test you should follow the plan:
1. transport two 50 kg. people;
2. transport one 50 kg. person back;
3. transport one 100 kg. person;
4. transport one 50 kg. person back;
5. transport two 50 kg. people.
That totals to 5 rides. Depending on which person to choose at step 2, we can get two distinct ways.
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
long long fact[200001], invfact[200001];
int n50 = 0, n100 = 0, k = 0;
struct node {
int l[2], r[2], b;
};
long long nways[51][51][51][51][2], shortest[51][51][51][51][2];
queue<node> q;
long long pmod(long long base, long long p) {
if (p == 0) return 1LL;
long long ret = pmod(base, p / 2);
ret = (ret * ret) % MOD;
if (p % 2 == 1) ret = (ret * base) % MOD;
return ret;
}
long long invEuler(long long x) { return pmod(x, MOD - 2); }
long long nCr(long long n, long long r) {
long long ret = 1;
ret *= fact[n];
ret = (ret * invfact[r]) % MOD;
ret = (ret * invfact[n - r]) % MOD;
return ret;
}
void bfs() {
memset(nways, 0, sizeof(nways));
memset(shortest, -1, sizeof(shortest));
nways[n50][n100][0][0][0] = 1;
shortest[n50][n100][0][0][0] = 0;
node temp;
temp.l[0] = n50;
temp.l[1] = n100;
temp.r[0] = 0;
temp.r[1] = 0;
temp.b = 0;
q.push(temp);
while (!q.empty()) {
temp = q.front();
q.pop();
int l0, l1, r0, r1, b;
l0 = temp.l[0];
l1 = temp.l[1];
r0 = temp.r[0];
r1 = temp.r[1];
b = temp.b;
if (b == 0) {
for (int i = 0; i <= l0; ++i) {
for (int j = 0; j <= l1; ++j) {
if (50 * i + 100 * j > k || (!i && !j)) continue;
int _l0 = l0 - i, _l1 = l1 - j, _r0 = r0 + i, _r1 = r1 + j, _b = !b;
if (shortest[_l0][_l1][_r0][_r1][_b] == -1 ||
shortest[_l0][_l1][_r0][_r1][_b] >
shortest[l0][l1][r0][r1][b] + 1) {
shortest[_l0][_l1][_r0][_r1][_b] = 1 + shortest[l0][l1][r0][r1][b];
nways[_l0][_l1][_r0][_r1][_b] =
(((nCr(l0, i) * nCr(l1, j)) % MOD) * nways[l0][l1][r0][r1][b]) %
MOD;
temp.l[0] = _l0;
temp.l[1] = _l1;
temp.r[0] = _r0;
temp.r[1] = _r1;
temp.b = _b;
q.push(temp);
} else if (shortest[_l0][_l1][_r0][_r1][_b] ==
shortest[l0][l1][r0][r1][b] + 1)
nways[_l0][_l1][_r0][_r1][_b] =
(nways[_l0][_l1][_r0][_r1][_b] +
(((nCr(l0, i) * nCr(l1, j)) % MOD) *
nways[l0][l1][r0][r1][b]) %
MOD) %
MOD;
}
}
} else {
for (int i = 0; i <= r0; ++i) {
for (int j = 0; j <= r1; ++j) {
if (50 * i + 100 * j > k || (!i && !j)) continue;
int _l0 = l0 + i, _l1 = l1 + j, _r0 = r0 - i, _r1 = r1 - j, _b = !b;
if (shortest[_l0][_l1][_r0][_r1][_b] == -1 ||
shortest[_l0][_l1][_r0][_r1][_b] >
shortest[l0][l1][r0][r1][b] + 1) {
shortest[_l0][_l1][_r0][_r1][_b] = 1 + shortest[l0][l1][r0][r1][b];
nways[_l0][_l1][_r0][_r1][_b] =
(((nCr(r0, i) * nCr(r1, j)) % MOD) * nways[l0][l1][r0][r1][b]) %
MOD;
temp.l[0] = _l0;
temp.l[1] = _l1;
temp.r[0] = _r0;
temp.r[1] = _r1;
temp.b = _b;
q.push(temp);
} else if (shortest[_l0][_l1][_r0][_r1][_b] ==
shortest[l0][l1][r0][r1][b] + 1)
nways[_l0][_l1][_r0][_r1][_b] =
(nways[_l0][_l1][_r0][_r1][_b] +
(((nCr(r0, i) * nCr(r1, j)) % MOD) *
nways[l0][l1][r0][r1][b]) %
MOD) %
MOD;
}
}
}
}
}
int main() {
int n, in;
fact[0] = 1;
fact[1] = 1;
invfact[0] = invEuler(1);
invfact[1] = invfact[0];
for (int i = 2; i < 200001; ++i) {
fact[i] = (fact[i - 1] * i) % MOD;
invfact[i] = invEuler(fact[i]);
}
scanf("%d %d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", &in);
if (in == 50)
n50++;
else
n100++;
}
bfs();
cout << shortest[0][0][n50][n100][1] << endl << nways[0][0][n50][n100][1];
}
|
As a tradition, every year before IOI all the members of Natalia Fan Club are invited to Malek Dance Club to have a fun night together. Malek Dance Club has 2n members and coincidentally Natalia Fan Club also has 2n members. Each member of MDC is assigned a unique id i from 0 to 2n - 1. The same holds for each member of NFC.
One of the parts of this tradition is one by one dance, where each member of MDC dances with a member of NFC. A dance pair is a pair of numbers (a, b) such that member a from MDC dances with member b from NFC.
The complexity of a pairs' assignment is the number of pairs of dancing pairs (a, b) and (c, d) such that a < c and b > d.
You are given a binary number of length n named x. We know that member i from MDC dances with member <image> from NFC. Your task is to calculate the complexity of this assignment modulo 1000000007 (109 + 7).
Expression <image> denotes applying «XOR» to numbers x and y. This operation exists in all modern programming languages, for example, in C++ and Java it denotes as «^», in Pascal — «xor».
Input
The first line of input contains a binary number x of lenght n, (1 ≤ n ≤ 100).
This number may contain leading zeros.
Output
Print the complexity of the given dance assignent modulo 1000000007 (109 + 7).
Examples
Input
11
Output
6
Input
01
Output
2
Input
1
Output
1
|
import java.io.*;
import java.util.*;
public class Contest189 {
public static void main(String[] args) throws IOException {
new Contest189().run();
}
long binpow(long a, long p, long mod) {
long res = 1 % mod;
while(p != 0) {
if((p & 1) != 0)
res = (res * a) % mod;
a = (a * a) % mod;
p >>= 1;
}
return res;
}
void solve() throws IOException {
final long mod = (long)(1e9 + 7.5);
String x = nextToken();
int n = x.length();
long res = 0;
for(int i = 0; i < n; ++i)
if(x.charAt(i) == '1') {
long left = binpow(2, i, mod);
long right = binpow(binpow(2, n - i - 1, mod), 2, mod);
res = (res + left * right) % mod;
}
out.println(res);
}
BufferedReader br;
StringTokenizer st;
PrintWriter out;
public String nextToken() throws IOException {
while(st == null || !st.hasMoreTokens()) {
st = new StringTokenizer(br.readLine());
}
return st.nextToken();
}
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());
}
void run() throws IOException {
boolean oj = System.getProperty("ONLINE_JUDGE") != null;
br = new BufferedReader( new InputStreamReader( oj ? System.in : new FileInputStream("input.txt")));
out = new PrintWriter( oj ? System.out : new FileOutputStream("output.txt"));
solve();
out.close();
}
}
|
Mad scientist Mike is building a time machine in his spare time. To finish the work, he needs a resistor with a certain resistance value.
However, all Mike has is lots of identical resistors with unit resistance R0 = 1. Elements with other resistance can be constructed from these resistors. In this problem, we will consider the following as elements:
1. one resistor;
2. an element and one resistor plugged in sequence;
3. an element and one resistor plugged in parallel.
<image>
With the consecutive connection the resistance of the new element equals R = Re + R0. With the parallel connection the resistance of the new element equals <image>. In this case Re equals the resistance of the element being connected.
Mike needs to assemble an element with a resistance equal to the fraction <image>. Determine the smallest possible number of resistors he needs to make such an element.
Input
The single input line contains two space-separated integers a and b (1 ≤ a, b ≤ 1018). It is guaranteed that the fraction <image> is irreducible. It is guaranteed that a solution always exists.
Output
Print a single number — the answer to the problem.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Examples
Input
1 1
Output
1
Input
3 2
Output
3
Input
199 200
Output
200
Note
In the first sample, one resistor is enough.
In the second sample one can connect the resistors in parallel, take the resulting element and connect it to a third resistor consecutively. Then, we get an element with resistance <image>. We cannot make this element using two resistors.
|
#import sys
#sys.stdin = open('in')
a, b = map(long,raw_input().split())
res = 0
while a > 1 or b > 1:
if a > b:
n = a / b
res += n
a -= b*n
else:
n = b / a
res += n
b -= a*n
print res + (1 if a == 1 and b == 1 else 0)
|
Dima, Inna and Seryozha have gathered in a room. That's right, someone's got to go. To cheer Seryozha up and inspire him to have a walk, Inna decided to cook something.
Dima and Seryozha have n fruits in the fridge. Each fruit has two parameters: the taste and the number of calories. Inna decided to make a fruit salad, so she wants to take some fruits from the fridge for it. Inna follows a certain principle as she chooses the fruits: the total taste to the total calories ratio of the chosen fruits must equal k. In other words, <image> , where aj is the taste of the j-th chosen fruit and bj is its calories.
Inna hasn't chosen the fruits yet, she is thinking: what is the maximum taste of the chosen fruits if she strictly follows her principle? Help Inna solve this culinary problem — now the happiness of a young couple is in your hands!
Inna loves Dima very much so she wants to make the salad from at least one fruit.
Input
The first line of the input contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ 10). The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the fruits' tastes. The third line of the input contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100) — the fruits' calories. Fruit number i has taste ai and calories bi.
Output
If there is no way Inna can choose the fruits for the salad, print in the single line number -1. Otherwise, print a single integer — the maximum possible sum of the taste values of the chosen fruits.
Examples
Input
3 2
10 8 1
2 7 1
Output
18
Input
5 3
4 4 4 4 4
2 2 2 2 2
Output
-1
Note
In the first test sample we can get the total taste of the fruits equal to 18 if we choose fruit number 1 and fruit number 2, then the total calories will equal 9. The condition <image> fulfills, that's exactly what Inna wants.
In the second test sample we cannot choose the fruits so as to follow Inna's principle.
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[110], b[110], dp[110][101000][2];
long long Rec(int i, int sum, bool take) {
if (i == n) return (sum == 1e4 && take ? 0 : -1e9);
if (dp[i][sum][take] != -1) return dp[i][sum][take];
long long Res = -1e9;
Res = max(Res, a[i] + Rec(i + 1, (sum + a[i]) - b[i] * k, 1));
Res = max(Res, Rec(i + 1, sum, take));
return dp[i][sum][take] = Res;
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
cout << (Rec(0, 1e4, 0) < 0 ? -1 : Rec(0, 1e4, 0));
return 0;
}
|
Two chess pieces, a rook and a knight, stand on a standard chessboard 8 × 8 in size. The positions in which they are situated are known. It is guaranteed that none of them beats the other one.
Your task is to find the number of ways to place another knight on the board so that none of the three pieces on the board beat another one. A new piece can only be placed on an empty square.
Input
The first input line contains the description of the rook's position on the board. This description is a line which is 2 in length. Its first symbol is a lower-case Latin letter from a to h, and its second symbol is a number from 1 to 8. The second line contains the description of the knight's position in a similar way. It is guaranteed that their positions do not coincide.
Output
Print a single number which is the required number of ways.
Examples
Input
a1
b2
Output
44
Input
a8
d4
Output
38
|
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.ArrayList;
import java.util.HashSet;
public class Main {
private static StreamTokenizer in;
private static PrintWriter out;
private static BufferedReader inB;
private static int nextInt() throws Exception{
in.nextToken();
return (int)in.nval;
}
private static String nextString() throws Exception{
in.nextToken();
return in.sval;
}
static{
inB = new BufferedReader(new InputStreamReader(System.in));
in = new StreamTokenizer(inB);
out = new PrintWriter(System.out);
}
private static boolean[][] mas = new boolean[8][8];
private static boolean is(int a, int b) {
return a >= 0 && a < 8 && b >= 0 && b < 8;
}
private static void fill(int a, int b) {
if(is(a, b))mas[a][b] = true;
}
private static void con(int a, int b) {
fill(a, b);
fill(a + 1, b+2);
fill(a - 1, b+2);
fill(a + 1, b-2);
fill(a - 1, b-2);
fill(a + 2, b+1);
fill(a + 2, b-1);
fill(a - 2, b+1);
fill(a - 2, b-1);
}
private static void lad(int a, int b) {
for(int i = 0; i<8; i++) {
mas[i][b] = true;
}
for(int i = 0; i<8; i++) {
mas[a][i] = true;
}
}
public static void main(String[] args)throws Exception{
char[] c1 = inB.readLine().toCharArray();
char[] c2 = inB.readLine().toCharArray();
con(c1[0] - 'a', c1[1] - '1');
lad(c1[0] - 'a', c1[1] - '1');
con(c2[0] - 'a', c2[1] - '1');
int ans = 0;
for(int i = 0; i<8; i++) {
for(int j = 0; j<8; j++) {
// System.out.print((mas[i][j]?"t":"f") + " ");
if(!mas[i][j])ans++;
}
// System.out.println();
}
System.out.println(ans);
}
}
|
Not so long ago as a result of combat operations the main Berland place of interest — the magic clock — was damaged. The cannon's balls made several holes in the clock, that's why the residents are concerned about the repair. The magic clock can be represented as an infinite Cartesian plane, where the origin corresponds to the clock center. The clock was painted two colors as is shown in the picture:
<image>
The picture shows only the central part of the clock. This coloring naturally extends to infinity.
The balls can be taken to be points on the plane. Your task is to find the color of the area, damaged by the given ball.
All the points located on the border of one of the areas have to be considered painted black.
Input
The first and single line contains two integers x and y — the coordinates of the hole made in the clock by the ball. Each of the numbers x and y has an absolute value that does not exceed 1000.
Output
Find the required color.
All the points between which and the origin of coordinates the distance is integral-value are painted black.
Examples
Input
-2 1
Output
white
Input
2 1
Output
black
Input
4 3
Output
black
|
#include <bits/stdc++.h>
using namespace std;
int x, y;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> x >> y;
double dist = sqrt((x * x + y * y));
if ((y >= 0 && x >= 0) || (y < 0 && x < 0)) {
if (int(dist) % 2 && int(dist) != dist)
return cout << "white", 0;
else
return cout << "black", 0;
} else {
if (int(dist) % 2 || int(dist) == dist)
return cout << "black", 0;
else
return cout << "white", 0;
}
return 0;
}
|
This time our child has a simple polygon. He has to find the number of ways to split the polygon into non-degenerate triangles, each way must satisfy the following requirements:
* each vertex of each triangle is one of the polygon vertex;
* each side of the polygon must be the side of exactly one triangle;
* the area of intersection of every two triangles equals to zero, and the sum of all areas of triangles equals to the area of the polygon;
* each triangle must be completely inside the polygon;
* each side of each triangle must contain exactly two vertices of the polygon.
The picture below depicts an example of a correct splitting.
<image>
Please, help the child. Calculate the described number of ways modulo 1000000007 (109 + 7) for him.
Input
The first line contains one integer n (3 ≤ n ≤ 200) — the number of vertices of the polygon. Then follow n lines, each line containing two integers. The i-th line contains xi, yi (|xi|, |yi| ≤ 107) — the i-th vertex of the polygon in clockwise or counterclockwise order.
It's guaranteed that the polygon is simple.
Output
Output the number of ways modulo 1000000007 (109 + 7).
Examples
Input
4
0 0
0 1
1 1
1 0
Output
2
Input
4
0 0
1 0
0 1
-1 0
Output
1
Input
5
0 0
1 0
1 1
0 1
-2 -1
Output
3
Note
In the first sample, there are two possible splittings:
<image>
In the second sample, there are only one possible splitting:
<image>
|
#include <bits/stdc++.h>
using namespace std;
pair<long double, long double> v[300], O, M;
int n, nr, K, nri, OK[300][300], nx[300], val1, val2, val;
long long A1, dt, A2, B1, B2, C1, C2, D[300][300], S, d1, d2, d3, d4;
long double xm, ym, SP;
long double aba(long double a) {
if (a < 0) return -a;
return a;
}
long double detu(long double ax, long double ay, long double bx, long double by,
long double cx, long double cy) {
return ax * by + bx * cy + cx * ay - ay * bx - by * cx - cy * ax;
}
long double det(pair<long double, long double> a,
pair<long double, long double> b,
pair<long double, long double> c) {
long double dt = a.first * b.second + b.first * c.second +
c.first * a.second - a.second * b.first -
b.second * c.first - c.second * a.first;
if (dt > 0) dt = 1;
if (dt < 0) dt = -1;
return dt;
}
int intersect(pair<long double, long double> a,
pair<long double, long double> b,
pair<long double, long double> c,
pair<long double, long double> d) {
long double d1 = det(a, b, c), d2 = det(a, b, d), d3 = det(c, d, a),
d4 = det(c, d, b);
if (!d1 || !d2 || !d3 || !d4) return 0;
if (d1 == -d2 && d3 == -d4)
return 1;
else
return 0;
}
int inside(pair<long double, long double> M) {
int c = 0;
for (int i = 1; i <= n; ++i)
if (det(O, M, v[i]) == 0 && v[i].first >= O.first &&
v[i].first <= M.first && v[i].second >= min(O.second, M.second) &&
v[i].second <= max(O.second, M.second))
c = 1 - c;
for (int i = 1; i <= n; ++i) {
if (intersect(O, M, v[i], v[nx[i]])) c = 1 - c;
}
return c;
}
long long solve(int st, int dr) {
if (nx[st] == dr || nx[nx[st]] == dr || st == dr) return 1;
if (D[st][dr]) return D[st][dr];
for (int i = nx[st]; i != dr; i = nx[i]) {
if (OK[st][i] && OK[dr][i]) {
D[st][dr] += solve(st, i) * solve(i, dr) % 1000000007;
if (D[st][dr] >= 1000000007) D[st][dr] -= 1000000007;
}
}
return D[st][dr];
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> v[i].first >> v[i].second;
for (int i = 1; i <= n; ++i) nx[i] = i + 1;
nx[n] = 1;
O.first = -1000000007;
O.second = -1000000009;
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j) {
K = 1;
OK[i][j] = OK[j][i] = 1;
if (j == i + 1) continue;
if (i == 1 && j == n) continue;
for (int k = 1; k <= n; ++k) {
if (i == k || j == k) continue;
if (det(v[i], v[j], v[k]) == 0 &&
v[k].first >= min(v[i].first, v[j].first) &&
v[k].first <= max(v[i].first, v[j].first) &&
v[k].second >= min(v[i].second, v[j].second) &&
v[k].second <= max(v[i].second, v[j].second)) {
K = 0;
break;
}
}
if (!K) {
OK[i][j] = OK[j][i] = 0;
continue;
}
for (int k = 1; k <= n; ++k) {
if (intersect(v[i], v[j], v[k], v[nx[k]])) {
K = 0;
break;
}
}
if (!K) {
OK[i][j] = OK[j][i] = 0;
continue;
}
M.first = v[i].first + v[j].first;
M.second = v[i].second + v[j].second;
M.first /= 2;
M.second /= 2;
O.first -= M.first - 1;
O.second -= M.second;
if (!inside(M)) OK[i][j] = OK[j][i] = 0;
O.first += M.first;
O.second += M.second;
}
cout << solve(1, n);
return 0;
}
|
In Berland prime numbers are fashionable — the respectable citizens dwell only on the floors with numbers that are prime numbers. The numismatists value particularly high the coins with prime nominal values. All the prime days are announced holidays!
Yet even this is not enough to make the Berland people happy. On the main street of the capital stand n houses, numbered from 1 to n. The government decided to paint every house a color so that the sum of the numbers of the houses painted every color is a prime number.
However it turned out that not all the citizens approve of this decision — many of them protest because they don't want many colored houses on the capital's main street. That's why it is decided to use the minimal possible number of colors. The houses don't have to be painted consecutively, but every one of n houses should be painted some color. The one-colored houses should not stand consecutively, any way of painting is acceptable.
There are no more than 5 hours left before the start of painting, help the government find the way when the sum of house numbers for every color is a prime number and the number of used colors is minimal.
Input
The single input line contains an integer n (2 ≤ n ≤ 6000) — the number of houses on the main streets of the capital.
Output
Print the sequence of n numbers, where the i-th number stands for the number of color for house number i. Number the colors consecutively starting from 1. Any painting order is allowed. If there are several solutions to that problem, print any of them. If there's no such way of painting print the single number -1.
Examples
Input
8
Output
1 2 2 1 1 1 1 2
|
import java.util.*;
public class cf45g {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
boolean[] isPrime = new boolean[n+1];
Arrays.fill(isPrime,true);
int[] ans = new int[n+1];
Arrays.fill(ans,1);
int sum = (n*n+n)/2;
if(!isPrime(sum)) {
//every even number is the sum of two odd primes
if(sum%2==0) {
int crnt = 3;
while(!(isPrime(crnt)&&isPrime(sum-crnt))) crnt++;
ans[crnt] = 2;
}
//every odd number is the sum of 2 and a prime or 3 and 2 primes
else {
if(isPrime(sum-2)) {
ans[2] = 2;
}
else {
ans[3] = 2;
int crnt = 3;
while(!(isPrime(crnt)&&isPrime(sum-3-crnt))) crnt++;
ans[crnt] = 3;
}
}
}
for(int i=1; i<=n; i++)
System.out.print(ans[i] + " ");
System.out.println();
}
static boolean isPrime(int x) {
if(x==2) return true;
if(x<2||x%2==0) return false;
for(int i=3; i*i<=x; i+=2)
if(x%i==0)
return false;
return true;
}
}
|
Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.
Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.
You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.
More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.
Input
The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).
Output
Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.
If the counterexample does not exist, print the single number -1.
Examples
Input
2 4
Output
2 3 4
Input
10 11
Output
-1
Input
900000000000000009 900000000000000029
Output
900000000000000009 900000000000000010 900000000000000021
Note
In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.
In the second sample you cannot form a group of three distinct integers, so the answer is -1.
In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three.
|
s, e = [int(num) for num in input().split()]
def GCD(a, b):
return GCD(b, a % b) if b else a
result = -1
for i in range(s, e + 1):
for j in range(i + 1, e + 1):
if GCD(i, j) == 1:
for k in range(j + 1, e + 1):
if GCD(j, k) == 1 and GCD(i, k) != 1:
print(i, j, k)
result = 0
break
if not result:
break
if not result:
break
if result:
print(result)
|
Amr is a young coder who likes music a lot. He always wanted to learn how to play music but he was busy coding so he got an idea.
Amr has n instruments, it takes ai days to learn i-th instrument. Being busy, Amr dedicated k days to learn how to play the maximum possible number of instruments.
Amr asked for your help to distribute his free days between instruments so that he can achieve his goal.
Input
The first line contains two numbers n, k (1 ≤ n ≤ 100, 0 ≤ k ≤ 10 000), the number of instruments and number of days respectively.
The second line contains n integers ai (1 ≤ ai ≤ 100), representing number of days required to learn the i-th instrument.
Output
In the first line output one integer m representing the maximum number of instruments Amr can learn.
In the second line output m space-separated integers: the indices of instruments to be learnt. You may output indices in any order.
if there are multiple optimal solutions output any. It is not necessary to use all days for studying.
Examples
Input
4 10
4 3 1 2
Output
4
1 2 3 4
Input
5 6
4 3 1 1 2
Output
3
1 3 4
Input
1 3
4
Output
0
Note
In the first test Amr can learn all 4 instruments.
In the second test other possible solutions are: {2, 3, 5} or {3, 4, 5}.
In the third test Amr doesn't have enough time to learn the only presented instrument.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
vector<int> ind;
for (int i = 0; i < n; i++) cin >> a[i];
int count = 0;
while (k >= 0) {
int m = 111;
int i, ans;
for (i = 0; i < n; i++) {
if (a[i] < m) {
m = a[i];
ans = i;
}
}
if (m == 111) break;
k -= m;
a[ans] = 111;
if (k >= 0) {
count++;
ind.push_back(ans);
}
}
cout << count << "\n";
for (auto x : ind) cout << x + 1 << " ";
return 0;
}
|
Andrewid the Android is a galaxy-famous detective. He is now investigating a case of frauds who make fake copies of the famous Stolp's gears, puzzles that are as famous as the Rubik's cube once was.
Its most important components are a button and a line of n similar gears. Each gear has n teeth containing all numbers from 0 to n - 1 in the counter-clockwise order. When you push a button, the first gear rotates clockwise, then the second gear rotates counter-clockwise, the the third gear rotates clockwise an so on.
Besides, each gear has exactly one active tooth. When a gear turns, a new active tooth is the one following after the current active tooth according to the direction of the rotation. For example, if n = 5, and the active tooth is the one containing number 0, then clockwise rotation makes the tooth with number 1 active, or the counter-clockwise rotating makes the tooth number 4 active.
Andrewid remembers that the real puzzle has the following property: you can push the button multiple times in such a way that in the end the numbers on the active teeth of the gears from first to last form sequence 0, 1, 2, ..., n - 1. Write a program that determines whether the given puzzle is real or fake.
Input
The first line contains integer n (1 ≤ n ≤ 1000) — the number of gears.
The second line contains n digits a1, a2, ..., an (0 ≤ ai ≤ n - 1) — the sequence of active teeth: the active tooth of the i-th gear contains number ai.
Output
In a single line print "Yes" (without the quotes), if the given Stolp's gears puzzle is real, and "No" (without the quotes) otherwise.
Examples
Input
3
1 0 0
Output
Yes
Input
5
4 2 1 4 3
Output
Yes
Input
4
0 2 3 1
Output
No
Note
In the first sample test when you push the button for the first time, the sequence of active teeth will be 2 2 1, when you push it for the second time, you get 0 1 2.
|
import functools as ft
if __name__ == '__main__':
n = int(input())
a = list(map(int, input().split()))
b = [i for i in range(n)]
for i in range(1, n + 1):
a = [(a[j] + 1) % n if not j % 2 else (a[j] - 1) % n for j in range(n)]
cnt = ft.reduce(lambda x, y: x + y, [a[j] == b[j] for j in range(n)])
if cnt == n:
print("YES")
break
else:
print("NO")
|
It's election time in Berland. The favorites are of course parties of zublicanes and mumocrates. The election campaigns of both parties include numerous demonstrations on n main squares of the capital of Berland. Each of the n squares certainly can have demonstrations of only one party, otherwise it could lead to riots. On the other hand, both parties have applied to host a huge number of demonstrations, so that on all squares demonstrations must be held. Now the capital management will distribute the area between the two parties.
Some pairs of squares are connected by (n - 1) bidirectional roads such that between any pair of squares there is a unique way to get from one square to another. Some squares are on the outskirts of the capital meaning that they are connected by a road with only one other square, such squares are called dead end squares.
The mayor of the capital instructed to distribute all the squares between the parties so that the dead end squares had the same number of demonstrations of the first and the second party. It is guaranteed that the number of dead end squares of the city is even.
To prevent possible conflicts between the zublicanes and the mumocrates it was decided to minimize the number of roads connecting the squares with the distinct parties. You, as a developer of the department of distributing squares, should determine this smallest number.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 5000) — the number of squares in the capital of Berland.
Next n - 1 lines contain the pairs of integers x, y (1 ≤ x, y ≤ n, x ≠ y) — the numbers of the squares connected by the road. All squares are numbered with integers from 1 to n. It is guaranteed that the number of dead end squares of the city is even.
Output
Print a single number — the minimum number of roads connecting the squares with demonstrations of different parties.
Examples
Input
8
1 4
2 4
3 4
6 5
7 5
8 5
4 5
Output
1
Input
5
1 2
1 3
1 4
1 5
Output
2
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 5000;
const int MAXM = MAXN - 1;
int n;
int head[MAXN];
int nxt[2 * MAXM], to[2 * MAXM];
int cnt[MAXM + 1];
int val[MAXM + 1][MAXN + 1];
void go(int at, int e) {
cnt[e] = 0, val[e][0] = 0;
for (int x = head[at]; x != -1; x = nxt[x]) {
int ne = x >> 1;
if (ne == e) continue;
go(to[x], ne);
for (int i = cnt[e] + cnt[ne]; i >= 0; --i) {
int nval = INT_MAX;
for (int i1 = max(0, i - cnt[ne]); i1 <= i && i1 <= cnt[e]; ++i1)
if (val[e][i1] != INT_MAX && val[ne][i - i1] != INT_MAX &&
val[e][i1] + val[ne][i - i1] < nval)
nval = val[e][i1] + val[ne][i - i1];
for (int i1 = max(0, i - cnt[ne]); i1 <= i && i1 <= cnt[e]; ++i1)
if (val[e][i1] != INT_MAX && val[ne][i1 + cnt[ne] - i] != INT_MAX &&
val[e][i1] + val[ne][i1 + cnt[ne] - i] + 1 < nval)
nval = val[e][i1] + val[ne][i1 + cnt[ne] - i] + 1;
val[e][i] = nval;
}
cnt[e] += cnt[ne];
}
if (cnt[e] == 0) cnt[e] = 1, val[e][0] = INT_MAX, val[e][1] = 0;
}
void run() {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) head[i] = -1;
for (int i = (0); i < (n - 1); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
nxt[2 * i + 0] = head[a];
head[a] = 2 * i + 0;
to[2 * i + 0] = b;
nxt[2 * i + 1] = head[b];
head[b] = 2 * i + 1;
to[2 * i + 1] = a;
}
if (n == 2) {
printf("1\n");
return;
}
int root = -1;
for (int i = (0); i < (n); ++i)
if (head[i] != -1 && nxt[head[i]] != -1) {
root = i;
break;
}
assert(root != -1);
go(root, n - 1);
printf("%d\n", val[n - 1][cnt[n - 1] / 2]);
}
int main() {
run();
return 0;
}
|
In the land of Bovinia there are n pastures, but no paths connecting the pastures. Of course, this is a terrible situation, so Kevin Sun is planning to rectify it by constructing m undirected paths connecting pairs of distinct pastures. To make transportation more efficient, he also plans to pave some of these new paths.
Kevin is very particular about certain aspects of path-paving. Since he loves odd numbers, he wants each pasture to have an odd number of paved paths connected to it. Thus we call a paving sunny if each pasture is incident to an odd number of paved paths. He also enjoys short paths more than long paths, so he would like the longest paved path to be as short as possible. After adding each path, Kevin wants to know if a sunny paving exists for the paths of Bovinia, and if at least one does, the minimum possible length of the longest path in such a paving. Note that "longest path" here means maximum-weight edge.
Input
The first line contains two integers n (2 ≤ n ≤ 100 000) and m (1 ≤ m ≤ 300 000), denoting the number of pastures and paths, respectively. The next m lines each contain three integers ai, bi and li, describing the i-th path. The i-th path connects pastures ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi) and has length li (1 ≤ li ≤ 109). Paths are given in the order in which they are constructed.
Output
Output m lines. The i-th line should contain a single integer denoting the minimum possible length of the longest path (maximum-weight edge) in a sunny paving using only the first i paths. If Kevin cannot pave a set of paths so that each pasture is incident to an odd number of paved paths, output - 1.
Note that the paving is only hypothetical—your answer after adding the i-th path should not be affected by any of your previous answers.
Examples
Input
4 4
1 3 4
2 4 8
1 2 2
3 4 3
Output
-1
8
8
3
Input
3 2
1 2 3
2 3 4
Output
-1
-1
Input
4 10
2 1 987
3 2 829
4 1 768
4 2 608
3 4 593
3 2 488
4 2 334
2 1 204
1 3 114
1 4 39
Output
-1
-1
829
829
768
768
768
488
334
204
Note
For the first sample, these are the paths that Kevin should pave after building the i-th path:
1. No set of paths works.
2. Paths 1 (length 4) and 2 (length 8).
3. Paths 1 (length 4) and 2 (length 8).
4. Paths 3 (length 2) and 4 (length 3).
In the second sample, there never exists a paving that makes Kevin happy.
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
const int MAXM = 300000;
struct node {
int key, id, rev;
int siz1, siz2, s;
node *fa, *ch[2], *mx;
} tree[MAXN + MAXM + 5], *ad[MAXN + MAXM + 5];
struct edge {
int u, v, w, id;
edge(int _u = 0, int _v = 0, int _w = 0, int _i = 0)
: u(_u), v(_v), w(_w), id(_i) {}
} e[MAXM + 5];
bool operator<(edge a, edge b) {
if (a.w == b.w) return a.id < b.id;
return a.w < b.w;
}
set<edge> Set;
set<edge>::iterator it;
node *NIL, *ncnt;
void Init() {
NIL = ncnt = &tree[0];
NIL->fa = NIL->ch[0] = NIL->ch[1] = NIL->mx = NIL;
NIL->key = -1;
}
bool IsRoot(node *x) {
return (x->fa == NIL) || (x->fa->ch[0] != x && x->fa->ch[1] != x);
}
void SetChild(node *x, node *y, int d) {
x->ch[d] = y;
if (y != NIL) y->fa = x;
}
node *NewNode(int k, int id, int s) {
ncnt++;
ncnt->key = k, ncnt->id = id, ncnt->s = ncnt->siz1 = s;
ncnt->fa = ncnt->ch[0] = ncnt->ch[1] = NIL;
ncnt->mx = ncnt;
return ncnt;
}
void PushDown(node *x) {
if (x->rev) {
swap(x->ch[0], x->ch[1]);
if (x->ch[0] != NIL) x->ch[0]->rev ^= 1;
if (x->ch[1] != NIL) x->ch[1]->rev ^= 1;
x->rev = 0;
}
}
void PushUp(node *x) {
if (x->key > x->ch[0]->mx->key && x->key > x->ch[1]->mx->key)
x->mx = x;
else if (x->ch[0]->mx->key > x->ch[1]->mx->key)
x->mx = x->ch[0]->mx;
else
x->mx = x->ch[1]->mx;
x->siz1 = x->s + x->ch[0]->siz1 + x->ch[1]->siz1 + x->siz2;
}
void Rotate(node *x) {
node *y = x->fa;
PushDown(y), PushDown(x);
int d = (y->ch[1] == x);
if (IsRoot(y))
x->fa = y->fa;
else
SetChild(y->fa, x, y->fa->ch[1] == y);
SetChild(y, x->ch[!d], d);
SetChild(x, y, !d);
PushUp(y);
}
void Splay(node *x) {
PushDown(x);
while (!IsRoot(x)) {
node *y = x->fa;
if (IsRoot(y))
Rotate(x);
else {
if ((y->fa->ch[1] == y) == (y->ch[1] == x))
Rotate(y);
else
Rotate(x);
Rotate(x);
}
}
PushUp(x);
}
void Access(node *x) {
node *y = NIL;
while (x != NIL) {
Splay(x);
x->siz2 += x->ch[1]->siz1;
SetChild(x, y, 1);
x->siz2 -= x->ch[1]->siz1;
PushUp(x);
y = x, x = x->fa;
}
}
void MakeRoot(node *x) {
Access(x), Splay(x);
x->rev ^= 1;
}
void Link(node *x, node *y) {
MakeRoot(x);
MakeRoot(y);
x->fa = y;
y->siz2 += x->siz1;
}
void Cut(node *x, node *y) {
MakeRoot(x);
Access(y), Splay(y);
y->ch[0] = x->fa = NIL;
PushUp(y);
}
node *FindRoot(node *x) {
Access(x), Splay(x);
while (x->ch[0] != NIL) x = x->ch[0];
return x;
}
node *QueryMAX(node *x, node *y) {
MakeRoot(x);
Access(y);
Splay(y);
return y->mx;
}
int n, m, stot;
void Debug() {
for (it = Set.begin(); it != Set.end(); it++)
printf("(%d, %d, %d)\n", it->u, it->v, it->w);
}
int main() {
Init();
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) ad[i] = NewNode(-1, -1, 1);
stot = n;
for (int i = 1; i <= m; i++) {
e[i].id = i;
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
if (e[i].u == e[i].v) continue;
ad[n + i] = NewNode(e[i].w, i, 0);
Set.insert(e[i]);
if (FindRoot(ad[e[i].u]) == FindRoot(ad[e[i].v])) {
node *p = QueryMAX(ad[e[i].u], ad[e[i].v]);
Splay(p);
if (p->key > e[i].w) {
Set.erase(e[p->id]);
Cut(p, ad[e[p->id].u]), Cut(p, ad[e[p->id].v]);
Link(ad[e[i].u], ad[n + i]), Link(ad[e[i].v], ad[n + i]);
} else
Set.erase(e[i]);
} else {
MakeRoot(ad[e[i].u]), MakeRoot(ad[e[i].v]);
if (ad[e[i].u]->siz1 % 2 == 1 && ad[e[i].v]->siz1 % 2 == 1) stot -= 2;
Link(ad[e[i].u], ad[n + i]), Link(ad[e[i].v], ad[n + i]);
}
if (stot == 0) {
it = Set.end();
it--;
while (true) {
node *p = ad[n + it->id], *q = ad[e[it->id].u], *r = ad[e[it->id].v];
MakeRoot(p);
Access(q);
Access(r);
if (q->siz1 & 1) break;
Access(q);
if (r->siz1 & 1) break;
Set.erase(it);
Cut(p, q);
Cut(p, r);
it = Set.end();
it--;
}
it = Set.end();
it--;
printf("%d\n", it->w);
} else
printf("-1\n");
}
}
|
Students in a class are making towers of blocks. Each student makes a (non-zero) tower by stacking pieces lengthwise on top of each other. n of the students use pieces made of two blocks and m of the students use pieces made of three blocks.
The students don’t want to use too many blocks, but they also want to be unique, so no two students’ towers may contain the same number of blocks. Find the minimum height necessary for the tallest of the students' towers.
Input
The first line of the input contains two space-separated integers n and m (0 ≤ n, m ≤ 1 000 000, n + m > 0) — the number of students using two-block pieces and the number of students using three-block pieces, respectively.
Output
Print a single integer, denoting the minimum possible height of the tallest tower.
Examples
Input
1 3
Output
9
Input
3 2
Output
8
Input
5 0
Output
10
Note
In the first case, the student using two-block pieces can make a tower of height 4, and the students using three-block pieces can make towers of height 3, 6, and 9 blocks. The tallest tower has a height of 9 blocks.
In the second case, the students can make towers of heights 2, 4, and 8 with two-block pieces and towers of heights 3 and 6 with three-block pieces, for a maximum height of 8 blocks.
|
#include <bits/stdc++.h>
using namespace std;
int bs(int a, int l1, int r1, int n, int m) {
int l = l1, r = r1;
int mid;
while (r - l > 1) {
mid = l + (r - l) / 2;
if (mid / 2 + mid / 3 - mid / 6 >= a && mid / 2 >= n && mid / 3 >= m) {
r = mid;
} else {
l = mid;
}
}
if (l / 2 + l / 3 - l / 6 >= a && l / 2 >= n && l / 3 >= m) {
return l;
} else {
return r;
}
}
int main() {
int n, m;
cin >> n >> m;
int ans = bs(n + m, 0, 1000000000, n, m);
cout << ans << endl;
return 0;
}
|
Watchmen are in a danger and Doctor Manhattan together with his friend Daniel Dreiberg should warn them as soon as possible. There are n watchmen on a plane, the i-th watchman is located at point (xi, yi).
They need to arrange a plan, but there are some difficulties on their way. As you know, Doctor Manhattan considers the distance between watchmen i and j to be |xi - xj| + |yi - yj|. Daniel, as an ordinary person, calculates the distance using the formula <image>.
The success of the operation relies on the number of pairs (i, j) (1 ≤ i < j ≤ n), such that the distance between watchman i and watchmen j calculated by Doctor Manhattan is equal to the distance between them calculated by Daniel. You were asked to compute the number of such pairs.
Input
The first line of the input contains the single integer n (1 ≤ n ≤ 200 000) — the number of watchmen.
Each of the following n lines contains two integers xi and yi (|xi|, |yi| ≤ 109).
Some positions may coincide.
Output
Print the number of pairs of watchmen such that the distance between them calculated by Doctor Manhattan is equal to the distance calculated by Daniel.
Examples
Input
3
1 1
7 5
1 5
Output
2
Input
6
0 0
0 1
0 2
-1 1
0 1
1 1
Output
11
Note
In the first sample, the distance between watchman 1 and watchman 2 is equal to |1 - 7| + |1 - 5| = 10 for Doctor Manhattan and <image> for Daniel. For pairs (1, 1), (1, 5) and (7, 5), (1, 5) Doctor Manhattan and Daniel will calculate the same distances.
|
#include <bits/stdc++.h>
using namespace std;
void rdInt(int &n) {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
n = x * f;
}
map<int, int> mpx, mpy;
map<pair<int, int>, int> st;
int main() {
int n;
while (~scanf("%d", &n)) {
mpx.clear();
mpy.clear();
st.clear();
long long an = 0;
int x, y;
for (int i = 0; i < n; i++) {
rdInt(x);
rdInt(y);
an += mpx[x];
an += mpy[y];
an -= st[make_pair(x, y)];
mpx[x]++;
mpy[y]++;
st[make_pair(x, y)]++;
}
printf("%I64d\n", an);
}
return 0;
}
|
During the programming classes Vasya was assigned a difficult problem. However, he doesn't know how to code and was unable to find the solution in the Internet, so he asks you to help.
You are given a sequence a, consisting of n distinct integers, that is used to construct the binary search tree. Below is the formal description of the construction process.
1. First element a_1 becomes the root of the tree.
2. Elements a_2, a_3, …, a_n are added one by one. To add element a_i one needs to traverse the tree starting from the root and using the following rules:
1. The pointer to the current node is set to the root.
2. If a_i is greater than the value in the current node, then its right child becomes the current node. Otherwise, the left child of the current node becomes the new current node.
3. If at some point there is no required child, the new node is created, it is assigned value a_i and becomes the corresponding child of the current node.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the length of the sequence a.
The second line contains n distinct integers a_i (1 ≤ a_i ≤ 10^9) — the sequence a itself.
Output
Output n - 1 integers. For all i > 1 print the value written in the node that is the parent of the node with value a_i in it.
Examples
Input
3
1 2 3
Output
1 2
Input
5
4 2 3 1 6
Output
4 2 2 4
|
#include <bits/stdc++.h>
using namespace std;
set<int> a;
map<int, int> b;
set<int>::iterator k1, k2;
int n, x, k = 0;
int main() {
scanf("%d", &n);
scanf("%d", &x);
a.insert(x);
b[x] = 1;
for (int i = 1; i < n; ++i) {
scanf("%d", &x);
k1 = a.lower_bound(x);
if (k1 == a.end())
k1--, printf("%d ", *k1);
else if (k1 == a.begin()) {
printf("%d ", *k1);
} else {
k2 = k1;
k1--;
if (b[*k2] < b[*k1])
printf("%d ", *k1);
else
printf("%d ", *k2);
}
a.insert(x);
b[x] = i + 1;
}
return 0;
}
|
While creating high loaded systems one should pay a special attention to caching. This problem will be about one of the most popular caching algorithms called LRU (Least Recently Used).
Suppose the cache may store no more than k objects. At the beginning of the workflow the cache is empty. When some object is queried we check if it is present in the cache and move it here if it's not. If there are more than k objects in the cache after this, the least recently used one should be removed. In other words, we remove the object that has the smallest time of the last query.
Consider there are n videos being stored on the server, all of the same size. Cache can store no more than k videos and caching algorithm described above is applied. We know that any time a user enters the server he pick the video i with probability pi. The choice of the video is independent to any events before.
The goal of this problem is to count for each of the videos the probability it will be present in the cache after 10100 queries.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 20) — the number of videos and the size of the cache respectively. Next line contains n real numbers pi (0 ≤ pi ≤ 1), each of them is given with no more than two digits after decimal point.
It's guaranteed that the sum of all pi is equal to 1.
Output
Print n real numbers, the i-th of them should be equal to the probability that the i-th video will be present in the cache after 10100 queries. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 1
0.3 0.2 0.5
Output
0.3 0.2 0.5
Input
2 1
0.0 1.0
Output
0.0 1.0
Input
3 2
0.3 0.2 0.5
Output
0.675 0.4857142857142857 0.8392857142857143
Input
3 3
0.2 0.3 0.5
Output
1.0 1.0 1.0
|
#include <bits/stdc++.h>
using namespace std;
const int N = 30, mod = int(1e9) + 7;
const double eps = 1e-9;
int k, n;
double p[N];
long double dp[1 << 21], a[N];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%lf", &p[i]);
}
dp[0] = 1;
for (int mask = 0; mask < (1 << n); mask++) {
long double sum = 0;
for (int i = 0; i < n; i++) {
if (mask & (1 << i)) {
sum += p[i];
}
}
if (__builtin_popcount(mask) == k || abs(sum - 1) < eps) {
for (int i = 0; i < n; i++) {
if (mask & (1 << i)) {
a[i] += dp[mask];
}
}
continue;
}
for (int i = 0; i < n; i++) {
if (!(mask & (1 << i))) {
int nmask = mask | (1 << i);
dp[nmask] += dp[mask] * p[i] / (1 - sum);
}
}
}
for (int i = 0; i < n; i++) {
printf("%.12lf ", double(a[i]));
}
return 0;
}
|
Tree is a connected undirected graph that has no cycles. Edge cactus is a connected undirected graph without loops and parallel edges, such that each edge belongs to at most one cycle.
Vasya has an edge cactus, each edge of this graph has some color.
Vasya would like to remove the minimal number of edges in such way that his cactus turned to a tree. Vasya wants to make it in such a way that there were edges of as many different colors in the resulting tree, as possible. Help him to find how many different colors can the resulting tree have.
Input
The first line contains two integers: n, m (2 ≤ n ≤ 10 000) — the number of vertices and the number of edges in Vasya's graph, respectively.
The following m lines contain three integers each: u, v, c (1 ≤ u, v ≤ n, u ≠ v, 1 ≤ c ≤ m) — the numbers of vertices connected by the corresponding edge, and its color. It is guaranteed that the described graph is indeed an edge cactus.
Output
Output one integer: the maximal number of different colors that the resulting tree can have.
Examples
Input
4 4
1 2 4
2 3 1
3 4 2
4 2 3
Output
3
Input
7 9
1 2 1
2 3 4
3 1 5
1 4 5
4 5 2
5 1 6
1 6 4
6 7 6
7 1 3
Output
6
|
#include <bits/stdc++.h>
using namespace std;
queue<int> q;
int fa[10000 + 10], dfn[10000 + 10], n, m, tot, dcnt, S, T, cnt = 1;
bool vis[10000 * 4 + 10];
void Read(int &x) {
char c;
while (c = getchar(), c != EOF)
if (c >= '0' && c <= '9') {
x = c - '0';
while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
ungetc(c, stdin);
return;
}
}
namespace MAXFLOW {
int dist[10000 * 3 + 10], vd[10000 * 3 + 10];
bool vis[10000 * 3 + 10];
struct node {
int v, cap;
node *next, *back;
} * adj[10000 * 3 + 10], edge[10000 * 20 + 10], *ecnt = edge;
inline void addedge(int u, int v, int cap) {
node *p = ++ecnt;
p->v = v;
p->cap = cap;
p->next = adj[u];
adj[u] = p;
p = p->back = ++ecnt;
p->v = u;
p->cap = 0;
p->next = adj[v];
adj[v] = p;
p->back = ecnt - 1;
}
void spfa(int S) {
int i, u;
for (i = 1; i <= tot; i++) dist[i] = 0x7fffffff;
dist[S] = 0;
q.push(S);
while (!q.empty()) {
u = q.front();
q.pop();
vis[u] = 0;
for (node *p = adj[u]; p; p = p->next) {
if (p->back->cap && dist[p->v] > dist[u] + 1) {
dist[p->v] = dist[u] + 1;
if (!vis[p->v]) q.push(p->v), vis[p->v] = 1;
}
}
}
}
int dfs(int u, int augu) {
if (u == T) return augu;
int mind = tot - 1, delta, augv = 0;
for (node *p = adj[u]; p; p = p->next) {
if (p->cap) {
if (dist[u] == dist[p->v] + 1) {
delta = min(p->cap, augu - augv);
delta = dfs(p->v, delta);
p->cap -= delta;
p->back->cap += delta;
augv += delta;
if (augv == augu || dist[S] >= tot) return augv;
}
mind = min(dist[p->v], mind);
}
}
if (!augv) {
if (!--vd[dist[u]]) dist[S] = tot;
vd[dist[u] = mind + 1]++;
}
return augv;
}
int sap() {
int flow = 0, i;
spfa(T);
for (i = 1; i <= tot; i++) vd[i] = 0;
for (i = 1; i <= tot; i++)
if (dist[i] != 0x7fffffff) vd[dist[i]]++;
while (dist[S] < tot) flow += dfs(S, 0x7fffffff);
return flow;
}
} // namespace MAXFLOW
struct node {
int v, c;
node *next;
} * adj[10000 + 10], edge[10000 * 4 + 10], *ecnt = edge, *pre[10000 * 2 + 10];
inline void addedge(int u, int v, int c) {
node *p = ++ecnt;
p->v = v;
p->c = c;
p->next = adj[u];
adj[u] = p;
}
void dfs(int u) {
dfn[u] = ++dcnt;
for (node *p = adj[u]; p; p = p->next) {
if (p->v != fa[u]) {
if (!dfn[p->v]) {
pre[p->v] = p;
fa[p->v] = u;
dfs(p->v);
if (!vis[p - edge]) MAXFLOW::addedge(p->c, m + 3, 1);
} else if (dfn[p->v] < dfn[u]) {
int x = u, num = 0;
cnt++;
MAXFLOW::addedge(p->c, cnt + m + 2, 1);
while (x != p->v) {
MAXFLOW::addedge(pre[x]->c, cnt + m + 2, 1);
vis[pre[x] - edge] = 1;
x = fa[x];
num++;
}
MAXFLOW::addedge(cnt + m + 2, T, num);
}
}
}
}
void read() {
Read(n), Read(m);
int i, u, v, c;
for (i = 1; i <= m; i++) {
Read(u), Read(v), Read(c);
addedge(u, v, c);
addedge(v, u, c);
}
S = m + 1, T = S + 1;
}
void solve() {
dfs(1);
MAXFLOW::addedge(m + 3, T, 0x7fffffff);
tot = cnt + m + 2;
for (int i = 1; i <= m; i++) MAXFLOW::addedge(S, i, 1);
}
int main() {
read();
solve();
printf("%d\n", MAXFLOW::sap());
}
|
Just in case somebody missed it: we have wonderful girls in Arpa’s land.
Arpa has a rooted tree (connected acyclic graph) consisting of n vertices. The vertices are numbered 1 through n, the vertex 1 is the root. There is a letter written on each edge of this tree. Mehrdad is a fan of Dokhtar-kosh things. He call a string Dokhtar-kosh, if we can shuffle the characters in string such that it becomes palindrome.
<image>
He asks Arpa, for each vertex v, what is the length of the longest simple path in subtree of v that form a Dokhtar-kosh string.
Input
The first line contains integer n (1 ≤ n ≤ 5·105) — the number of vertices in the tree.
(n - 1) lines follow, the i-th of them contain an integer pi + 1 and a letter ci + 1 (1 ≤ pi + 1 ≤ i, ci + 1 is lowercase English letter, between a and v, inclusively), that mean that there is an edge between nodes pi + 1 and i + 1 and there is a letter ci + 1 written on this edge.
Output
Print n integers. The i-th of them should be the length of the longest simple path in subtree of the i-th vertex that form a Dokhtar-kosh string.
Examples
Input
4
1 s
2 a
3 s
Output
3 1 1 0
Input
5
1 a
2 h
1 a
4 h
Output
4 1 0 1 0
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0.0) * 2.0;
const long double eps = 1e-10;
const int step[8][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1},
{-1, 1}, {1, 1}, {1, -1}, {-1, -1}};
template <class T>
inline T abs1(T a) {
return a < 0 ? -a : a;
}
template <typename t, typename t1>
t min1(t a, t1 b) {
return a < b ? a : b;
}
template <typename t, typename... arg>
t min1(t a, arg... arr) {
return min1(a, min1(arr...));
}
template <typename t, typename t1>
t max1(t a, t1 b) {
return a > b ? a : b;
}
template <typename t, typename... arg>
t max1(t a, arg... arr) {
return max1(a, max1(arr...));
}
inline int jud(double a, double b) {
if (abs(a) < eps && abs(b) < eps)
return 0;
else if (abs1(a - b) / max(abs1(a), abs1(b)) < eps)
return 0;
if (a < b) return -1;
return 1;
}
template <typename t>
inline int jud(t a, t b) {
if (a < b) return -1;
if (a == b) return 0;
return 1;
}
template <typename it, typename t1>
inline int find(t1 val, it a, int na, bool f_small = 1, bool f_lb = 1) {
if (na == 0) return 0;
int be = 0, en = na - 1;
if (*a <= *(a + na - 1)) {
if (f_lb == 0)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != 1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != -1)
en = mid;
else
be = mid + 1;
}
if (f_small && jud(*(a + be), val) == 1) be--;
if (!f_small && jud(*(a + be), val) == -1) be++;
} else {
if (f_lb)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != -1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != 1)
en = mid;
else
be = mid + 1;
}
if (!f_small && jud(*(a + be), val) == -1) be--;
if (f_small && jud(*(a + be), val) == 1) be++;
}
return be;
}
template <class T>
inline T lowb(T num) {
return num & (-num);
}
inline int bitnum(unsigned int nValue) { return __builtin_popcount(nValue); }
inline int bitnum(int nValue) { return __builtin_popcount(nValue); }
inline int bitnum(unsigned long long nValue) {
return __builtin_popcount(nValue) + __builtin_popcount(nValue >> 32);
}
inline int bitnum(long long nValue) {
return __builtin_popcount(nValue) + __builtin_popcount(nValue >> 32);
}
inline int bitmaxl(unsigned int a) {
if (a == 0) return 0;
return 32 - __builtin_clz(a);
}
inline int bitmaxl(int a) {
if (a == 0) return 0;
return 32 - __builtin_clz(a);
}
inline int bitmaxl(unsigned long long a) {
int temp = a >> 32;
if (temp) return 32 - __builtin_clz(temp) + 32;
return bitmaxl(int(a));
}
inline int bitmaxl(long long a) {
int temp = a >> 32;
if (temp) return 32 - __builtin_clz(temp) + 32;
return bitmaxl(int(a));
}
long long pow(long long n, long long m, long long mod = 0) {
if (m < 0) return 0;
long long ans = 1;
long long k = n;
while (m) {
if (m & 1) {
ans *= k;
if (mod) ans %= mod;
}
k *= k;
if (mod) k %= mod;
m >>= 1;
}
return ans;
}
template <class t1, class t2>
inline void add(t1 &a, t2 b, int mod = -1) {
if (mod == -1) mod = 1000000007;
a += b;
while (a >= mod) a -= mod;
while (a < 0) a += mod;
}
template <class t>
void output1(t arr) {
for (int i = 0; i < (int)arr.size(); i++) cerr << arr[i] << ' ';
cerr << endl;
}
template <class t>
void output2(t arr) {
for (int i = 0; i < (int)arr.size(); i++) output1(arr[i]);
}
const int maxn = 500100;
struct edge {
int to, nxt, ch;
} e[maxn * 2];
int head[maxn], le;
int fa[maxn];
int deep[maxn], sz[maxn], bs[maxn], val[maxn];
int n;
int ans[maxn];
int table[1 << 22];
int tans;
void addedge(int a, int b, int ch) {
e[le].to = b;
e[le].nxt = head[a];
e[le].ch = ch;
head[a] = le++;
}
void del(int no) {
table[val[no]] = -n;
for (int i = head[no]; i != -1; i = e[i].nxt) del(e[i].to);
}
void getans(int no, int op) {
tans = max(table[val[no]] + deep[no] - op * 2, tans);
for (int i = 0; i < 22; i++) {
tans = max(tans, table[val[no] ^ (1 << i)] + deep[no] - op * 2);
}
for (int i = head[no]; i != -1; i = e[i].nxt) getans(e[i].to, op);
}
void upd(int no) {
table[val[no]] = max(table[val[no]], deep[no]);
for (int i = head[no]; i != -1; i = e[i].nxt) upd(e[i].to);
}
void dfssz(int no) {
sz[no] = 1;
for (int i = head[no]; i != -1; i = e[i].nxt) {
deep[e[i].to] = deep[no] + 1;
val[e[i].to] = 1 << e[i].ch;
val[e[i].to] ^= val[no];
dfssz(e[i].to);
sz[no] += sz[e[i].to];
if (bs[no] == 0 || sz[e[i].to] > sz[bs[no]]) bs[no] = e[i].to;
}
}
void dfs(int no) {
for (int i = head[no]; i != -1; i = e[i].nxt)
if (e[i].to != bs[no]) {
dfs(e[i].to);
}
if (bs[no] != 0) dfs(bs[no]);
table[val[no]] = max(table[val[no]], deep[no]);
tans = max(0, table[val[no]] - deep[no]);
for (int i = 0; i < 22; i++)
tans = max(tans, table[val[no] ^ (1 << i)] - deep[no]);
for (int i = head[no]; i != -1; i = e[i].nxt)
if (e[i].to != bs[no]) {
getans(e[i].to, deep[no]);
upd(e[i].to);
}
ans[no] = tans;
if (fa[no] != -1 && bs[fa[no]] != no) {
table[val[no]] = -n;
for (int i = head[no]; i != -1; i = e[i].nxt) del(e[i].to);
}
for (int i = head[no]; i != -1; i = e[i].nxt)
ans[no] = max(ans[no], ans[e[i].to]);
}
int main() {
ios_base::sync_with_stdio(0);
memset(head, -1, sizeof(head));
fa[0] = -1;
scanf("%d", &n);
for (int i = 0; i < 1 << 22; i++) table[i] = -n;
for (int i = 1; i < n; i++) {
int no;
char str[3];
scanf("%d%s", &no, str);
no--;
fa[i] = no;
addedge(no, i, str[0] - 'a');
}
dfssz(0);
dfs(0);
for (int i = 0; i < n; i++) printf("%d\n", ans[i]);
return 0;
}
|
Misha and Vanya have played several table tennis sets. Each set consists of several serves, each serve is won by one of the players, he receives one point and the loser receives nothing. Once one of the players scores exactly k points, the score is reset and a new set begins.
Across all the sets Misha scored a points in total, and Vanya scored b points. Given this information, determine the maximum number of sets they could have played, or that the situation is impossible.
Note that the game consisted of several complete sets.
Input
The first line contains three space-separated integers k, a and b (1 ≤ k ≤ 109, 0 ≤ a, b ≤ 109, a + b > 0).
Output
If the situation is impossible, print a single number -1. Otherwise, print the maximum possible number of sets.
Examples
Input
11 11 5
Output
1
Input
11 2 3
Output
-1
Note
Note that the rules of the game in this problem differ from the real table tennis game, for example, the rule of "balance" (the winning player has to be at least two points ahead to win a set) has no power within the present problem.
|
import java.util.Scanner;
public class C765 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int K = in.nextInt();
int A = in.nextInt();
int B = in.nextInt();
int sets = A/K + B/K;
if ((A%K != 0 && B < K) || (B%K != 0 && A < K)) {
sets = -1;
}
System.out.println(sets);
}
}
|
On the 228-th international Uzhlyandian Wars strategic game tournament teams from each country are called. The teams should consist of 5 participants.
The team of Uzhlyandia will consist of soldiers, because there are no gamers.
Masha is a new minister of defense and gaming. The prime duty of the minister is to calculate the efficiency of the Uzhlandian army. The army consists of n soldiers standing in a row, enumerated from 1 to n. For each soldier we know his skill in Uzhlyandian Wars: the i-th soldier's skill is ai.
It was decided that the team will consist of three players and two assistants. The skills of players should be same, and the assistants' skills should not be greater than the players' skill. Moreover, it is important for Masha that one of the assistants should stand in the row to the left of the players, and the other one should stand in the row to the right of the players. Formally, a team is five soldiers with indexes i, j, k, l, p, such that 1 ≤ i < j < k < l < p ≤ n and ai ≤ aj = ak = al ≥ ap.
The efficiency of the army is the number of different teams Masha can choose. Two teams are considered different if there is such i such that the i-th soldier is a member of one team, but not a member of the other team.
Initially, all players are able to be players. For some reasons, sometimes some soldiers become unable to be players. Sometimes some soldiers, that were unable to be players, become able to be players. At any time any soldier is able to be an assistant. Masha wants to control the efficiency of the army, so she asked you to tell her the number of different possible teams modulo 1000000007 (109 + 7) after each change.
Input
The first line contains single integer n (1 ≤ n ≤ 105) — the number of soldiers in Uzhlyandia.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the soldiers' skills.
The third line contains single integer m (1 ≤ m ≤ 105) — the number of changes.
The next m lines contain the changes, each change is described with two integers t and x (1 ≤ t ≤ 2, 1 ≤ x ≤ n) on a separate line. If t = 1, then the x-th soldier is unable to be a player after this change. If t = 2, then the x-th soldier is able to be a player after this change.
It is guaranteed that before each query of the first type the soldier is able to be a player, and before each query of the second type the soldier is unable to be a player.
Output
Print m integers — the number of distinct teams after each change.
Print the answers modulo 1000000007 (109 + 7).
Examples
Input
6
1 1 1 1 1 1
2
1 3
2 3
Output
1
6
Input
8
3 4 4 2 4 5 4 1
3
1 5
2 5
1 2
Output
1
6
2
Note
In the first example, after the first change the only team consists of soldiers [1, 2, 4, 5, 6]. After the second change any five soldiers can form a team.
In the first example after the first change the only team is soldiers [1, 2, 3, 7, 8]. After the second change the possible teams are: [1, 2, 3, 5, 7], [1, 2, 3, 5, 8], [1, 2, 3, 7, 8], [1, 2, 5, 7, 8], [1, 3, 5, 7, 8], [2, 3, 5, 7, 8]. After the third change the possible teams are: [1, 3, 5, 7, 8], [2, 3, 5, 7, 8].
|
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1e9 + 7;
const long long linf = 1ll << 60;
const double dinf = 1e60;
template <typename T>
inline void scf(T &x) {
bool f = 0;
x = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (f) x = -x;
return;
}
template <typename T1, typename T2>
void scf(T1 &x, T2 &y) {
scf(x);
return scf(y);
}
template <typename T1, typename T2, typename T3>
void scf(T1 &x, T2 &y, T3 &z) {
scf(x);
scf(y);
return scf(z);
}
template <typename T1, typename T2, typename T3, typename T4>
void scf(T1 &x, T2 &y, T3 &z, T4 &w) {
scf(x);
scf(y);
scf(z);
return scf(w);
}
inline char mygetchar() {
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
template <typename T>
void chkmax(T &x, const T &y) {
if (y > x) x = y;
return;
}
template <typename T>
void chkmin(T &x, const T &y) {
if (y < x) x = y;
return;
}
void TZL();
void RANK1();
int main() {
TZL();
RANK1();
return 0;
}
const int N = 1e5 + 100;
const int mod = 1e9 + 7;
struct node {
int f[3][3];
node() { memset((f), (0), sizeof((f))); }
node(int cntl, int cntr) {
memset((f), (0), sizeof((f)));
f[0][0] = cntl;
f[2][2] = cntr;
f[1][1] = 1;
return;
}
node operator+(const node &a) const {
node ret;
memcpy((ret.f), (f), sizeof((f)));
for (int l = 0, _end_ = (3); l < _end_; ++l)
for (int r = 0, _end_ = (3); r < _end_; ++r)
(ret.f[l][r] += a.f[l][r]) %= mod;
for (int l = 0, _end_ = (2); l < _end_; ++l)
for (int r = (l + 1), _end_ = (2); r <= _end_; ++r)
for (int mid = (l), _end_ = (r - 1); mid <= _end_; ++mid) {
ret.f[l][r] =
(1ll * ret.f[l][r] + 1ll * f[l][mid] * a.f[mid + 1][r]) % mod;
}
return ret;
}
};
struct seg {
int n;
struct node {
::node f;
node *l, *r;
void pull() {
if (l && r) f = l->f + r->f;
return;
}
} * root;
void B(node *&cur, int l, int r, int *a, int *b) {
cur = new node;
if (l == r) {
cur->f = ::node(a[l], b[l]);
return;
}
int mid = l + r >> 1;
B(cur->l, l, mid, a, b);
B(cur->r, mid + 1, r, a, b);
return cur->pull();
}
void M(node *&cur, int i, ::node x, int l, int r) {
if (l == r) {
cur->f = x;
return;
}
int mid = l + r >> 1;
if (i > mid)
M(cur->r, i, x, mid + 1, r);
else
M(cur->l, i, x, l, mid);
return cur->pull();
}
int Q() { return root->f.f[0][2]; }
void B(int _n, int *cntl, int *cntr) {
B(root, 1, n = _n, cntl, cntr);
return;
}
void M(int i, ::node x) { return M(root, i, x, 1, n); }
void out(node *cur, int l, int r, int dep = 1) {
if (!cur) return;
int mid = l + r >> 1;
out(cur->l, l, mid, dep + 1);
for (int i = 0, _end_ = (dep); i < _end_; ++i) putchar('\t');
printf("[%d, %d]:\n", l, r);
for (int i = 0, _end_ = (3); i < _end_; ++i) {
for (int j = 0, _end_ = (dep + 1); j < _end_; ++j) putchar('\t');
for (int j = 0, _end_ = (3); j < _end_; ++j)
printf("%d ", cur->f.f[i][j]);
putchar('\n');
}
for (int i = 0, _end_ = (dep); i < _end_; ++i) putchar('\t');
puts("============");
out(cur->r, mid + 1, r, dep + 1);
return;
}
void out() { return out(root, 1, n); }
} rt[N];
int n, m, ans;
int a[N], cntl[N], cntr[N];
vector<int> apr[N];
namespace BIT {
int num[N];
int lowbit(int i) { return i & (-i); }
void M(int i) {
for (; i <= m; i += lowbit(i)) num[i]++;
return;
}
int Q(int i) {
int ret = 0;
for (; i; i ^= lowbit(i)) ret += num[i];
return ret;
}
void B() {
memset((num), (0), sizeof((num)));
return;
}
} // namespace BIT
void TZL() {
map<int, int> M;
M.clear();
scf(n);
for (int i = (1), _end_ = (n); i <= _end_; ++i) {
scf(a[i]);
M[a[i]];
}
for (auto it = M.begin(); it != M.end(); ++it) it->second = (++m);
for (int i = (1), _end_ = (n); i <= _end_; ++i) a[i] = M[a[i]];
for (int i = (1), _end_ = (n); i <= _end_; ++i) {
cntl[i] = BIT::Q(a[i]);
BIT::M(a[i]);
}
BIT::B();
for (int i = (n), _end_ = (1); i >= _end_; --i) {
cntr[i] = BIT::Q(a[i]);
BIT::M(a[i]);
}
for (int i = (1), _end_ = (n); i <= _end_; ++i) apr[a[i]].push_back(i);
static int foo[N], bar[N];
for (int i = (1), _end_ = (m); i <= _end_; ++i) {
int pnt = 0;
for (int x : apr[i]) {
++pnt;
foo[pnt] = cntl[x];
bar[pnt] = cntr[x];
}
rt[i].B(pnt, foo, bar);
(ans += rt[i].Q()) %= mod;
}
return;
}
void RANK1() {
int q_n;
scf(q_n);
while (q_n--) {
int typ, i;
scf(typ, i);
int x = a[i],
j = lower_bound(apr[x].begin(), apr[x].end(), i) - apr[x].begin() + 1;
(ans += mod - rt[x].Q()) %= mod;
node nw;
if (typ == 2) nw = node(cntl[i], cntr[i]);
rt[x].M(j, nw);
(ans += rt[x].Q()) %= mod;
printf("%d\n", ans);
}
return;
}
|
Do you remember a kind cartoon "Beauty and the Beast"? No, no, there was no firing from machine guns or radiation mutants time-travels!
There was a beauty named Belle. Once she had violated the Beast's order and visited the West Wing. After that she was banished from the castle...
Everybody was upset. The beautiful Belle was upset, so was the Beast, so was Lumiere the candlestick. But the worst thing was that Cogsworth was upset. Cogsworth is not a human, but is the mantel clock, which was often used as an alarm clock.
Due to Cogsworth's frustration all the inhabitants of the castle were in trouble: now they could not determine when it was time to drink morning tea, and when it was time for an evening stroll.
Fortunately, deep in the basement are lying digital clock showing the time in the format HH:MM. Now the residents of the castle face a difficult task. They should turn Cogsworth's hour and minute mustache hands in such a way, that Cogsworth began to show the correct time. Moreover they need to find turn angles in degrees for each mustache hands. The initial time showed by Cogsworth is 12:00.
You can only rotate the hands forward, that is, as is shown in the picture:
<image>
As since there are many ways too select such angles because of full rotations, choose the smallest angles in the right (non-negative) direction.
Note that Cogsworth's hour and minute mustache hands move evenly and continuously. Hands are moving independently, so when turning one hand the other hand remains standing still.
Input
The only line of input contains current time according to the digital clock, formatted as HH:MM (00 ≤ HH ≤ 23, 00 ≤ MM ≤ 59). The mantel clock initially shows 12:00.
Pretests contain times of the beginning of some morning TV programs of the Channel One Russia.
Output
Print two numbers x and y — the angles of turning the hour and minute hands, respectively (0 ≤ x, y < 360). The absolute or relative error in the answer should not exceed 10 - 9.
Examples
Input
12:00
Output
0 0
Input
04:30
Output
135 180
Input
08:17
Output
248.5 102
Note
A note to the second example: the hour hand will be positioned exactly in the middle, between 4 and 5.
|
#include <bits/stdc++.h>
using namespace std;
char *pt;
long get_int() {
long temp = 0;
while (*pt < '0' && *pt > '9') pt++;
while (*pt >= '0' && *pt <= '9') {
temp = temp * 10 + (*pt - '0');
pt++;
}
pt++;
return temp;
}
long long gcd(long long a, long long b) {
if (b == 1 || a == 1) return 1;
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
long long fastPower(long long a, long long b) {
if (b == 0) return 1;
if (b == 1) return a % 747474747;
long long ans = fastPower(a, b / 2);
ans *= ans;
ans %= 747474747;
if (b % 2) ans *= a;
return ans % 747474747;
}
long long fastPowerCustomMod(long long a, long long b, long long c) {
if (b == 0) return 1;
if (b == 1) return a % c;
long long ans = fastPower(a, b / 2);
ans *= ans;
ans %= c;
if (b % 2) ans *= a;
return ans % c;
}
int is_prime(long long num) {
if (num == 2 || num == 3) return 1;
if (num % 2 == 0 || num % 3 == 0) return 0;
long long i = 5, w = 2;
while (i * i <= num) {
if (num % i == 0) return 0;
i += w;
w = 6 - w;
}
return 1;
}
int compare(const void *a, const void *b) {
return (*(long long *)a - *(long long *)b);
}
int dec_compare(const void *a, const void *b) {
return (-*(int *)a + *(int *)b);
}
long long eularTotient(long long n) {
long long result = n;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) result -= result / i;
while (n % i == 0) n /= i;
}
if (n > 1) result -= result / n;
return result;
}
FILE *in, *out;
char str[1000000];
int main() {
scanf("%s", str);
int h, min;
h = (str[0] - '0') * 10 + str[1] - '0';
min = (str[3] - '0') * 10 + str[4] - '0';
float a, b;
a = h * 30.0 + (min * 30.0) / 60.0;
b = min * 6.0;
while (a >= 360.0) a -= 360.0;
while (b >= 360.0) b -= 360.0;
cout << a << " " << b << endl;
return 0;
}
|
<image>
Recently, a wild Krakozyabra appeared at Jelly Castle. It is, truth to be said, always eager to have something for dinner.
Its favorite meal is natural numbers (typically served with honey sauce), or, to be more precise, the zeros in their corresponding decimal representations. As for other digits, Krakozyabra dislikes them; moreover, they often cause it indigestion! So, as a necessary precaution, Krakozyabra prefers to sort the digits of a number in non-descending order before proceeding to feast. Then, the leading zeros of the resulting number are eaten and the remaining part is discarded as an inedible tail.
For example, if Krakozyabra is to have the number 57040 for dinner, its inedible tail would be the number 457.
Slastyona is not really fond of the idea of Krakozyabra living in her castle. Hovewer, her natural hospitality prevents her from leaving her guest without food. Slastyona has a range of natural numbers from L to R, which she is going to feed the guest with. Help her determine how many distinct inedible tails are going to be discarded by Krakozyabra by the end of the dinner.
Input
In the first and only string, the numbers L and R are given – the boundaries of the range (1 ≤ L ≤ R ≤ 1018).
Output
Output the sole number – the answer for the problem.
Examples
Input
1 10
Output
9
Input
40 57
Output
17
Input
157 165
Output
9
Note
In the first sample case, the inedible tails are the numbers from 1 to 9. Note that 10 and 1 have the same inedible tail – the number 1.
In the second sample case, each number has a unique inedible tail, except for the pair 45, 54. The answer to this sample case is going to be (57 - 40 + 1) - 1 = 17.
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e17;
const long long maxn = 2e5 + 700;
const int mod = 1e9 + 7;
template <typename T>
inline void read(T &a) {
char c = getchar();
T x = 0, f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
a = f * x;
}
long long n, m, p;
char s[maxn];
int a[maxn], b[maxn];
int digit(long long x, int *d) {
int ans = 0;
while (x) {
d[++ans] = x % 10;
x /= 10;
}
return ans;
}
int path[maxn];
int check(int pos, int lbound, int rbound) {
if (!pos) return 1;
if (!lbound && !rbound) return 1;
int l = lbound ? a[pos] : 0;
int r = rbound ? b[pos] : 9;
for (int i = l; i <= r; i++) {
if (path[i] > 0) {
path[i]--;
if (check(pos - 1, lbound && i == l, rbound && i == r)) {
path[i]++;
return 1;
}
path[i]++;
}
}
return 0;
}
int pos, res = 0;
void dfs(int u, int w) {
if (u == 9) {
path[u] = w;
if (check(pos, 1, 1)) res++;
return;
}
for (int i = 0; i <= w; i++) {
path[u] = i;
dfs(u + 1, w - i);
}
}
int main() {
read(n);
read(m);
pos = digit(n, a);
pos = digit(m, b);
dfs(0, pos);
printf("%d\n", res);
return 0;
}
|
Harry, Ron and Hermione have figured out that Helga Hufflepuff's cup is a horcrux. Through her encounter with Bellatrix Lestrange, Hermione came to know that the cup is present in Bellatrix's family vault in Gringott's Wizarding Bank.
The Wizarding bank is in the form of a tree with total n vaults where each vault has some type, denoted by a number between 1 to m. A tree is an undirected connected graph with no cycles.
The vaults with the highest security are of type k, and all vaults of type k have the highest security.
There can be at most x vaults of highest security.
Also, if a vault is of the highest security, its adjacent vaults are guaranteed to not be of the highest security and their type is guaranteed to be less than k.
Harry wants to consider every possibility so that he can easily find the best path to reach Bellatrix's vault. So, you have to tell him, given the tree structure of Gringotts, the number of possible ways of giving each vault a type such that the above conditions hold.
Input
The first line of input contains two space separated integers, n and m — the number of vaults and the number of different vault types possible. (1 ≤ n ≤ 105, 1 ≤ m ≤ 109).
Each of the next n - 1 lines contain two space separated integers ui and vi (1 ≤ ui, vi ≤ n) representing the i-th edge, which shows there is a path between the two vaults ui and vi. It is guaranteed that the given graph is a tree.
The last line of input contains two integers k and x (1 ≤ k ≤ m, 1 ≤ x ≤ 10), the type of the highest security vault and the maximum possible number of vaults of highest security.
Output
Output a single integer, the number of ways of giving each vault a type following the conditions modulo 109 + 7.
Examples
Input
4 2
1 2
2 3
1 4
1 2
Output
1
Input
3 3
1 2
1 3
2 1
Output
13
Input
3 1
1 2
1 3
1 1
Output
0
Note
In test case 1, we cannot have any vault of the highest security as its type is 1 implying that its adjacent vaults would have to have a vault type less than 1, which is not allowed. Thus, there is only one possible combination, in which all the vaults have type 2.
|
#include <bits/stdc++.h>
using namespace std;
long long INV2 = 500000004;
long long INV6 = 166666668;
long long power(long long a, long long b, long long c) {
long long x = 1, y = a;
while (b > 0) {
if (b & 1) x = (x * y) % c;
y = (y * y) % c;
b /= 2;
}
return x % c;
}
int dx[] = {0, -1, 0, 1};
int dy[] = {-1, 0, 1, 0};
int dr[] = {1, 1, 0, -1, -1, -1, 0, 1};
int dc[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int N = 1e5 + 5, M = 15;
long long n, m, dp[N][M][5], aux[M][5], k, x;
vector<int> v[N];
bool vis[N];
void dfs(int node) {
vis[node] = 1;
dp[node][0][0] = k - 1;
dp[node][1][1] = 1;
dp[node][0][2] = m - k;
for (auto u : v[node]) {
if (!vis[u]) {
dfs(u);
for (int i = 0; i < 3; ++i) {
for (int j = 0; j <= x; ++j) {
aux[j][i] = 0;
}
}
for (int i = x; i >= 0; --i) {
for (int j = 0; j <= i; ++j) {
aux[i][0] = (aux[i][0] + (dp[node][i - j][0] *
(dp[u][j][0] + dp[u][j][1] + dp[u][j][2])) %
1000000007) %
1000000007;
aux[i][1] =
(aux[i][1] + (dp[node][i - j][1] * dp[u][j][0]) % 1000000007) %
1000000007;
aux[i][2] =
(aux[i][2] + (dp[node][i - j][2] * (dp[u][j][0] + dp[u][j][2])) %
1000000007) %
1000000007;
}
}
for (int i = 0; i < 3; ++i) {
for (int j = 0; j <= x; ++j) {
dp[node][j][i] = aux[j][i];
}
}
}
}
return;
}
int main() {
scanf("%lld%lld", &n, &m);
for (int i = 0; i < n - 1; ++i) {
int xx, yy;
scanf("%d%d", &xx, &yy);
v[xx].push_back(yy);
v[yy].push_back(xx);
}
scanf("%lld%lld", &k, &x);
dfs(1);
long long ans = 0;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j <= x; ++j) {
ans = (ans + dp[1][j][i]) % 1000000007;
}
}
printf("%lld\n", ans);
return 0;
}
|
Vasya the programmer lives in the middle of the Programming subway branch. He has two girlfriends: Dasha and Masha, who live at the different ends of the branch, each one is unaware of the other one's existence.
When Vasya has some free time, he goes to one of his girlfriends. He descends into the subway at some time, waits the first train to come and rides on it to the end of the branch to the corresponding girl. However, the trains run with different frequencies: a train goes to Dasha's direction every a minutes, but a train goes to Masha's direction every b minutes. If two trains approach at the same time, Vasya goes toward the direction with the lower frequency of going trains, that is, to the girl, to whose directions the trains go less frequently (see the note to the third sample).
We know that the trains begin to go simultaneously before Vasya appears. That is the train schedule is such that there exists a moment of time when the two trains arrive simultaneously.
Help Vasya count to which girlfriend he will go more often.
Input
The first line contains two integers a and b (a ≠ b, 1 ≤ a, b ≤ 106).
Output
Print "Dasha" if Vasya will go to Dasha more frequently, "Masha" if he will go to Masha more frequently, or "Equal" if he will go to both girlfriends with the same frequency.
Examples
Input
3 7
Output
Dasha
Input
5 3
Output
Masha
Input
2 3
Output
Equal
Note
Let's take a look at the third sample. Let the trains start to go at the zero moment of time. It is clear that the moments of the trains' arrival will be periodic with period 6. That's why it is enough to show that if Vasya descends to the subway at a moment of time inside the interval (0, 6], he will go to both girls equally often.
If he descends to the subway at a moment of time from 0 to 2, he leaves for Dasha on the train that arrives by the second minute.
If he descends to the subway at a moment of time from 2 to 3, he leaves for Masha on the train that arrives by the third minute.
If he descends to the subway at a moment of time from 3 to 4, he leaves for Dasha on the train that arrives by the fourth minute.
If he descends to the subway at a moment of time from 4 to 6, he waits for both trains to arrive by the sixth minute and goes to Masha as trains go less often in Masha's direction.
In sum Masha and Dasha get equal time — three minutes for each one, thus, Vasya will go to both girlfriends equally often.
|
#include <bits/stdc++.h>
using namespace std;
inline int SG(double x) { return x > -1E-8 ? x < 1E-8 ? 0 : 1 : -1; }
long long gcd(long long a, long long b) {
while ((a %= b) && (b %= a))
;
return a + b;
}
int main() {
long long a, b, i, j, d, sa;
scanf("%I64d %I64d", &a, &b);
d = a * b / gcd(a, b);
sa = 0;
for (i = 1, j = 0; i * a < d; i++) {
while (j * b < i * a) j++;
if ((j - 1) * b < (i - 1) * a) {
sa += a;
} else {
sa += i * a - (j - 1) * b;
}
}
if (a > b) {
sa += b;
}
if (sa > d - sa) {
puts("Dasha");
} else if (sa < d - sa) {
puts("Masha");
} else {
puts("Equal");
}
return 0;
}
|
Mishka has got n empty boxes. For every i (1 ≤ i ≤ n), i-th box is a cube with side length ai.
Mishka can put a box i into another box j if the following conditions are met:
* i-th box is not put into another box;
* j-th box doesn't contain any other boxes;
* box i is smaller than box j (ai < aj).
Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.
Help Mishka to determine the minimum possible number of visible boxes!
Input
The first line contains one integer n (1 ≤ n ≤ 5000) — the number of boxes Mishka has got.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the side length of i-th box.
Output
Print the minimum possible number of visible boxes.
Examples
Input
3
1 2 3
Output
1
Input
4
4 2 4 3
Output
2
Note
In the first example it is possible to put box 1 into box 2, and 2 into 3.
In the second example Mishka can put box 2 into box 3, and box 4 into box 1.
|
from sys import stdin,stdout
from collections import Counter
def ai(): return list(map(int, stdin.readline().split()))
def ei(): return map(int, stdin.readline().split())
def ip(): return int(stdin.readline().strip())
def op(ans): return stdout.write(str(ans) + '\n')
t = ip()
li = ai()
x = max(li)
c = Counter(li).values()
print(max(c))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.