input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
On the way to Lanka, Ram and co encountered another interesting path. The path was laid with numbered rocks which were to be jumped over. The number denoted the maximum jump length that could be made by the person standing on that rock. For instance, if Ram was standing on a rock numbered 2, he could either make a jump of 1 and move to its immediate rock ahead of it or make a jump of 2 and move to the rock located 2 rocks ahead.
Since, they were running out of time, Hanuman wanted to find out the minimum number of jumps they would have to make to reach the end of the path, given a list of numbers labeled on the rocks. Let us help Hanuman find the number.
INPUT:
an integer T (1 ≤ T ≤ 1000) : number of testcases
Each test case is represented by a number N(2 ≤ N ≤ 1000) denoting the number of rocks followed by an array of numbers rockNum[] labeled on those N rocks.
The elements in the array rockNum[] will be less than or equal to N and greater than 0.
OUTPUT:
For each test case, output the minimum number of jumps required to reach the goal(the last element of the array) from the starting position(first element of the array).
SAMPLE INPUT
2
5
2 3 1 1 4
11
1 3 5 8 9 2 6 7 6 8 9
SAMPLE OUTPUT
2
3
Explanation
In the first test case, Ram could make a jump as such (0,2,3,4 : jump 2 to index 2,jump 1 to index 3 and then jump 1 to index 4) or a jump as such (0,1,4 : jump 1 to index 1, jump 3 to index 4). Since the latter one involves the least number of jumps, the answer is 2.
In the second test case, the optimal jump is (1,3,8,9). So the answer is 3 .
|
t = int(raw_input())
while t:
n = int(raw_input())
arr = [int(i) for i in raw_input().split()]
dp = [0]*n
for i in range(1,len(arr)):
for j in range(i):
if j + arr[j] >=i:
if dp[i]==0:
dp[i] = dp[j]+1
else:
dp[i] = min(dp[j]+1,dp[i])
print dp[n-1]
t-=1
|
Recently Ram got to know about a secret place where he can play many games to win lot of prize. Games are very easy, so he can easily win high prize, but he can play a limited number of games.
He want to win the maximum amount of prize.So he wants to choose games, such that the prize money is maximum.
Assume that he wins the game if he choose to play that game.
There are n games and he can play maximum k games.
I th game is having a[i] prize money, help him to find maximum amount of prize money that he can win.
Note :
There is atleast one game.
Each game can be played atmost one time.
Constraints :
T ≤ 10
N ≤ 10^5
k ≤ 10^5
a[i] ≤ 10^6
Input :
First line contain number of test cases t.
Each test case consist of two lines.
First line of each test case consist of two integer n and k.
Second line of each test case consist n space separated integers a[i].
Output:
Output t line each line consisting of the maximum prize that he can win.
To be eligible for prizes you have to register for AlgoXtreme at the Zeitgeist site. To register visit Zeitgeist. Only those candidates who have registered on the Zeitgeist website for the AlgoXtreme contest will be eligible to avail the Prizes.
SAMPLE INPUT
5
5 5
1 1 1 1 1
4 0
1 1 1 1
3 1
8 9 8
6 5
100 200 300 400 500 1000
2 1
1 2
SAMPLE OUTPUT
5
0
9
2400
2
Explanation
For the first test case, he can play all the games so the prize is 5.
For the second test case, he can play none of the games so the prize is 0.
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
#print 'Hello World!'
t=input()
while t>0:
t-=1
n,k=map(int,raw_input().split())
l=[int(i) for i in raw_input().split()]
l.sort()
p=l[::-1]
s=0
if k>n:
print sum(l)
else:
for i in range(k):
s+=p[i]
print s
|
Miraya and her best Alice friend are now ending their studies and they are willing to work together in a software company, but before this Alice will be tested by the Miraya through the following procedure,
Miraya is obviously Computer Science person while her best friend belongs to Arts. However, as Miraya didn't want to lose contact with her, she decided to mix Arts and Computer-Science one last time and amaze her friend with Computer-Science, so she could have a geek coding partner.
To amaze her, Miraya selected a natural number N, which she presented to her friend Alice.
Miraya: "So, Alice, as you can see, we have a Natural Number N, yes? The first thing you have to do is ,If you write down the first N natural numbers on a paper you will get a sequence of distinct numbers. You can denote them as
{x1,x2,x3,…..,xn} a sequence of N distinct integers, which is also a permutation of first N natural numbers."
Miraya: “Now Alice we have a permutation of first N natural numbers. You can select any permutation of the aforesaid permutation to find out an optimal permutation of numbers. A permutation is said to be optimal if it maximizes the summation of absolute differences of all the consecutive elements of the permutation when written as it is on the paper.”
But Alice is very weak in solving such kind of problems. So she needs your help to get the desired maximum value from the Optimal Permutation. If it becomes possible for Alice then, they will be working together in the same software company.
Constraints:
1 ≤ T ≤ 10^3
1 ≤ N ≤ (2 x 10^5)
Input:
The first line of the input contains an integer T denoting the number of test cases.
then each test case contains a single integer N.
Output:
For each test case output the required answer in separate line to help Alice.
SAMPLE INPUT
2
2
7
SAMPLE OUTPUT
1
23
Explanation
In Test-case # 1 for n=2 the possible sequences are {1,2} & {2,1} and both yielding the same result i.e. abs(1-2) = 1.
|
def solve (bhavik):
if (bhavik == 1):
return 0
else:
return (bhavik * bhavik)/2 - 1
t = input()
for _ in xrange(t):
n = input()
ans = solve(int(n))
print ans
|
You are given an two integers i and j such that i ≤ j.
Task is to find the sum of all integers from i to j (both inclusive).
For example:
i = 3
j = 5
then sum from i to j will be 3+4+5 = 12
Input:
Single line containing two space separated integers i and j.
Output:
Print out the sum of integers from i to j (both inclusive).
Constraints:
0 ≤ i ≤ 1000000000000000000 (10^18)
0 ≤ j ≤ 1000000000000000000 (10^18)
i ≤ j
Absolute difference between i and j can be upto 1000000000000000000
i.e. |j-i| ≤ 1000000000000000000 (10^18)
Subtask 1: (50 points)
0 ≤ i ≤ 1000000
0 ≤ j ≤ 1000000
i ≤ j
Absolute difference between i and j can be upto 1000000
i.e. |j-i| ≤ 1000000
Subtask 2: (50 points)
Original Constraints
Hint:
Use mathematics instead of loop to find sum.
Use BigInteger class of Java for large number multiplication.
SAMPLE INPUT
99 1000000000000
SAMPLE OUTPUT
500000000000499999995149
|
a,b=map(long,raw_input().split())
n=b-a+1
print (a+b)*n/2
|
Problem Statement
As they say, small is cute and beautiful.
Given N distinct positive integers, find the smallest number that can be formed by concatenating all of them.
Input Format
The first line of the input file contains a positive integer N. Then N lines follow.
Each line contains a single positive integer K.
Output Format
Output the smallest possible number that can be formed by concatenating all the numbers.
Constraints
1 ≤ N ≤ 5000
1 ≤ K ≤ 10^15
SAMPLE INPUT
5
14
66
907
1234567890
9876543210
SAMPLE OUTPUT
123456789014669079876543210
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
#print 'Hello World!'
def func(a,b):
if(len(a) != len(b)):
#a = int(a)
#b = int(b)
str1 = a + b
str2 = b + a
if str1 > str2:
return 1
elif str1 == str2:
return 0
else:
return -1
else:
if a > b:
return 1
elif a==b:
return 0
else:
return -1
lines = int(raw_input())
lst = []
for i in range(lines):
lst.append(raw_input())
lst.sort(func)
res = ""
for i in lst:
res = res + i
print(int(res))
|
Little PandeyG is a curious student, studying in HEgwarts. Being smarter, faster and displaying more zeal for magic than any other student, one by one he managed to impress the three hidden witches of the school. They knew his secret desire to be a warrior, so each of them gave him some super power to use if he's up for a fight against one of his enemies.
The first witch: She gave PandeyG the power to take away one unit of strength away from his enemies. - Eg 36 - 1 = 35.
The second witch: Jealous of the first witch, the second one gave the kid the power to halfen the strength of his enemies. - Eg. \frac{36}{2} = 18.
The third witch: Even better, she gave him the power to reduce the strength of his enemies to one third of what it initially was. - Eg. \frac{36}{3} = 12.
The witches, though, clearly told him that he'll be only able to use these powers if the strength of the opponent is an integer, otherwise not.
Since, PandeyG is one smart kid, he knew that by using all three of the powers he has got, he'll be able to defeat every enemy he's ever going to face, sometime or the other, in some number of moves.
Now, here's the twist: In spite of having all these powers, PandeyG was still losing matches against his enemies - because he was unable to use them in the optimal fashion. To defeat an opponent, you need to make sure that the enemy has only 1 unit of strength left in him.
Given the value 'k' - k being the units of the enemy of PandeyG's strength, help PandeyG figure out the minimum number of magical hits he'll be needing to defeat his opponent, using his powers.
Input Format:
The first line represents the number of test cases, t.
Followed by t lines - and on every line, a number n - with the strength unit of your enemy.
Output format:
For every number n, print the minimum number of hits needed to defeat his enemy by making his strength equal to 1.
Constraints:
1 ≤ t ≤ 1000.
1 ≤ n ≤ 10^9.
SAMPLE INPUT
5
1
2
3
4
5
SAMPLE OUTPUT
0
1
1
2
3
Explanation
In the first test case, the enemy's power is already 1, so you will no move to defeat him.
In the second case, the enemy's power can be reduced to 1 simply by using the second witch's power - reducing 2 to 1, in one step.
In the third case, the enemy's power can be reduced to 1 in one step again using the third witch's power.
In the fourth case, PandeyG can reduce the enemy's power in 2 steps, by using his second power twice.
In the fifth case, there are two ways:
Way 1:
Reduce 5 by 1 to make 4.
Half it. \frac{4}{2} = 2.
Half it. \frac{2}{2} = 1.
3 steps.
Way 2:
Reduce 5 by 1 to make it 4.
Reduce 4 by 1 to make it 3.
Reduce 3 to 1, by making it one third. \frac{3}{3} = 1.
3 steps.
In any case, you need to print the MINIMUM number of steps needed.
|
def main():
for _ in xrange(input()):
v=[]
s=set()
n=input()
ans=0
v.append(n)
i=0
f=0
j=1
while(f==0):
if(n==1):
break
if(f==1):
break
ans+=1
for k in xrange(i,j):
x = -1
y = -1
z = -1
if(v[k]%3==0):
x=v[k]/3
if(v[k]%2==0):
y=v[k]/2
z=v[k]-1
if(x==1 or y==1 or z==1):
f=1
break
if(x!=-1):
if x not in s:
s.add(x)
v.append(x)
if(y!=-1):
if y not in s:
s.add(y)
v.append(y)
if(z!=-1):
if z not in s:
s.add(z)
v.append(z)
i=j
j=len(v)
print ans
main()
|
Given are integers a,b,c and d. If x and y are integers and a \leq x \leq b and c\leq y \leq d hold, what is the maximum possible value of x \times y?
Constraints
* -10^9 \leq a \leq b \leq 10^9
* -10^9 \leq c \leq d \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
a b c d
Output
Print the answer.
Examples
Input
1 2 1 1
Output
2
Input
3 5 -4 -2
Output
-6
Input
-1000000000 0 -1000000000 0
Output
1000000000000000000
|
lines = map(int,input().split())
a,b,c,d = lines
print(max(a*c,a*d,b*c,b*d))
|
The Kingdom of Takahashi has N towns, numbered 1 through N.
There is one teleporter in each town. The teleporter in Town i (1 \leq i \leq N) sends you to Town A_i.
Takahashi, the king, loves the positive integer K. The selfish king wonders what town he will be in if he starts at Town 1 and uses a teleporter exactly K times from there.
Help the king by writing a program that answers this question.
Constraints
* 2 \leq N \leq 2 \times 10^5
* 1 \leq A_i \leq N
* 1 \leq K \leq 10^{18}
Input
Input is given from Standard Input in the following format:
N K
A_1 A_2 \dots A_N
Output
Print the integer representing the town the king will be in if he starts at Town 1 and uses a teleporter exactly K times from there.
Examples
Input
4 5
3 2 4 1
Output
4
Input
6 727202214173249351
6 5 2 5 3 2
Output
2
|
n, k = map(int, input().split())
a = list(map(int, input().split()))
s = []
ord = [-1] * (n+1)
v = 1
while ord[v] == -1:
ord[v] = len(s)
s.append(v)
v = a[v-1]
c = len(s) - ord[v]
l = ord[v]
ans = 0
if k < l:
ans = s[k]
else:
k -= l
k %= c
ans = s[l+k]
print(ans)
|
We have a string S of length N consisting of uppercase English letters.
How many times does `ABC` occur in S as contiguous subsequences (see Sample Inputs and Outputs)?
Constraints
* 3 \leq N \leq 50
* S consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print number of occurrences of `ABC` in S as contiguous subsequences.
Examples
Input
10
ZABCDBABCQ
Output
2
Input
19
THREEONEFOURONEFIVE
Output
0
Input
33
ABCCABCBABCCABACBCBBABCBCBCBCABCB
Output
5
|
n = input()
print(input().count('ABC'))
|
There is a directed graph with N vertices numbered 1 to N and M edges. The i-th edge is directed from Vertex A_i to Vertex B_i, and there are C_i coins placed along that edge. Additionally, there is a button on Vertex N.
We will play a game on this graph. You start the game on Vertex 1 with zero coins, and head for Vertex N by traversing the edges while collecting coins. It takes one minute to traverse an edge, and you can collect the coins placed along the edge each time you traverse it. As usual in games, even if you traverse an edge once and collect the coins, the same number of coins will reappear next time you traverse that edge, which you can collect again.
When you reach Vertex N, you can end the game by pressing the button. (You can also choose to leave Vertex N without pressing the button and continue traveling.) However, when you end the game, you will be asked to pay T \times P coins, where T is the number of minutes elapsed since the start of the game. If you have less than T \times P coins, you will have to pay all of your coins instead.
Your score will be the number of coins you have after this payment. Determine if there exists a maximum value of the score that can be obtained. If the answer is yes, find that maximum value.
Constraints
* 2 \leq N \leq 2500
* 1 \leq M \leq 5000
* 1 \leq A_i, B_i \leq N
* 1 \leq C_i \leq 10^5
* 0 \leq P \leq 10^5
* All values in input are integers.
* Vertex N can be reached from Vertex 1.
Input
Input is given from Standard Input in the following format:
N M P
A_1 B_1 C_1
:
A_M B_M C_M
Output
If there exists a maximum value of the score that can be obtained, print that maximum value; otherwise, print `-1`.
Examples
Input
3 3 10
1 2 20
2 3 30
1 3 45
Output
35
Input
2 2 10
1 2 100
2 2 100
Output
-1
Input
4 5 10
1 2 1
1 4 1
3 4 1
2 2 100
3 3 100
Output
0
|
n,m,p = map(int, input().split())
edge = []
inv_link = [[] for _ in range(n)]
link = [[] for _ in range(n)]
for i in range(m):
a,b,cost = list(map(int,input().split()))
edge.append([a-1,b-1,p-cost])
link[a-1].append(b-1)
inv_link[b-1].append(a-1)
def bell(edges, start,num_v):
cost = [float('inf')] * num_v
cost[start] = 0
for _ in range(num_v):
updated = False
for a, b, c in edges:
if cost[b] > cost[a] + c:
cost[b] = cost[a] + c
updated = True
if not updated: break
else:
return False,cost
return True,cost
from collections import deque
Q = deque()
Q.append([n-1,0])
visited=[-1]*n
visited[n-1]=0
while Q:
now,cnt = Q.popleft()
for nxt in inv_link[now]:
if visited[nxt]!=-1:
continue
visited[nxt]=cnt+1
Q.append([nxt,cnt+1])
new_edge=[]
for a,b,c in edge:
if visited[a]==-1 or visited[b]==-1:
continue
new_edge.append([a,b,c])
ret,cost = bell(new_edge,0,n)
if ret:
print(max(0,-cost[-1]))
else:
print(-1)
|
On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.
You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.
Constraints
* b is one of the letters `A`, `C`, `G` and `T`.
Input
Input is given from Standard Input in the following format:
b
Output
Print the letter representing the base that bonds with the base b.
Examples
Input
A
Output
T
Input
G
Output
C
|
import java.util.*;
import java.io.*;
public class Main{
public static void main(String[] args) throws Exception{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s = br.readLine();
if(s.equals("A")) System.out.println("T");
else if(s.equals("T")) System.out.println("A");
else if(s.equals("G")) System.out.println("C");
else System.out.println("G");
}
}
|
You are given an integer N. Determine if there exists a tuple of subsets of \\{1,2,...N\\}, (S_1,S_2,...,S_k), that satisfies the following conditions:
* Each of the integers 1,2,...,N is contained in exactly two of the sets S_1,S_2,...,S_k.
* Any two of the sets S_1,S_2,...,S_k have exactly one element in common.
If such a tuple exists, construct one such tuple.
Constraints
* 1 \leq N \leq 10^5
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
If a tuple of subsets of \\{1,2,...N\\} that satisfies the conditions does not exist, print `No`. If such a tuple exists, print `Yes` first, then print such subsets in the following format:
k
|S_1| S_{1,1} S_{1,2} ... S_{1,|S_1|}
:
|S_k| S_{k,1} S_{k,2} ... S_{k,|S_k|}
where S_i={S_{i,1},S_{i,2},...,S_{i,|S_i|}}.
If there are multiple such tuples, any of them will be accepted.
Examples
Input
3
Output
Yes
3
2 1 2
2 3 1
2 2 3
Input
4
Output
No
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int k=2;
while(k*(k-1)/2 < n) k++;
if(k*(k-1)/2 != n){
cout << "No" << endl;
return 0;
}
int a[500][500];
int b[500];
for(int i=1; i<=k; i++)b[i]=0;
int x=1;
for(int i=1; i<=k; i++){
for(int j=i+1; j<=k; j++){
a[i][b[i]]=x;
b[i]++;
a[j][b[j]]=x;
b[j]++;
x++;
}
}
cout << "Yes" << endl;
cout << k << endl;
for(int i=1; i<=k; i++){
cout << k-1 << " ";
for(int j=0; j<k-1; j++){
cout << a[i][j];
if(j==k-2) cout << endl;
else cout << " ";
}
}
}
|
Let {\rm comb}(n,r) be the number of ways to choose r objects from among n objects, disregarding order. From n non-negative integers a_1, a_2, ..., a_n, select two numbers a_i > a_j so that {\rm comb}(a_i,a_j) is maximized. If there are multiple pairs that maximize the value, any of them is accepted.
Constraints
* 2 \leq n \leq 10^5
* 0 \leq a_i \leq 10^9
* a_1,a_2,...,a_n are pairwise distinct.
* 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 a_i and a_j that you selected, with a space in between.
Examples
Input
5
6 9 4 2 11
Output
11 6
Input
2
100 0
Output
100 0
|
#coding:utf-8
N=input()
A=map(int,raw_input().split())
A.sort()
n=A[-1]
med=n/2
p=0
mi=1145141919810
for i,a in enumerate(A):
b=min(a,n-a)
if abs(b-med) < mi:
p=i; mi=abs(b-med)
print("%d %d"%(n,A[p]))
|
Sitting in a station waiting room, Joisino is gazing at her train ticket.
The ticket is numbered with four digits A, B, C and D in this order, each between 0 and 9 (inclusive).
In the formula A op1 B op2 C op3 D = 7, replace each of the symbols op1, op2 and op3 with `+` or `-` so that the formula holds.
The given input guarantees that there is a solution. If there are multiple solutions, any of them will be accepted.
Constraints
* 0≤A,B,C,D≤9
* All input values are integers.
* It is guaranteed that there is a solution.
Input
Input is given from Standard Input in the following format:
ABCD
Output
Print the formula you made, including the part `=7`.
Use the signs `+` and `-`.
Do not print a space between a digit and a sign.
Examples
Input
1222
Output
1+2+2+2=7
Input
0290
Output
0-2+9+0=7
Input
3242
Output
3+2+4-2=7
|
import java.io.*;
import java.util.*;
public class Main{
public static void main(String[] args){
solve();
}
public static void solve(){
Scanner sc = new Scanner(System.in);
int z = sc.nextInt();
int x = z;
int a = x/1000;
x -= x/1000*1000;
int b = x/100;
x -= x/100*100;
int c = x/10;
x -= x/10*10;
int ans = 0;
int[] count = new int[3];
for(int i=0;i<2;i++){
for(int j=0;j<2;j++){
for(int k=0;k<2;k++){
ans = a;
if(i==0){
ans += b;
}
else{
ans -= b;
}
if(j==0){
ans += c;
}
else{
ans -= c;
}
if(k==0){
ans += x;
}
else{
ans -= x;
}
if(ans == 7){
count[0] = i;
count[1] = j;
count[2] = k;
}
}
}
}
for(int i=0;i<4;i++){
System.out.print(z/(int)Math.pow(10,3-i));
z -= z/(int)Math.pow(10,3-i)*(int)Math.pow(10,3-i);
if(i!=3){
if(count[i]==0){
System.out.print("+");
}
else{
System.out.print("-");
}
}
}
System.out.println("=7");
}
}
|
You are taking a computer-based examination. The examination consists of N questions, and the score allocated to the i-th question is s_i. Your answer to each question will be judged as either "correct" or "incorrect", and your grade will be the sum of the points allocated to questions that are answered correctly. When you finish answering the questions, your answers will be immediately judged and your grade will be displayed... if everything goes well.
However, the examination system is actually flawed, and if your grade is a multiple of 10, the system displays 0 as your grade. Otherwise, your grade is displayed correctly. In this situation, what is the maximum value that can be displayed as your grade?
Constraints
* All input values are integers.
* 1 ≤ N ≤ 100
* 1 ≤ s_i ≤ 100
Input
Input is given from Standard Input in the following format:
N
s_1
s_2
:
s_N
Output
Print the maximum value that can be displayed as your grade.
Examples
Input
3
5
10
15
Output
25
Input
3
10
10
15
Output
35
Input
3
10
20
30
Output
0
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[n];
for(int i = 0 ; i < n ; i++) a[i] = sc.nextInt();
boolean[][] dp = new boolean[101][10010];
dp[0][0] = true;
for(int i = 0 ; i < n ; i++) {
for(int j = 0 ; j <= 10000 ; j++) {
if(dp[i][j] == true) {
dp[i + 1][j] = true;
dp[i + 1][j + a[i]] = true;
}
}
}
for(int i = 10000 ; i >= 0 ; i--) {
if(i % 10 != 0 && dp[n][i] == true) {
System.out.println(i);
return;
}
}
System.out.println(0);
}
}
|
You are given a string S consisting of lowercase English letters. Another string T is initially empty. Determine whether it is possible to obtain S = T by performing the following operation an arbitrary number of times:
* Append one of the following at the end of T: `dream`, `dreamer`, `erase` and `eraser`.
Constraints
* 1≦|S|≦10^5
* S consists of lowercase English letters.
Input
The input is given from Standard Input in the following format:
S
Output
If it is possible to obtain S = T, print `YES`. Otherwise, print `NO`.
Examples
Input
erasedream
Output
YES
Input
dreameraser
Output
YES
Input
dreamerer
Output
NO
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
s = s.replaceAll("eraser", "").replaceAll("erase", "").replaceAll("dreamer", "").replaceAll("dream", "");
if(s.equals("")) {
System.out.println("YES");
} else {
System.out.println("NO");
}
}
}
|
Snuke got an integer sequence of length N from his mother, as a birthday present. The i-th (1 ≦ i ≦ N) element of the sequence is a_i. The elements are pairwise distinct. He is sorting this sequence in increasing order. With supernatural power, he can perform the following two operations on the sequence in any order:
* Operation 1: choose 2 consecutive elements, then reverse the order of those elements.
* Operation 2: choose 3 consecutive elements, then reverse the order of those elements.
Snuke likes Operation 2, but not Operation 1. Find the minimum number of Operation 1 that he has to perform in order to sort the sequence in increasing order.
Constraints
* 1 ≦ N ≦ 10^5
* 0 ≦ A_i ≦ 10^9
* If i ≠ j, then A_i ≠ A_j.
* All input values are integers.
Input
The input is given from Standard Input in the following format:
N
A_1
:
A_N
Output
Print the minimum number of times Operation 1 that Snuke has to perform.
Examples
Input
4
2
4
3
1
Output
1
Input
5
10
8
5
3
2
Output
0
|
n,*a=map(int,open(0))
print(len(set(a[::2])^set(sorted(a)[::2]))//2)
|
Books are indexed. Write a program which reads a list of pairs of a word and a page number, and prints the word and a list of the corresponding page numbers.
You can assume that a word consists of at most 30 characters, and the page number is less than or equal to 1000. The number of pairs of a word and a page number is less than or equal to 100. A word never appear in a page more than once.
The words should be printed in alphabetical order and the page numbers should be printed in ascending order.
Input
word page_number
::
::
Output
word
a_list_of_the_page_number
word
a_list_of_the_Page_number
::
::
Example
Input
style 12
even 25
introduction 3
easy 9
style 7
document 13
style 21
even 18
Output
document
13
easy
9
even
18 25
introduction
3
style
7 12 21
|
import java.util.Arrays;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.Collections;
public class Main{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
ArrayList<String> str = new ArrayList<String>();
while(scan.hasNext()){
str.add(scan.nextLine());
}
Collections.sort(str);
String be = "";
int count = 0;
String nt = "";
for(int i = 0;i < str.size();i++){
String[] ts = str.get(i).split(" ");
if(ts[0].equals(be)){
nt += " " + ts[1];
count++;
continue;
}
if(count > 1){
String[] a = nt.split(" ");
int[] b = new int[count];
for(int j = 0;j < count;j++){
b[j] = Integer.parseInt(a[j]);
}
Arrays.sort(b);
for(int j = 0;j < count;j++){
System.out.print(b[j]+((j == count-1)?"\n":" "));
}
count = 1;
System.out.println(ts[0]);
be = ts[0];
nt = ts[1];
}else{
if(count != 0){
System.out.println(nt);
}
System.out.println(ts[0]);
be = ts[0];
nt = ts[1];
count = 1;
}
}
if(count > 1){
String[] a = nt.split(" ");
int[] b = new int[count];
for(int j = 0;j < count;j++){
b[j] = Integer.parseInt(a[j]);
}
Arrays.sort(b);
for(int j = 0;j < count;j++){
System.out.print(b[j]+((j == count-1)?"\n":" "));
}
}else{
System.out.println(nt);
}
}
}
|
Food contains three nutrients called "protein", "fat" and "carbohydrate", which are called three major nutrients. It is calculated that protein and carbohydrate are 4 kcal (kilocalories) and fat is 9 kcal per 1 g (gram). For example, according to the table below, the number 1 cake contains 7 g of protein, 14 g of fat and 47 g of carbohydrates. If you calculate the calories contained based on this, it will be 4 x 7 + 9 x 14 + 4 x 47 = 342 kcal. Others are calculated in the same way.
Number | Name | Protein (g) | Lipids (g) | Carbohydrates (g) | Calories (kcal)
--- | --- | --- | --- | --- | ---
1 | Cake | 7 | 14 | 47 | 342
2 | Potato Chips | 5 | 35 | 55 | 555
3 | Dorayaki | 6 | 3 | 59 | 287
4 | Pudding | 6 | 5 | 15 | 129
Input the number of sweets to be classified n, the information of each sweet, and the limit information, and output a list of sweets that do not exceed the limit (may be eaten) if only one sweet is used. Create a program.
The candy information consists of the candy number s, the weight p of the protein contained in the candy, the weight q of the lipid, and the weight r of the carbohydrate. The limit information consists of the maximum protein weight P that can be included, the fat weight Q, the carbohydrate weight R, and the maximum calorie C that can be consumed, of protein, fat, carbohydrate, and calories. If any one of them is exceeded, the restriction will be violated and it will be judged as "sweets that should not be eaten".
For a list of sweets that you can eat, output the numbers of sweets that you can eat in the order in which you entered them. If there are no sweets you can eat, please output "NA". For the four sweets in the table above, if the limit is P = 10, Q = 15, R = 50, C = 400, cake and pudding may be eaten as their respective nutrients and calories are below the limit. Although it is classified as sweets, potato chips are classified as sweets that should not be eaten because the amount of carbohydrates exceeds the limit value.
input
Given a sequence of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
s1 p1 q1 r1
s2 p2 q2 r2
::
sn pn qn rn
P Q R C
The first line gives the number of sweets n (1 ≤ n ≤ 1000). The next n lines are given the number si (1 ≤ si ≤ 1000) of the i-th candy and the integers pi, qi, ri (0 ≤ pi, qi, ri ≤ 100) representing the weight of each nutrient.
The following lines are given the integers P, Q, R (0 ≤ P, Q, R ≤ 100), C (0 ≤ C ≤ 1700) representing the limits for each nutrient and calorie.
The number of datasets does not exceed 100.
output
For each dataset, it outputs the number of sweets you can eat or "NA".
Example
Input
4
1 7 14 47
2 5 35 55
3 6 3 59
4 6 5 15
10 15 50 400
2
1 8 10 78
2 4 18 33
10 10 50 300
0
Output
1
4
NA
|
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(true){
final int n = sc.nextInt();
if(n == 0){
break;
}
int[][] items = new int[n][4];
for(int i = 0; i < n; i++){
for(int j = 0; j < 4; j++){
items[i][j] = sc.nextInt();
}
}
int[] limits = new int[4];
for(int i = 0; i < 4; i++){
limits[i] = sc.nextInt();
}
boolean found = false;
START:for(int i = 0; i < n; i++){
for(int j = 1; j < 4; j++){
if(items[i][j] > limits[j-1]){
continue START;
}
}
if(items[i][1]*4 + items[i][2]*9 + items[i][3]*4 > limits[3]){
continue START;
}
found = true;
System.out.println(items[i][0]);
}
if(!found){
System.out.println("NA");
}
}
}
}
|
You are a famous adventurer and have already won two dungeons. You got a new dungeon map with some walkways and a treasure trove. The map shows the value of the treasure in each treasure chest.
You can enter the dungeon from any treasure chest and escape the dungeon from any treasure chest. From invasion to escape, you can navigate through the passages between the treasure chests several times to get the treasures of the treasure chest you visited. According to the map, each passage can be bidirectional, and any treasure trove can be reached from any treasure trove via one or more passages. However, once the passage is passed, it can only be passed in the same direction as the first time after the second time. Treasure in the treasure chest can only be obtained the first time you visit it. At this time, I want to maximize the total value of the treasures I get.
Create a program that finds the maximum sum of the treasure values that can be obtained between invasion and escape when given map information. However, it is assumed that the treasure house is assigned a number from 1 to N.
input
The input is given in the following format.
$ N $ $ M $
$ v_1 $
$ v_2 $
::
$ v_N $
$ s_1 $ $ t_1 $
$ s_2 $ $ t_2 $
::
$ s_M $ $ t_M $
The first line gives the number of treasure trove $ N $ ($ 2 \ leq N \ leq 10 ^ 5 $) and the number of passages $ M $ ($ 1 \ leq M \ leq 2 \ times 10 ^ 5 $). The following $ N $ line is given the value of the treasure in the $ i $ th treasure trove $ v_i $ ($ 1 \ leq v_i \ leq 1000 $). The following $ M $ line is given the treasure trove numbers $ s_i $, $ t_i $ ($ 1 \ leq s_i, t_i \ leq N, s_i \ net_i $) connected to both ends of each aisle. However, the passage connecting the same treasure chests cannot be given more than once.
output
The maximum value of the total value of the treasure that can be obtained is output in one line.
Examples
Input
5 4
2
1
3
6
4
1 2
2 3
2 4
4 5
Output
14
Input
None
Output
None
|
# include <iostream>
# include <algorithm>
#include <array>
# include <cassert>
#include <cctype>
#include <climits>
#include <numeric>
# include <vector>
# include <string>
# include <set>
# include <map>
# include <cmath>
# include <iomanip>
# include <functional>
# include <tuple>
# include <utility>
# include <stack>
# include <queue>
# include <list>
# include <bitset>
# include <complex>
# include <chrono>
# include <random>
# include <limits.h>
# include <unordered_map>
# include <unordered_set>
# include <deque>
# include <cstdio>
# include <cstring>
#include <stdio.h>
#include<time.h>
#include <stdlib.h>
#include <cstdint>
#include <cfenv>
#include<fstream>
//#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
long long MOD = 998244353;// 1000000000 + 7;
constexpr long long INF = numeric_limits<LL>::max() / 2;
const double PI = acos(-1);
#define fir first
#define sec second
#define thi third
#define debug(x) cerr<<#x<<": "<<x<<'\n'
typedef pair<LL, LL> Pll;
typedef pair<LL, pair<LL, LL>> Ppll;
typedef pair<LL, pair<LL, bitset<100001>>> Pbll;
typedef pair<LL, pair<LL, vector<LL>>> Pvll;
typedef pair<LL, LL> Vec2;
struct Tll { LL first, second, third; };
struct Fll { LL first, second, third, fourd; };
typedef pair<LL, Tll> Ptll;
#define rep(i,rept) for(LL i=0;i<rept;i++)
#define Rrep(i,mf) for(LL i=mf-1;i>=0;i--)
void YN(bool f) {
if (f)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void yn(bool f) {
if (f)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
struct Edge { LL to, cost; };
struct edge { LL from, to, cost; };
vector<vector<int>>g;
vector<edge>edges;
vector<Pll>v;
map<Pll, Pll>ma;
set<LL>st;
LL h, w, n, m, k, t, s, p, q, last, cnt, sum, ans, a[210000], b[210000], dp[210000];
string str, ss;
bool f;
char c;
int di[4][2] = { { 0,1 },{ 1,0 },{ 0,-1 },{ -1,0 } };
struct LowLink {
int n;
vector<vector<int>> G;
set<pair<int, int> > bridge;
set<int> articulation;
vector<int> ord, low;
vector<bool> vis;
LowLink() {}
LowLink(int _n) :n(_n) {
G.resize(_n);
ord.resize(_n);
low.resize(_n);
vis.resize(_n);
}
LowLink(vector<vector<int>> &g) {
G = g;
n = G.size();
ord.resize(G.size());
low.resize(G.size());
vis.resize(G.size());
}
void add_Edge(int x, int y) {
G[x].push_back(y);
G[y].push_back(x);
}
void build() {
int k = 0;
for (int i = 0; i < n; i++) {
if (!vis[i]) dfs(i, -1, k);
}
}
void dfs(int v, int p, int &k)
{
vis[v] = true;
ord[v] = k++;
low[v] = ord[v];
bool isArticulation = false;
int ct = 0;
for (int i = 0; i < G[v].size(); i++) {
if (!vis[G[v][i]]) {
ct++;
dfs(G[v][i], v, k);
low[v] = min(low[v], low[G[v][i]]);
if (~p && ord[v] <= low[G[v][i]]) isArticulation = true;
if (ord[v] < low[G[v][i]]) bridge.insert(make_pair(min(v, G[v][i]), max(v, G[v][i])));
}
else if (G[v][i] != p) {
low[v] = min(low[v], ord[G[v][i]]);
}
}
if (p == -1 && ct > 1) isArticulation = true;
if (isArticulation) articulation.insert(v);
}
void print() {
cout << "関節点の個数" << endl;
cout << articulation.size() << "個" << endl;
for (auto i = articulation.begin(); i != articulation.end(); i++)
cout << *i << endl;
cout << "橋の個数" << endl;
cout << bridge.size() << "個" << endl;
for (auto i = bridge.begin(); i != bridge.end(); i++)
cout << i->first << "-" << i->second << endl;
}
};
struct TwoEdgeConnectedComponent {
int n;
vector<vector<int>> g, tree;//木として見た時の辺が入っている
vector<int> cmp;//木として見た時の頂点が入っている
LowLink lnk;
TwoEdgeConnectedComponent(int _n) {
n = _n;
cmp.assign(_n, -1);
g.resize(_n);
tree.resize(_n);
}
TwoEdgeConnectedComponent(const vector<vector<int>> &g) : g(g) {
n = (int)g.size();
cmp.assign(n, -1);
}
void add_Edge(int x, int y) {
g[x].push_back(y);
g[y].push_back(x);
}
void build() {
lnk = LowLink(g);
lnk.build();
int k = 0;
function<void(int, int)> dfs = [&](int u, int prev) {
cmp[u] = k;
for (auto v : g[u]) if (cmp[v] == -1 && lnk.bridge.count({ min(u, v), max(u, v) }) == 0) {
dfs(v, u);
}
};
for (int i = 0; i < n; i++) if (cmp[i] == -1) {
dfs(i, -1);
k++;
}
tree.resize(k);
for (auto e : lnk.bridge) {
tree[cmp[e.first]].push_back(cmp[e.second]);
tree[cmp[e.second]].push_back(cmp[e.first]);
}
}
};
void dfs(int cur, int par) {
vector<LL>ret;
ret.push_back(0);
ret.push_back(0);
rep(i, g[cur].size()) {
int v = g[cur][i];
if (v == par)continue;
dfs(v, cur);
ret.push_back(dp[v]);
}
sort(ret.begin(), ret.end(), [](int x, int y) {return x > y; });
if (ret.size() > 1)
ans = max(ans, ret[0] + ret[1] + b[cur]);
ans = max(ans, ret[0] + b[cur]);
dp[cur] = ret[0] + b[cur];
}
int main() {
cin >> n >> m;
rep(i, n) {
cin >> a[i];
}
g.resize(n);
rep(i, m) {
int x,y;
cin >> x>>y;
x--, y--;
g[x].push_back(y);
g[y].push_back(x);
}
TwoEdgeConnectedComponent tec(g);
tec.build();
rep(i, tec.cmp.size()) {
b[tec.cmp[i]] += a[i];
}
g = tec.tree;
dfs(0,-1);
cout << ans << endl;
return 0;
}
|
There are two cameras which observe the up line and the down line respectively on the double lane (please see the following figure). These cameras are located on a line perpendicular to the lane, and we call the line 'monitoring line.' (the red line in the figure)
<image>
Monitoring systems are connected to the cameras respectively. When a car passes through the monitoring line, the corresponding monitoring system records elapsed time (sec) from the start of monitoring.
Your task is to write a program which reads records of the two monitoring systems and prints the maximum time interval where cars did not pass through the monitoring line.
The two monitoring system start monitoring simultaneously. The end of monitoring is indicated by the latest time in the records.
Input
The input consists of multiple datasets. Each dataset consists of:
n m
tl1 tl2 ... tln
tr1 tr2 ... trm
n, m are integers which represent the number of cars passed through monitoring line on the up line and the down line respectively. tli, tri are integers which denote the elapsed time when i-th car passed through the monitoring line for the up line and the down line respectively. You can assume that tl1 < tl2 < ... < tln、 tr1 < tr2 < ... < trm.
You can also assume that n, m ≤ 10000, and 1 ≤ tli, tri ≤ 1,000,000.
The end of input is indicated by a line including two zero.
Output
For each dataset, print the maximum value in a line.
Example
Input
4 5
20 35 60 70
15 30 40 80 90
3 2
10 20 30
42 60
0 1
100
1 1
10
50
0 0
Output
20
18
100
40
|
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
int i, n, m, x, max;
vector<int> data;
while(1){
cin >> n >> m;
if(n == 0 && m == 0) break;
for(i=0; i<n+m; ++i){
cin >> x;
data.push_back(x);
}
sort(data.begin(), data.end());
for(i=1, max=data[0]; i<data.size(); ++i){
if(max < data[i] - data[i-1])
max = data[i] - data[i-1];
}
cout << max << endl;
data.clear();
}
return 0;
}
|
The Balance of the World
The world should be finely balanced. Positive vs. negative, light vs. shadow, and left vs. right brackets. Your mission is to write a program that judges whether a string is balanced with respect to brackets so that we can observe the balance of the world.
A string that will be given to the program may have two kinds of brackets, round ("( )") and square ("[ ]"). A string is balanced if and only if the following conditions hold.
* For every left round bracket ("("), there is a corresponding right round bracket (")") in the following part of the string.
* For every left square bracket ("["), there is a corresponding right square bracket ("]") in the following part of the string.
* For every right bracket, there is a left bracket corresponding to it.
* Correspondences of brackets have to be one to one, that is, a single bracket never corresponds to two or more brackets.
* For every pair of corresponding left and right brackets, the substring between them is balanced.
Input
The input consists of one or more lines, each of which being a dataset. A dataset is a string that consists of English alphabets, space characters, and two kinds of brackets, round ("( )") and square ("[ ]"), terminated by a period. You can assume that every line has 100 characters or less. The line formed by a single period indicates the end of the input, which is not a dataset.
Output
For each dataset, output "yes" if the string is balanced, or "no" otherwise, in a line. There may not be any extra characters in the output.
Sample Input
So when I die (the [first] I will see in (heaven) is a score list).
[ first in ] ( first out ).
Half Moon tonight (At least it is better than no Moon at all].
A rope may form )( a trail in a maze.
Help( I[m being held prisoner in a fortune cookie factory)].
([ (([( [ ] ) ( ) (( ))] )) ]).
.
.
Output for the Sample Input
yes
yes
no
no
no
yes
yes
Example
Input
Output
|
import java.util.Scanner;
import java.util.Stack;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
while(sc.hasNextLine()){
String s = sc.nextLine();
if(s.equals(".")) break;
Stack<Character> count = new Stack<>();
boolean flag = true;
LABEL:
for(int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
switch(c) {
case '(':
count.push(')');
break;
case '[':
count.push(']');
break;
case ')':
case ']':
if(count.isEmpty() || count.peek() != c) {
flag = false;
break LABEL;
}else {
count.pop();
}
}
}
if(count.isEmpty() && flag) {
System.out.println("yes");
}
else {
System.out.println("no");
}
}
}
}
|
Do you know the famous series of children's books named "Where's Wally"? Each of the books contains a variety of pictures of hundreds of people. Readers are challenged to find a person called Wally in the crowd.
We can consider "Where's Wally" as a kind of pattern matching of two-dimensional graphical images. Wally's figure is to be looked for in the picture. It would be interesting to write a computer program to solve "Where's Wally", but this is not an easy task since Wally in the pictures may be slightly different in his appearances. We give up the idea, and make the problem much easier to solve. You are requested to solve an easier version of the graphical pattern matching problem.
An image and a pattern are given. Both are rectangular matrices of bits (in fact, the pattern is always square-shaped). 0 means white, and 1 black. The problem here is to count the number of occurrences of the pattern in the image, i.e. the number of squares in the image exactly matching the pattern. Patterns appearing rotated by any multiples of 90 degrees and/or turned over forming a mirror image should also be taken into account.
Input
The input is a sequence of datasets each in the following format.
w h p
image data
pattern data
The first line of a dataset consists of three positive integers w, h and p. w is the width of the image and h is the height of the image. Both are counted in numbers of bits. p is the width and height of the pattern. The pattern is always square-shaped. You may assume 1 ≤ w ≤ 1000, 1 ≤ h ≤ 1000, and 1 ≤ p ≤ 100.
The following h lines give the image. Each line consists of ⌈w/6⌉ (which is equal to &⌊(w+5)/6⌋) characters, and corresponds to a horizontal line of the image. Each of these characters represents six bits on the image line, from left to right, in a variant of the BASE64 encoding format. The encoding rule is given in the following table. The most significant bit of the value in the table corresponds to the leftmost bit in the image. The last character may also represent a few bits beyond the width of the image; these bits should be ignored.
character| value (six bits)
---|---
A-Z| 0-25
a-z| 26-51
0-9| 52-61
+| 62
/| 63
The last p lines give the pattern. Each line consists of ⌈p/6⌉ characters, and is encoded in the same way as the image.
A line containing three zeros indicates the end of the input. The total size of the input does not exceed two megabytes.
Output
For each dataset in the input, one line containing the number of matched squares in the image should be output. An output line should not contain extra characters.
Two or more matching squares may be mutually overlapping. In such a case, they are counted separately. On the other hand, a single square is never counted twice or more, even if it matches both the original pattern and its rotation, for example.
Example
Input
48 3 3
gAY4I4wA
gIIgIIgg
w4IAYAg4
g
g
w
153 3 3
kkkkkkkkkkkkkkkkkkkkkkkkkg
SSSSSSSSSSSSSSSSSSSSSSSSSQ
JJJJJJJJJJJJJJJJJJJJJJJJJI
g
Q
I
1 1 2
A
A
A
384 3 2
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
BCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/A
CDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/AB
A
A
0 0 0
Output
8
51
0
98
|
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <queue>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, k, n) for (int i = (k); i < (int)(n); ++i)
#define FOREQ(i, k, n) for (int i = (k); i <= (int)(n); ++i)
#define FORIT(i, c) for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define SZ(v) (int)((v).size())
#define MEMSET(v, h) memset((v), (h), sizeof(v))
#define FIND(m, w) ((m).find(w) != (m).end())
void print(char p[1010][1010], int w, int h) {
REP(y, h) {
REP(x, w) {
printf("%d ", p[y][x]);
}
puts("");
}
puts("");
}
struct PMA {
PMA *next[200];
int accept;
PMA() : accept(110) { MEMSET(next, 0); }
};
PMA *root1,*root2;
PMA *buildPMA(char p[1010][1010], int size) {
PMA *root = new PMA;
for (int i = 0; i < size; i++) {
PMA *t = root;
for (int j = 0; p[i][j]; j++) {
int c = p[i][j];
if (t->next[c] == NULL) {
t->next[c] = new PMA;
}
t = t->next[c];
}
if (t->accept == 110) {
t->accept = i + 1;
}
}
queue<PMA*> que;
for (int c = 1; c < 200; c++) {
if (root->next[c]) {
root->next[c]->next[0] = root;
que.push(root->next[c]);
} else {
root->next[c] = root;
}
}
while (!que.empty()) {
PMA *t = que.front();
que.pop();
for (int c = 1; c < 200; c++) {
if (t->next[c] != NULL) {
que.push(t->next[c]);
PMA *r = t->next[0];
while (!r->next[c]) {
r = r->next[0];
}
t->next[c]->next[0] = r->next[c];
}
//
//
//
}
}
return root;
}
void deletePMA(PMA *root) {
set<PMA*> visit;
queue<PMA*> que;
que.push(root);
visit.insert(root);
while (!que.empty()) {
PMA *t = que.front();
que.pop();
for (int c = 1; c < 200; c++) {
if (t->next[c] == NULL) { continue; }
if (visit.count(t->next[c])) { continue; }
visit.insert(t->next[c]);
que.push(t->next[c]);
}
}
FORIT(it, visit) { delete *it; }
}
char matchs[1010][1010];
int match(char *t, int n, const PMA *v, char matchs[1010][1010], int y) {
int ret = 0;
for (int i = 0; i < n; i++) {
int c = t[i];
while (!v->next[c]) {
v = v->next[0];
}
v = v->next[c];
if (v->accept != 110) { ret++; }
matchs[y][i] = v->accept;
}
return ret;
}
void reverse(char p[1010][1010], int w, int h) {
REP(y, h) {
reverse(p[y], p[y] + w);
}
}
char temp[1010][1010];
void rotate(char p[1010][1010], int w, int h) {
memcpy(temp, p, sizeof(temp));
REP(y, h) REP(x, w) {
temp[x][y] = p[h - y - 1][x];
}
memcpy(p, temp, sizeof(temp));
}
int width, height, p;
char str[1010];
char imageData[1010][1010];
char pattern[1010][1010];
char iniPattern[1010][1010];
char mapto[1][1010];
char temp2[1010][1010];
int calc() {
int ret = 0;
REP(y, height) {
match(imageData[y], width, root1, matchs, y);
}
rotate(matchs, width, height);
REP(y, width) {
ret += match(matchs[y], height, root2, temp2, y);
}
return ret;
}
int convert(char c) {
if (isupper(c)) {
return c - 'A';
} else if (islower(c)) {
return c - 'a' + 26;
} else if (isdigit(c)) {
return c - '0' + 52;
} else if (c == '+') {
return 62;
} else if (c == '/') {
return 63;
}
assert(false);
return -1;
}
void input(char data[1010][1010], int w, int h) {
REP(y, h) {
scanf("%s", str);
REP(x, (w + 5) / 6) {
int value = convert(str[x]);
REP(i, 6) {
data[y][x * 6 + (5 - i)] = (value & 1) + 1;
value >>= 1;
}
}
data[y][w] = 0;
}
}
int main() {
//freopen("H.in", "r", stdin);
while (scanf("%d %d %d", &width, &height, &p), width|height|p) {
MEMSET(matchs, 0);
MEMSET(mapto, 0);
MEMSET(temp, 0);
MEMSET(imageData, 0);
MEMSET(pattern, 0);
input(imageData, width, height);
input(pattern, p, p);
//print(imageData, width, height);
//print(pattern, p, p);
REP(y, p) {
char value = y;
REP(i, y) {
if (memcmp(pattern[y], pattern[i], sizeof(pattern[y])) == 0) { value = i; break; }
}
mapto[0][y] = value + 1;
}
root1 = buildPMA(pattern, p);
root2 = buildPMA(mapto, 1);
ll ans = 0;
REP(i, 2) {
REP(j, 4) {
//cout << i << " " << j << " " << width << " " << height << endl;
//print(imageData, width, height);
ans += calc();
rotate(imageData, width, height);
swap(width, height);
}
reverse(imageData, width, height);
}
bool lr = false;
bool ud = false;
bool mirror = false;
bool r180 = false;
memcpy(iniPattern, pattern, sizeof(pattern));
reverse(pattern, p, p);
if (memcmp(iniPattern, pattern, sizeof(pattern)) == 0) { lr = true;}
rotate(pattern, p, p);
if (memcmp(iniPattern, pattern, sizeof(pattern)) == 0) { mirror = true;}
rotate(pattern, p, p);
if (memcmp(iniPattern, pattern, sizeof(pattern)) == 0) { ud = true;}
reverse(pattern, p, p);
if (memcmp(iniPattern, pattern, sizeof(pattern)) == 0) { r180 = true;}
reverse(pattern, p, p);
rotate(pattern, p, p);
if (memcmp(iniPattern, pattern, sizeof(pattern)) == 0) { mirror = true;}
//cout << ans << endl;
//cout << ud << " " << lr << " " << mirror << " " << r180 << endl;
if (ud && lr && mirror) {
assert(ans % 8 == 0);
assert(r180);
ans /= 8;
} else if (r180) {
assert(ans % 4 == 0);
//assert(!ud && !lr);
ans /= 4;
} else if ((ud || lr) && mirror) {
assert(ans % 4 == 0);
ans /= 4;
} else if (ud || lr || mirror) {
assert(ans % 2 == 0);
assert(!r180);
ans /= 2;
}
deletePMA(root1);
deletePMA(root2);
printf("%lld\n", ans);
}
}
|
G, a college student living in a certain sky city, has a hornworm, Imotaro. He disciplined Imotaro to eat all the food in order with the shortest number of steps. You, his friend, decided to write a program because he asked me to find out if Imotaro was really disciplined.
Input
H W N
area
Input is given in H + 1 lines. The first line contains three integers H, W, N (2 ≤ H ≤ 10, 2 ≤ W ≤ 10, 1 ≤ N ≤ 9). H is the height of the area, W is the width, and N is the number of foods (at this time, 6 + N ≤ H × W always holds).
In each line from the 2nd line to H + 1st line, ´S´, ´1´, 2´,… ´9´, ´a´, ´b´, ´c´, ´d´, ´e´, A W character string consisting of ´ # ´ and ´.´ is written, and each represents the state of each section of the area. In addition, ´S´, ´a´, ´b´, ´c´, ´d´, ´e´ represent the initial state of the hornworm. There is no food or obstacles so that it is covered with the hornworm in the initial state. In addition, the initial position of the hornworm and the position of the food are guaranteed to be entered correctly.
Output
Output the minimum number of steps when the hornworm eats food in order, or -1 if that is not possible.
Examples
Input
5 8 3
#.......
#.####2#
#.#.3..#
#.######
.1Sabcde
Output
14
Input
5 8 3
.......
.####2#
.#.3..#
.######
.1Sabcde
Output
14
Input
2 6 2
.1.baS
.2.cde
Output
7
Input
2 6 2
.1#baS
.2.cde
Output
-1
|
/*
* h.cc:
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
using namespace std;
/* constant */
const int MAX_H = 10;
const int MAX_W = 10;
const int MAX_N = 9;
const int M = 5;
const int DBITS = 1 << (M * 2);
const int INF = 1 << 30;
const int dxs[] = {1, 0, -1, 0}, dys[] = {0, -1, 0, 1};
/* typedef */
struct Stat {
int d, k, x, y, dbits;
};
/* global variables */
string flds[MAX_H];
int xs[M], ys[M];
int dists[MAX_N][MAX_H][MAX_W][DBITS];
/* subroutines */
bool move(Stat &s, int h, int w, int di) {
int x0 = s.x + dxs[di], y0 = s.y + dys[di];
if (x0 < 0 || x0 >= w || y0 < 0 || y0 >= h || flds[y0][x0] == '#')
return false;
for (int i = 0, x = s.x, y = s.y; i < M - 1; i++) {
int dii = ((s.dbits >> (i * 2)) & 3);
x += dxs[dii], y += dys[dii];
if (x0 == x && y0 == y) return false;
}
s.dbits = ((s.dbits << 2) & (DBITS - 1)) | ((di + 2) & 3);
s.x = x0, s.y = y0;
s.d++;
return true;
}
/* main */
int main() {
int h, w, n;
cin >> h >> w >> n;
Stat st;
st.d = st.k = st.dbits = 0;
for (int y = 0; y < h; y++) {
cin >> flds[y];
for (int x = 0; x < w; x++) {
char ch = flds[y][x];
if (ch == 'S') st.x = x, st.y = y;
else if (ch >= 'a' && ch <= 'e') {
int id = ch - 'a';
xs[id] = x, ys[id] = y;
}
}
}
for (int i = 0, x = st.x, y = st.y; i < M; i++) {
int dx = xs[i] - x, dy = ys[i] - y;
for (int di = 0; di < 4; di++)
if (dx == dxs[di] && dy == dys[di]) {
st.dbits |= (di << (i * 2));
break;
}
x = xs[i], y = ys[i];
}
for (int i = 0; i < n; i++)
for (int y = 0; y < h; y++)
for (int x = 0; x < w; x++)
for (int bits = 0; bits < DBITS; bits++)
dists[i][y][x][bits] = INF;
dists[0][st.y][st.x][st.dbits] = 0;
queue<Stat> q;
q.push(st);
int ans = -1;
while (! q.empty()) {
Stat u = q.front(); q.pop();
int uch = flds[u.y][u.x];
if (uch == '1' + u.k) {
if (++u.k >= n) {
ans = u.d;
break;
}
dists[u.k][u.y][u.x][u.dbits] = u.d;
}
for (int di = 0; di < 4; di++) {
Stat v = u;
if (move(v, h, w, di) &&
dists[v.k][v.y][v.x][v.dbits] > v.d) {
dists[v.k][v.y][v.x][v.dbits] = v.d;
q.push(v);
}
}
}
printf("%d\n", ans);
return 0;
}
|
In 1936, a dictator Hiedler who aimed at world domination had a deep obsession with the Lost Ark. A person with this ark would gain mystic power according to legend. To break the ambition of the dictator, ACM (the Alliance of Crusaders against Mazis) entrusted a secret task to an archeologist Indiana Johns. Indiana stepped into a vast and harsh desert to find the ark.
Indiana finally found an underground treasure house at a ruin in the desert. The treasure house seems storing the ark. However, the door to the treasure house has a special lock, and it is not easy to open the door.
To open the door, he should solve a problem raised by two positive integers a and b inscribed on the door. The problem requires him to find the minimum sum of squares of differences for all pairs of two integers adjacent in a sorted sequence that contains four positive integers a1, a2 , b1 and b2 such that a = a1a2 and b = b1b2. Note that these four integers does not need to be different. For instance, suppose 33 and 40 are inscribed on the door, he would have a sequence 3, 5, 8, 11 as 33 and 40 can be decomposed into 3 × 11 and 5 × 8 respectively. This sequence gives the sum (5 - 3)2 + (8 - 5)2 + (11 - 8)2 = 22, which is the smallest sum among all possible sorted sequences. This example is included as the first data set in the sample input.
Once Indiana fails to give the correct solution, he will suffer a calamity by a curse. On the other hand, he needs to solve the problem as soon as possible, since many pawns under Hiedler are also searching for the ark, and they might find the same treasure house. He will be immediately killed if this situation happens. So he decided to solve the problem by your computer program.
Your task is to write a program to solve the problem presented above.
Input
The input consists of a series of data sets. Each data set is given by a line that contains two positive integers not greater than 10,000.
The end of the input is represented by a pair of zeros, which should not be processed.
Output
For each data set, print a single integer that represents the minimum square sum in a line. No extra space or text should appear.
Example
Input
33 40
57 144
0 0
Output
22
94
|
#include <algorithm>
#include <cmath>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <cassert>
#include <functional>
using namespace std;
#define LOG(...) printf(__VA_ARGS__)
//#define LOG(...)
#define FOR(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define RSORT(c) sort((c).rbegin(),(c).rend())
#define CLR(a) memset((a), 0 ,sizeof(a))
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int dx[] = { -1, 0, 1, 0 }; const int dy[] = { 0, 1, 0, -1 };
int main() {
int x, y;
while (cin >> x >> y, x){
vector<int> xv;
vector<int> yv;
for (int i = 1; i <= sqrt(x); i++){
if (x%i == 0)xv.push_back(i);
}
for (int i = 1; i <= sqrt(y); i++){
if (y%i == 0)yv.push_back(i);
}
vector<int> calc(4);
int ans = 1000000007;
REP(i, xv.size()){
REP(j, yv.size()){
calc[0] = xv[i];
calc[1] = x / xv[i];
calc[2] = yv[j];
calc[3] = y / yv[j];
SORT(calc);
ans = min(ans, (calc[0] - calc[1])*(calc[0] - calc[1]) + (calc[2] - calc[1])*(calc[2] - calc[1]) + (calc[3] - calc[2])*(calc[3] - calc[2]));
}
}
cout << ans << endl;
}
}
|
This is a story of a world somewhere far from the earth. In this world, the land is parted into a number of countries ruled by empires. This world is not very peaceful: they have been involved in army race.
They are competing in production of missiles in particular. Nevertheless, no countries have started wars for years. Actually they have a reason they can’t get into wars - they have missiles much more than enough to destroy the entire world. Once a war would begin among countries, none of them could remain.
These missiles have given nothing but scare to people. The competition has caused big financial and psychological pressure to countries. People have been tired. Military have been tired. Even empires have been tired. No one wishes to keep on missile production.
So empires and diplomats of all countries held meetings quite a few times toward renouncement of missiles and abandon of further production. The meetings were quite difficult as they have different matters. However, they overcame such difficulties and finally came to the agreement of a treaty. The points include:
* Each country will dispose all the missiles of their possession by a certain date.
* The war potential should not be different by greater than a certain amount d among all countries.
Let us describe more details on the second point. Each missile has its capability, which represents how much it can destroy the target. The war potential of each country is measured simply by the sum of capability over missiles possessed by that country. The treaty requires the difference to be not greater than d between the maximum and minimum potential of all the countries.
Unfortunately, it is not clear whether this treaty is feasible. Every country is going to dispose their missiles only in the order of time they were produced, from the oldest to the newest. Some missiles have huge capability, and disposal of them may cause unbalance in potential.
Your task is to write a program to see this feasibility.
Input
The input is a sequence of datasets. Each dataset is given in the following format:
n d
m1 c1,1 ... c1,m1
...
mn cn,1 ... cn,mn
The first line contains two positive integers n and d, the number of countries and the tolerated difference of potential (n ≤ 100, d ≤ 1000). Then n lines follow. The i-th line begins with a non-negative integer mi, the number of the missiles possessed by the i-th country. It is followed by a sequence of mi positive integers. The j-th integer ci,j represents the capability of the j-th newest missile of the i-th country (ci,j ≤ 1000). These integers are separated by a single space. Note that the country disposes their missiles in the reverse order of the given sequence.
The number of missiles is not greater than 10000. Also, you may assume the difference between the maximum and minimum potential does not exceed d in any dataset.
The input is terminated by a line with two zeros. This line should not be processed.
Output
For each dataset, print a single line. If they can dispose all their missiles according to the treaty, print "Yes" (without quotes). Otherwise, print "No".
Note that the judge is performed in a case-sensitive manner. No extra space or character is allowed.
Example
Input
3 3
3 4 1 1
2 1 5
2 3 3
3 3
3 2 3 1
2 1 5
2 3 3
0 0
Output
Yes
No
|
#include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
int main()
{
for(;;){
int n, d;
cin >> n >> d;
if(n == 0 && d == 0)
return 0;
vector<stack<int> > q(n);
vector<int> sum(n, 0);
for(int i=0; i<n; ++i){
int m;
cin >> m;
while(--m >= 0){
int a;
cin >> a;
q[i].push(a);
sum[i] += a;
}
}
multiset<int> ms;
for(int i=0; i<n; ++i)
ms.insert(sum[i]);
bool ng;
while(*ms.rbegin() != 0){
ng = true;
for(int i=0; i<n; ++i){
if(sum[i] == 0)
continue;
ms.erase(ms.find(sum[i]));
int x = sum[i] - q[i].top();
if(abs(*ms.begin() - x) <= d && abs(*ms.rbegin() - x) <= d){
q[i].pop();
sum[i] = x;
ng = false;
}
ms.insert(sum[i]);
}
if(ng)
break;
}
if(ng)
cout << "No" << endl;
else
cout << "Yes" << endl;
}
}
|
``Domino effect'' is a famous play using dominoes. A player sets up a chain of dominoes stood. After a chain is formed, the player topples one end of the dominoes. The first domino topples the second domino, the second topples the third and so on.
You are playing domino effect. Before you finish to set up a chain of domino, a domino block started to topple, unfortunately. You have to stop the toppling as soon as possible.
The domino chain forms a polygonal line on a two-dimensional coordinate system without self intersections. The toppling starts from a certain point on the domino chain and continues toward the both end of the chain. If the toppling starts on an end of the chain, the toppling continue toward the other end. The toppling of a direction stops when you touch the toppling point or the toppling reaches an end of the domino chain.
You can assume that:
* You are a point without volume on the two-dimensional coordinate system.
* The toppling stops soon after touching the toppling point.
* You can step over the domino chain without toppling it.
You will given the form of the domino chain, the starting point of the toppling, your coordinates when the toppling started, the toppling velocity and the your velocity. You are task is to write a program that calculates your optimal move to stop the toppling at the earliest timing and calculates the minimum time to stop the toppling.
Input
The first line contains one integer N, which denotes the number of vertices in the polygonal line of the domino chain (2 \leq N \leq 1000). Then N lines follow, each consists of two integers x_{i} and y_{i}, which denote the coordinates of the i-th vertex (-10,000 \leq x, y \leq 10000). The next line consists of three integers x_{t}, y_{t} and v_{t}, which denote the coordinates of the starting point and the velocity of the toppling. The last line consists of three integers x_{p}, y_{p} and v_{p}, which denotes the coordinates of you when the toppling started and the velocity (1 \leq v_{t} \lt v_{p} \leq 10). You may assume that the starting point of the toppling lies on the polygonal line.
Output
Print the minimum time to stop the toppling. The output must have a relative or absolute error less than 10^{-6}.
Examples
Input
2
0 0
15 0
5 0 1
10 10 2
Output
5.0
Input
3
-10 0
0 0
0 10
-1 0 1
3 0 2
Output
4.072027
Input
2
0 0
10 0
5 0 1
9 0 3
Output
2.0
|
#include<cstdio>
#include<complex>
#include<vector>
#include<cmath>
#include<utility>
#include<algorithm>
using namespace std;
const double eps=1e-9;
template<class T> bool eq(T a,T b){
return abs(a-b)<eps;
}
template<class T> int sgn(T a){
return eq(a,0.0)?0:(a>0?1:-1);
}
typedef complex<double> Point;
typedef complex<double> Vector;
typedef pair<Point,Point> Segment;
typedef vector<Point> Polyline;
Polyline poly;
Point pd,ph;
double vd,vh;
int N;
bool onSeg(Point a,Point b,Point c){
//Is c on a-b?
return eq(abs(a-b),abs(a-c)+abs(b-c));
}
double doP(Vector a,Vector b){
return (conj(a)*b).real();
}
Point proj(Point a,Point b,Point c){
if(eq(a,b)) return c;
Point x=b-a,p=c-a;
Point pr=x*(doP(x,p)/norm(x));
return pr+a;
}
pair<double,Point> solve(Segment seg,Point pt,double human,double domino){
Point p1=seg.first,p2=seg.second;
double d1=abs(p1-pt),d2=abs(p2-pt);
double ln=abs(p1-p2);
double t1=d1/vh,t2=d2/vh;
double td=ln/vd;
if(human+t2>domino+td) return make_pair(-1,pt);
Point lb=p1,ub=p2;
for(int stage=0;stage<100;stage++){
Point mid=(lb+ub)/2.0;
double lDomino=abs(mid-p1);
double lHuman=abs(mid-pt);
double tDomino=domino+lDomino/vd;
double tHuman=human+lHuman/vh;
if(tHuman>tDomino) lb=mid;
else ub=mid;
}
double retT=domino+abs(lb-p1)/vd;
Point retP=lb;
return make_pair(retT,retP);
}
double getLen(Polyline poly){
double res=0;
for(int i=0;i+1<poly.size();i++){
res+=abs(poly[i+1]-poly[i]);
}
return res;
}
pair<double,Point> solve(Polyline poly,Point pt,double human){
if(poly.size()<=1){
return make_pair(0,pt);
}
double disSum=0;
for(int i=0;i+1<poly.size();i++){
Segment seg;
seg.first=poly[i];
seg.second=poly[i+1];
Point perp=proj(poly[i],poly[i+1],pt);
if(onSeg(poly[i],poly[i+1],perp)){
Segment seg1,seg2;
seg1=Segment(poly[i],perp);
seg2=Segment(perp,poly[i+1]);
pair<double,Point> res;
res=solve(seg1,pt,human,disSum/vd);
if(res.first>=0) return res;
disSum+=abs(perp-poly[i]);
res=solve(seg2,pt,human,disSum/vd);
if(res.first>=0) return res;
disSum+=abs(poly[i+1]-perp);
}else{
pair<double,Point> res;
res=solve(seg,pt,human,disSum/vd);
if(res.first>=0){
return res;
}
disSum+=abs(poly[i+1]-poly[i]);
}
}
return make_pair(0,pt);
}
double solve(Polyline left,Polyline right,Point pt){
//go left->go right
pair<double,Point> resL=solve(left,pt,0);
pair<double,Point> resLR=solve(right,resL.second,resL.first);
double cur;
if(resL.first<eps){
cur=getLen(left)/vd;
}else{
cur=resL.first;
}
if(resLR.first<eps){
cur=max(cur,getLen(right)/vd);
}else{
cur=max(cur,resLR.first);
}
return cur;
}
int main(){
int N;
scanf("%d",&N);
for(int i=0;i<N;i++){
int x,y;
scanf("%d%d",&x,&y);
poly.push_back(Point(x,y));
}
int x,y,v;
scanf("%d%d%d",&x,&y,&v);
pd=Point(x,y);
vd=v;
scanf("%d%d%d",&x,&y,&v);
ph=Point(x,y);
vh=v;
if(eq(pd,ph)){
printf("0\n");
return 0;
}
if(eq(poly[0],pd)||eq(poly[N-1],pd)){
if(eq(poly[N-1],pd)){
reverse(poly.begin(),poly.end());
}
pair<double,Point> res=solve(poly,ph,0);
double ans=res.first;
if(ans<eps){
double allDis=getLen(poly);
ans=allDis/vd;
printf("%.9f\n",ans);
return 0;
}
}
for(int i=0;i<N-1;i++){
Point p1=poly[i];
Point p2=poly[i+1];
bool flg=onSeg(p1,p2,pd);
if(flg){
double ans=1e30;
Polyline left,right;
left.push_back(pd);
for(int j=i;j>=0;j--) if(!eq(pd,poly[j])) left.push_back(poly[j]);
right.push_back(pd);
for(int j=i+1;j<N;j++) if(!eq(pd,poly[j])) right.push_back(poly[j]);
ans=min(ans,solve(left,right,ph));
ans=min(ans,solve(right,left,ph));
printf("%.9f\n",ans);
break;
}
}
return 0;
}
|
At the school where the twins Ami and Mami attend, the summer vacation has already begun, and a huge amount of homework has been given this year as well. However, the two of them were still trying to go out without doing any homework today. It is obvious that you will see crying on the last day of summer vacation as it is, so you, as a guardian, decided not to leave the house until you finished your homework of reading impressions today with your heart as a demon.
Well-prepared you have already borrowed all the assignment books from the library. However, according to library rules, only one book is borrowed for each book. By the way, for educational reasons, I decided to ask them to read all the books and write their impressions without cooperating with each other. In addition, since the deadline for returning books is near, I decided to have them finish reading all the books as soon as possible. And you decided to think about how to do your homework so that you can finish your homework as soon as possible under those conditions. Here, the time when both the twins finish their work is considered as the time when they finish reading the book and the time when they finish their homework.
Since there is only one book for each book, two people cannot read the same book at the same time. In addition, due to adult circumstances, once you start reading a book, you cannot interrupt it, and once you start writing an impression about a book, you cannot interrupt it. Of course, I can't write my impressions about a book I haven't read. Since Ami and Mami are twins, the time it takes to read each book and the time it takes to write an impression are common to both of them.
For example, suppose that there are three books, and the time it takes to read each book and the time it takes to write an impression are as follows.
| Time to read a book | Time to write an impression
--- | --- | ---
Book 1 | 5 | 3
Book 2 | 1 | 2
Book 3 | 1 | 2
In this case, if you proceed with your homework as shown in Figure C-1, you can finish reading all the books in time 10 and finish your homework in time 15. In the procedure shown in Fig. C-2, the homework is completed in time 14, but it cannot be adopted this time because the time to finish reading the book is not the shortest. Also, as shown in Fig. C-3, two people cannot read the same book at the same time, interrupt reading of a book as shown in Fig. C-4, or write an impression of a book that has not been read.
<image>
Figure C-1: An example of how to get the homework done in the shortest possible time
<image>
Figure C-2: An example where the time to finish reading a book is not the shortest
<image>
Figure C-3: An example of two people reading the same book at the same time
<image>
Figure C-4: An example of writing an impression of a book that has not been read or interrupting work.
Considering the circumstances of various adults, let's think about how to proceed so that the homework can be completed as soon as possible for the twins who want to go out to play.
Input
The input consists of multiple datasets. The format of each data set is as follows.
N
r1 w1
r2 w2
...
rN wN
N is an integer representing the number of task books, and can be assumed to be 1 or more and 1,000 or less.
The following N lines represent information about the task book. Each line contains two integers separated by spaces, ri (1 ≤ ri ≤ 1,000) is the time it takes to read the i-th book, and wi (1 ≤ wi ≤ 1,000) is the impression of the i-th book. Represents the time it takes to write.
N = 0 indicates the end of input. This is not included in the dataset.
Output
For each dataset, output the minimum time to finish writing all the impressions on one line when the time to finish reading all the books by two people is minimized.
Sample Input
Four
1 1
3 1
4 1
twenty one
3
5 3
1 2
1 2
1
1000 1000
Ten
5 62
10 68
15 72
20 73
25 75
30 77
35 79
40 82
45 100
815 283
6
74 78
53 55
77 77
12 13
39 42
1 1
0
Output for Sample Input
14
15
3000
2013
522
Example
Input
4
1 1
3 1
4 1
2 1
3
5 3
1 2
1 2
1
1000 1000
10
5 62
10 68
15 72
20 73
25 75
30 77
35 79
40 82
45 100
815 283
6
74 78
53 55
77 77
12 13
39 42
1 1
0
Output
14
15
3000
2013
522
|
#include <bits/stdc++.h>
typedef long long LL;
#define SORT(c) sort((c).begin(),(c).end())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
using namespace std;
int main(void)
{
for(;;){
int n;
cin >> n;
if(!n) return 0;
vector<int> a,b;
a.resize(n);
b.resize(n);
REP(i,n) cin >> a[i] >> b[i];
int asum=0,amax=0,bsum=0;
REP(i,n){
asum+=a[i];
amax=max(amax,a[i]);
bsum+=b[i];
}
int dp[4096];
REP(i,2048) dp[i]=0;
dp[0]=1;
REP(i,n) for(int j=1000;j>=0;--j){
if(a[i]==amax) continue;
if(dp[j]){
dp[j+a[i]]+=dp[j];
dp[j+a[i]+b[i]]+=dp[j];
}
}
int answer=asum+bsum;
if(asum<amax*2){
for(int i=amax;dp[i]==0;--i) answer++;
}
cout << answer << endl;
}
}
|
D: Rescue a Postal Worker
story
You got a job at the post office, which you have long dreamed of this spring. I decided on the delivery area I was in charge of, and it was my first job with a feeling of excitement, but I didn't notice that there was a hole in the bag containing the mail because it was so floating that I dropped all the mail that was in it. It was. However, since you are well prepared and have GPS attached to all mail, you can know where the mail is falling.
You want to finish the delivery in the shortest possible time, as you may exceed the scheduled delivery time if you are picking up the mail again. Pick up all the dropped mail and find the shortest time to deliver it to each destination.
problem
Consider an undirected graph as the delivery area you are in charge of. When considering an undirected graph consisting of n vertices, each vertex is numbered from 1 to n. Given the number of dropped mails, the apex of the dropped mail, and the apex of the delivery destination of each mail, find the shortest time to collect all the mail and deliver it to the delivery destination. At this time, there may be other mail that has not been picked up when delivering a certain mail to the delivery destination of the mail. In addition, it is acceptable to be at any apex at the end of delivery.
Here, there is at most one mail item or at most one delivery destination at one apex, and there is no mail or delivery destination at the departure apex. Given undirected graphs are simple graphs, that is, graphs without self-cycles or multiple edges.
Input format
The format of the input data is as follows.
n m k p
x_1 y_1 w_1
...
x_m y_m w_m
s_1 t_1
...
s_k t_k
The first line contains the number of vertices n (3 ≤ n ≤ 1,000), the number of sides m (1 ≤ m ≤ 2,000), the number of dropped mails k (1 ≤ k ≤ 6), and the starting point p (1 ≤ 6). p ≤ n) is given. Input items in the line are given separated by one blank.
The following m lines give information about the edges in the graph. The i-th line is given the vertices x_i (1 ≤ x_i ≤ n), y_i (1 ≤ y_i ≤ n) and the weight w_i (1 ≤ w_i ≤ 1,000) at both ends of the i-th edge.
The jth line of the following k line is given the vertex s_j (1 ≤ s_j ≤ n) with the dropped mail and the vertex t_j (1 ≤ t_j ≤ n) of the delivery destination of the mail.
Here, the graph given has no self-cycles or multiple edges, and the starting point, the apex where each piece of mail falls, and each delivery destination are all different from each other.
Output format
Display on one line the shortest time to deliver all mail to each destination, starting from the apex p. However, if it cannot be delivered, output "Cannot deliver".
Input example 1
5 6 1 1
1 3 5
1 2 2
2 3 1
3 5 4
3 4 2
4 5 3
3 5
Output example 1
7
Input example 2
5 6 1 1
1 3 5
1 2 2
2 3 1
3 5 4
3 4 2
4 5 3
5 3
Output example 2
11
Input example 3
3 1 1 1
1 2 1
twenty three
Output example 3
Cannot deliver
Input example 4
5 8 2 3
1 2 1
2 3 4
3 4 5
4 5 3
5 1 4
1 3 3
2 5 1
5 3 4
1 2
5 4
Output example 3
8
Example
Input
5 6 1 1
1 3 5
1 2 2
2 3 1
3 5 4
3 4 2
4 5 3
3 5
Output
7
|
#include <algorithm>
#include <functional>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <bitset>
#include <climits>
#define all(c) (c).begin(), (c).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second
const int INF=100000000;
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
using namespace std;
typedef pair<int ,int > P;
typedef long long ll;
struct Edge{
int to,cost;
Edge(int to,int cost) :to(to),cost(cost){}
Edge(){}
};
struct Lost{
int s,t;
Lost(int s,int t) :s(s),t(t){}
Lost(){}
};
struct State{
int v;
int cost;
int bit1,bit2;
State(int v,int cost,int bit1,int bit2):
v(v),cost(cost),bit1(bit1),bit2(bit2){}
State(){}
bool operator>(const State rth) const {
return this->cost>rth.cost;
}
};
int n,m,k,p;
vector<Edge> G[1003];
Lost lost[10];
int dp[1003][1<<6][1<<6];
int dijk() {
rep(i,1003) rep(j,1<<6) rep(c,1<<6) dp[i][j][c]=INF;
dp[p][0][0]=0;
priority_queue<State,vector<State> ,greater<State> > que;
que.push(State(p,0,0,0));
while(que.size()) {
State s=que.top(); que.pop();
if(s.bit2+1==(1<<k)) break;
if(dp[s.v][s.bit1][s.bit2]>s.cost) continue;
rep(i,G[s.v].size()) {
Edge e=G[s.v][i];
rep(a,k) {
if(lost[a].s==e.to) {
if(dp[e.to][s.bit1|1<<a][s.bit2]>dp[s.v][s.bit1][s.bit2]+e.cost) {
dp[e.to][s.bit1|1<<a][s.bit2]=dp[s.v][s.bit1][s.bit2]+e.cost;
que.push(State(e.to,dp[e.to][s.bit1|1<<a][s.bit2],s.bit1|1<<a,s.bit2));
}
}
if(lost[a].t==e.to&&(s.bit1>>a)&1) {
if(dp[e.to][s.bit1][s.bit2|1<<a]>dp[s.v][s.bit1][s.bit2]+e.cost) {
dp[e.to][s.bit1][s.bit2|1<<a]=dp[s.v][s.bit1][s.bit2]+e.cost;
que.push(State(e.to,dp[e.to][s.bit1][s.bit2|1<<a],s.bit1,s.bit2|1<<a));
}
}
}
if(dp[e.to][s.bit1][s.bit2]>dp[s.v][s.bit1][s.bit2]+e.cost) {
dp[e.to][s.bit1][s.bit2]=dp[s.v][s.bit1][s.bit2]+e.cost;
que.push(State(e.to,dp[e.to][s.bit1][s.bit2],s.bit1,s.bit2));
}
}
}
int ans=INF;
rep(i,n) ans=min(ans,dp[i][(1<<k)-1][(1<<k)-1]);
return ans;
}
int main() {
cin>>n>>m>>k>>p;
p--;
rep(i,m) {
int x,y,w;
cin>>x>>y>>w;
x--,y--;
G[x].pb(Edge(y,w));
G[y].pb(Edge(x,w));
}
rep(i,k) {
int s,t;
cin>>s>>t;
s--,t--;
lost[i].s=s;
lost[i].t=t;
}
int ans=dijk();
if(ans==INF) cout<<"Cannot deliver"<<endl;
else cout<<ans<<endl;
return 0;
}
|
problem
The point $ P $ is placed at the origin on the coordinate plane. I want to move the point $ P $ to a position where the Manhattan distance from the origin is as far as possible.
First, the string $ S = s_1s_2 \ cdots s_ {| S |} $ ($ | S | $ is the number of characters in $ S $) is given. The point $ P $ is moved by reading the characters one by one from the beginning of the character string $ S $. The string $ S $ consists of the letters'U',' L',' D', and'R'. When each character is read, if the coordinates of the point $ P $ before movement are $ (x, y) $, the coordinates of the point $ P $ after movement are $ (x, y + 1) and \ (, respectively. It becomes x-1, y), \ (x, y-1), \ (x + 1, y) $.
Immediately before reading each character, you can choose whether or not to cast magic. There are two types of magic, magic 1 and magic 2. Assuming that the $ i $ th character of the character string $ S $ is $ s_i $, the change when magic is applied immediately before reading $ s_i $ is as follows.
* When magic 1 is applied: For all $ s_j \ (i \ le j \ le | S |) $, replace'U'with'D'and'D' with'U'.
* When magic 2 is applied: For all $ s_j \ (i \ le j \ le | S |) $, replace'L'with'R'and'R' with'L'.
Intuitively, Magic 1 can reverse the subsequent treatment of the top and bottom, and Magic 2 can reverse the treatment of the left and right. The number of times the magic is applied before reading a certain character may be multiple times. You can also apply both spells in succession. However, the total number of times that magic can be applied before reading all the characters in the character string $ S $ is $ K $. See the sample for details.
Find the maximum value of $ | x'| + | y'| $, where $ (x', y') $ is the coordinate of the point $ P $ after reading all the characters in the string $ S $. ..
input
Input is given from standard input in the following format.
$ S $
$ K $
output
Output the maximum value of $ | x'| + | y'| $ in one line. Also, output a line break at the end.
Example
Input
RRLUDDD
2
Output
7
|
#define _USE_MATH_DEFINES
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
using namespace std;
typedef pair<long long int, long long int> P;
long long int INF = 1e18;
long long int MOD = 1e9 + 7;
long long int DP[2100][2100];
long long int res[2100][2] = {};
int main(){
string SS, S[2] = {"", ""}, hoge = " ";
cin >> SS;
int K;
cin >> K;
for(int i = 0; i < SS.size(); i++){
if(SS[i] == 'L' || SS[i] == 'R'){
hoge[0] = '0' + (SS[i] == 'R');
S[0] += hoge;
}else{
hoge[0] = '0' + (SS[i] == 'U');
S[1] += hoge;
}
}
for(int n = 0; n < 2; n++){
for(int p = 0; p < 2; p++){
for(int i = 0; i < 2100; i++){
for(int j = 0; j < 2100; j++){
DP[i][j] = -INF;
}
}
DP[0][0] = 0;
for(int i = 0; i < S[n].size(); i++){
for(int j = 0; j <= K; j++){
if(S[n][i] == '0' + (p + j) % 2){
DP[i + 1][j] = max(DP[i + 1][j], DP[i][j] - 1);
}else{
DP[i + 1][j] = max(DP[i + 1][j], DP[i][j] + 1);
}
DP[i][j + 1] = max(DP[i][j + 1], DP[i][j]);
}
}
for(int j = 0; j <= K; j++){
DP[S[n].size()][j + 1] = max(DP[S[n].size()][j + 1], DP[S[n].size()][j]);
res[j][n] = max(res[j][n], DP[S[n].size()][j]);
}
}
}
long long int ans = 0;
for(int i = 0; i <= K; i++){
ans = max(ans, res[i][0] + res[K - i][1]);
}
cout << ans << endl;
return 0;
}
|
Great performance strategy
Taro, an examinee, participated in an N-day study camp. In this training camp, M subjects are tested every day, and after the training camp, a report card with all the test scores is distributed. The report card consists of N sheets of paper, and on the i-th sheet, only the subject names and scores of the tests of all M subjects on the i-day are printed.
Taro noticed that the date was not written on the report card, and decided to add some work before giving the report card to his mother. By rearranging the order of the papers in the report card and writing the page numbers in order from the first sheet to make a booklet, a "fake report card" was created. Taro's purpose is to maximize the number of subjects whose test scores are monotonously increasing with respect to page numbers in the "False Report Card".
When Taro makes a "false grade report", find the maximum number of subjects whose test scores are monotonously increasing with respect to the page number.
However, the N-day test score is a broad monotonous increase with respect to the page number. For 1 ≤ i <N, the score on the i + 1 sheet is the score on the i-th sheet. It means that it is the above.
Input
The input consists of 50 or less datasets. Each dataset is represented in the following format.
> N M a11 ... a1M ... aN1 ... aNM
The first line gives the number of days N and the number of subjects M for the study camp. N is an integer between 1 and 103, and M is an integer between 1 and 40.
Taro's score is given to the following N lines. Each line consists of M integers, where aij is the score of Taro-kun's subject j on day i, and aij is an integer between 0 and 103.
The end of the input is represented by a line of two zeros.
Output
For each dataset, output the maximum number of subjects whose test scores are monotonously increasing with respect to the page number on one line.
Sample Input
3 3
one two Three
2 1 3
3 3 3
8 5
3 3 4 3 4
2 1 2 3 2
7 9 7 8 7
3 4 3 3 4
1 2 2 3 2
4 5 6 5 6
7 9 7 7 8
4 5 5 6 6
5 5
1 2 3 4 5
2 3 4 5 1
3 4 5 1 2
4 5 1 2 3
5 1 2 3 4
5 9
1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2
3 3 3 3 3 3 3 3 3
4 4 4 4 4 4 4 4 4
5 5 5 5 5 5 5 5 5
0 0
Output for the Sample Input
2
3
1
9
Example
Input
3 3
1 2 3
2 1 3
3 3 3
8 5
3 3 4 3 4
2 1 2 3 2
7 9 7 8 7
3 4 3 3 4
1 2 2 3 2
4 5 6 5 6
7 9 7 7 8
4 5 5 6 6
5 5
1 2 3 4 5
2 3 4 5 1
3 4 5 1 2
4 5 1 2 3
5 1 2 3 4
5 9
1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2
3 3 3 3 3 3 3 3 3
4 4 4 4 4 4 4 4 4
5 5 5 5 5 5 5 5 5
0 0
Output
2
3
1
9
|
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
using ll = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b)a=b;};
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b)a=b;};
struct SCC{
vector<vector<int> > G, R, T, C;
vector<int> vs, used, blg;
SCC(){}
SCC(int n):G(n), R(n), used(n), blg(n){}
void add_edge(int u, int v){
G[u].emplace_back(v);
R[v].emplace_back(u);
}
void dfs(int v){
used[v] = 1;
for(int u:G[v])
if(!used[u]) dfs(u);
vs.emplace_back(v);
}
void rdfs(int v, int k){
used[v] = 1;
blg[v] = k;
C[k].emplace_back(v);
for(int u:R[v])
if(!used[u]) rdfs(u, k);
}
int build(){
int n =G.size();
for(int v=0;v<n;v++)
if(!used[v]) dfs(v);
fill(used.begin(), used.end(), 0);
int k = 0;
for(int i=n-1;i>=0;i--){
if(!used[vs[i]]){
T.emplace_back();
C.emplace_back();
rdfs(vs[i], k++);
}
}
for(int v=0;v<n;v++)
for(int u:G[v])
if(blg[v] != blg[u])
T[blg[v]].push_back(blg[u]);
for(int i=0;i<k;i++){
sort(T[i].begin(), T[i].end());
T[i].erase(unique(T[i].begin(), T[i].end()), T[i].end());
}
return k;
}
int operator[](int k) const{return blg[k];}
};
struct IndependentSet{
int n;
vector<vector<int> > G;
IndependentSet(int n):n(n), G(n){}
void add_edge(int u, int v){
G[u].emplace_back(v);
G[v].emplace_back(u);
}
int build(){
vector<int> deg(n, 0);
for(int i=0;i<n;i++) deg[i] = G[i].size();
int res = 0, cnt = 0, alive = n;
vector<int> used(n, 0), dead(n, 0);
function<void(void)> dfs = [&](){
if(cnt + alive <= res) return;
int v = -1;
for(int i=0;i<n;i++){
if(used[i] || dead[i] ) continue;
if(deg[i] <= 1){
v = i;
break;
}
if(v < 0 || deg[v] < deg[i]) v = i;
}
if(v < 0) return;
if(deg[v] != 1){
dead[v] = 1;
alive--;
for(int u:G[v]) deg[u]--;
dfs();
dead[v] = 0;
alive++;
for(int u:G[v]) deg[u]++;
}
{
used[v] = 1;
alive--;
for(int u:G[v])
if(0 == dead[u]++) alive -= !used[u];
cnt++;
chmax(res, cnt);
dfs();
used[v] = 0;
alive++;
for(int u:G[v])
if(--dead[u] == 0) alive += !used[u];
cnt--;
}
};
dfs();
return res;
}
};
signed main(){
cin.tie(0);
ios::sync_with_stdio(0);
int n,m;
while(cin>>n>>m,n){
vector< vector<int> > as(n,vector<int>(m));
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
cin>>as[i][j];
IndependentSet G(m);
for(int a=0;a<m;a++){
for(int b=0;b<a;b++){
int ng=0;
for(int i=0;i<n;i++){
for(int j=0;j<i;j++){
if(as[i][a]==as[j][a]) continue;
if(as[i][b]==as[j][b]) continue;
if((as[i][a]>as[j][a])^(as[i][b]>as[j][b])) ng=1;
if(ng) break;
}
if(ng) break;
}
if(ng) G.add_edge(a,b);
}
}
cout<<G.build()<<endl;
}
return 0;
}
|
Set
Given the sequence a_1, a_2, .., a_N.
How many values are there in this sequence?
input
N
a_1 a_2 ... a_N
output
Output the number of types of values in the sequence.
Constraint
* 1 \ leq N \ leq 10 ^ 5
* 1 \ leq a_i \ leq 10 ^ 9
Input example
6
8 6 9 1 2 1
Output example
Five
Example
Input
6
8 6 9 1 2 1
Output
5
|
#include<deque>
#include<queue>
#include<vector>
#include<algorithm>
#include<iostream>
#include<set>
#include<cmath>
#include<tuple>
#include<string>
#include<chrono>
#include<functional>
#include<iterator>
#include<random>
#include<unordered_set>
#include<array>
#include<map>
#include<iomanip>
#include<assert.h>
#include<list>
#include<bitset>
#include<stack>
#include<memory>
#include<numeric>
using namespace std;
using namespace std::chrono;
typedef long long int llint;
typedef long double lldo;
#define mp make_pair
#define mt make_tuple
#define pub push_back
#define puf push_front
#define pob pop_back
#define pof pop_front
#define fir first
#define sec second
#define res resize
#define ins insert
#define era erase
/*cout<<fixed<<setprecision(20);cin.tie(0);ios::sync_with_stdio(false);*/
const int mod=1e9+7;
const llint big=2.19e15+1;
const long double pai=3.141592653589793238462643383279502884197;
const long double eps=1e-4;
template <class T,class U>bool mineq(T& a,U b){if(a>b){a=b;return true;}return false;}
template <class T,class U>bool maxeq(T& a,U b){if(a<b){a=b;return true;}return false;}
llint gcd(llint a,llint b){if(a%b==0){return b;}else return gcd(b,a%b);}
llint lcm(llint a,llint b){if(a==0){return b;}return a/gcd(a,b)*b;}
template<class T> void SO(T& ve){sort(ve.begin(),ve.end());}
template<class T> void REV(T& ve){reverse(ve.begin(),ve.end());}
template<class T>int LBI(const vector<T>&ar,T in){return lower_bound(ar.begin(),ar.end(),in)-ar.begin();}
template<class T>int UBI(const vector<T>&ar,T in){return upper_bound(ar.begin(),ar.end(),in)-ar.begin();}
int main(void){
int n,i;cin>>n;
set<int>a;
while(n--){
int x;cin>>x;a.ins(x);}
cout<<a.size()<<endl;
return 0;
}
|
There is a sequence $A = a_0, a_1, ..., a_{n-1}$. You are given the following information and questions.
* relate$(x, y, z)$: $a_y$ is greater than $a_x$ by $z$
* diff$(x, y)$: report the difference between $a_x$ and $a_y$ $(a_y - a_x)$
Constraints
* $2 \leq n \leq 100,000$
* $1 \leq q \leq 200,000$
* $0 \leq x, y < n$
* $x \ne y$
* $0 \leq z \leq 10000$
* There are no inconsistency in the given information
Input
$n \; q$
$query_1$
$query_2$
:
$query_q$
In the first line, $n$ and $q$ are given. Then, $q$ information/questions are given in the following format.
0 $x \; y\; z$
or
1 $x \; y$
where '0' of the first digit denotes the relate information and '1' denotes the diff question.
Output
For each diff question, print the difference between $a_x$ and $a_y$ $(a_y - a_x)$.
Example
Input
5 6
0 0 2 5
0 1 2 3
1 0 1
1 1 3
0 1 4 8
1 0 4
Output
2
?
10
|
#include <bits/stdc++.h>
using namespace std;
class disjoint_set {
public:
vector<int> rank, prt, ptl;
disjoint_set (int size) {
rank.resize(size);
prt.resize(size);
ptl.resize(size);
for (int i = 0; i < size; i++) {
prt[i] = i;
rank[i] = 0;
ptl[i] = 0;
}
}
int find (int x) {
if (x == prt[x]){
return x;
} else {
int r = find(prt[x]);
ptl[x] += ptl[prt[x]];
return prt[x] = r;
}
}
bool is_equiv (int x, int y) {
return find(x) == find(y);
}
bool unite (int x, int y, int w) {
if (find(x) == find(y)) {
return false;
}
w += ptl[x];
w -= ptl[y];
x = find(x);
y = find(y);
if (rank[x] < rank[y]) {
swap(x, y);
w *= -1;
}
prt[y] = x;
ptl[y] = w;
if (rank[x] == rank[y]) {
rank[x]++;
}
return true;
}
int diff (int x, int y) {
find(x);
find(y);
return ptl[y] - ptl[x];
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
disjoint_set djs(n);
while (q--) {
int c;
cin >> c;
if (c == 0) {
int x, y, z;
cin >> x >> y >> z;
djs.unite(x, y, z);
} else {
int x, y;
cin >> x >> y;
if (!djs.is_equiv(x, y)) {
cout << "?" << '\n';
} else {
cout << djs.diff(x, y) << '\n';
}
}
}
return 0;
}
|
Multiplication of Big Integers II
Given two integers $A$ and $B$, compute the product, $A \times B$.
Input
Two integers $A$ and $B$ separated by a space character are given in a line.
Output
Print the product in a line.
Constraints
* $-1 \times 10^{200000} \leq A, B \leq 10^{200000}$
Sample Input 1
5 8
Sample Output 1
40
Sample Input 2
100 25
Sample Output 2
2500
Sample Input 3
-1 0
Sample Output 3
0
Sample Input 4
12 -3
Sample Output 4
-36
Example
Input
5 8
Output
40
|
#include <bits/stdc++.h>
#define FOR(i,a,b) for (int i=(a);i<(b);i++)
#define FORR(i,a,b) for (int i=(a);i>=(b);i--)
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define pcnt __builtin_popcount
#define tzcnt __builtin_ctzl
#define sz(x) (int)(x).size()
#define maxs(x,y) x=max(x,y)
#define mins(x,y) x=min(x,y)
#define show(x) cout<<#x<<" = "<<x<<endl;
#define all(a) (a.begin()),(a.end())
#define each(it,c) for(__typeof((c).begin()) it=(c).begin();it!=(c).end();it++)
#define perm(c) sort(all(c));for(bool c##p=1;c##p;c##p=next_permutation(all(c)))
#define bit(n) (1LL<<(n))
using namespace std;
typedef long long ll;
typedef __int128_t lll;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
template<typename T>string join(V<T>&v){stringstream s;FOR(i,0,sz(v))s<<' '<<v[i];return s.str().substr(1);}
template<typename A,size_t N,typename T>void Fill(A (&array)[N],const T&v){fill((T*)array,(T*)(array+N),v);}
lll gcd(lll a,lll b,lll &x,lll &y){if(!b){x=1;y=0;return a;}lll d=gcd(b,a%b,y,x);y-=a/b*x;return d;}
ll gcd(ll a,ll b){lll x=0,y=0;return gcd(a,b,x,y);}
ll modPow(lll a,lll n,ll m){if(!a)return a;lll p=1;for(;n>0;n>>=1,a=a*a%m)if(n&1)p=p*a%m;return(ll)p;}
bool isPrime(ll n){if(n<2||n%2==0)return n==2;lll t=n-1,d=t/(t&-t);for(lll a:{2,325,9375,28178,450775,9780504,1795265022})if(a%n){for(t=d,a=modPow(a,t,n);t!=n-1&&a!=1&&a!=n-1;a=a*a%n,t=t*2%n);if(a!=n-1&&t%2==0)return 0;}return 1;}
void dout(double d){printf("%.12f\n",d);}
void YN(bool z){cout<<(z?"YES\n":"NO\n");}
void Yn(bool z){cout<<(z?"Yes\n":"No\n");}
void yn(bool z){cout<<(z?"yes\n":"no\n");}
mt19937 rnd; void set_rnd(){random_device r;rnd=mt19937(r());}
V<ll> fact, rfact; void set_fact(int n, ll m){fact.pb(1);rfact.pb(1);FOR(i,1,n+1)fact.pb(fact[i-1]*i%m),rfact.pb(modPow(fact[i],m,m-2));}
const int iinf = 1e9+6;
const ll linf = 1e18;
const int mod = 1e9+7;
const double pi = acos(-1);
const double eps = 1e-10;
const int N = 1e5;
struct FFT{
const double pi = acos(-1);
vector<complex<double> > x;
int n;
void init(int _n){
n = _n;
x.resize(0);
complex<double> t(1.0, 0.0), w(cos(pi/n), -sin(pi/n));
for(int i=0; i<n; i++) x.push_back(t), t *= w;
}
void dft(vector<complex<double> >& a, bool inv) {
int j = 0;
for (int i = 1; i < n; ++i) {
int k = n >> 1;
while (j >= k) j -= k, k >>= 1;
j += k;
if (i < j) swap(a[i], a[j]);
}
complex<double> t;
for (int k = 1; k < n; k <<= 1) {
for (int i0 = 0; i0 < n; i0 += k << 1) {
for (int i = i0; i < i0 + k; ++i) {
j = i + k;
a[j] *= inv ? conj(x[n / k * (i - i0)]) : x[n / k * (i - i0)];
t = a[i] - a[j];
a[i] = a[i] + a[j];
a[j] = t;
}
}
}
if(inv) for(int i=0; i<n; i++) a[i] /= n;
}
} fft;
string s;
vector<complex<double> > a[2];
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
bool z = false;
FOR(j, 0, 2){
cin >> s;
int i = 0;
if(s[0] == '0'){
cout << 0 << endl;
return 0;
}
if(s[0] == '-') i++, z ^= true;
for(; i<sz(s); i++) a[j].pb(complex<double>(double(s[i]-'0'), 0.0));
reverse(all(a[j]));
}
int n = bit(32-__builtin_clz(sz(a[0])+sz(a[1])));
FOR(i, 0, 2) a[i].resize(n);
fft.init(n);
fft.dft(a[0], false);
fft.dft(a[1], false);
FOR(i, 0, n) a[0][i] *= a[1][i];
fft.dft(a[0], true);
int d = 0;
vector<int> v(n);
FOR(i, 0, n) v[i] = (int)round(a[0][i].real());
FOR(i, 0, n-1){
v[i+1] += v[i]/10;
v[i] %= 10;
}
if(z) printf("-");
z = false;
FORR(i, n-1, 0){
if(v[i] || z)printf("%d", v[i]);
z |= !!v[i];
}
printf("\n");
return 0;
}
|
We are very near to our goal now. The enemy is being weakened continuously. But alas, sensing his fall, the hacker has spread a worm into our network. It is consuming all our files at a tremendous rate and must be stopped at all costs. The only way to stop it is to enter a specific code number in to the worm. It is up to you to find an algorithm for the worm's stop code...Time is of the essence, my friend...
Input:
The first line will consist of the total number of test cases T.
The next T lines will consist of number N on each line.
Output:
For each test case, output is a number.
Example:
Input:
3
34
156
893
Output:
6
0
13
|
#! /usr/bin/python
# imports
import sys
import StringIO
class Problem(object):
def __init__(self, reader):
self.reader = reader
def run(self):
testCaseCount = int(self.reader.readline().strip())
for testCase in range(testCaseCount):
data = int(self.reader.readline().strip())
print (data % self.get_digit_sum(data))
def get_digit_sum(self, number):
sum = 0
while number !=0 :
sum = sum + ( number % 10 )
number = number / 10
return sum
# Main entry point
############################################################
if __name__ == "__main__":
data = sys.stdin
problem = Problem(data)
problem.run();
|
Chef likes to watch movies very much.A movie of his favorite actress has recently released and he wants to go to cinema hall with his friends to watch the movie.
But he will book tickets for him and his friends only if he gets the seats in his desired block size. eg. if he has 9 friends, then he has to book 10 tickets, and wants the seats to be in a rectangular block to 2 X 5. i.e if Chef has to book n number of seats, then the block of seats he would want is p X q where p * q = n
You are given the status of all the seats(booked or not) and you have tell the Chef the number of blocks of exact size, in which all the seats in the block are not booked, and the seat number of the top left corner of the block, so that Chef could chose one of the them.(The seat number of the seats is same as the indices of 2D matrix with base index 0)
.
It might be possible that no such block of empty seats is available
Input
The first line contains the number of test cases ( 1 <= t <= 10).
First line of each test contains n and m( 1 <= n,m <= 1000) which is the size of cinema hall. Cinema hall contains (n X m) no. of seats. The next line contains by p and q separated by a space which tells the block size non-booked seats that Chef wants.
It is followed by n lines where each line contains m characters. A booked seat is denoted by '.' and an available seat is denoted by '#' .
Output
The first line of output of each test case should consist of the number of available blocks of empty seats( e ) i.e the number of blocks of p X q that have no booked seats.
It should be followed by e number of lines where each line contains a and b (0 <= a < n , 0 <= b < m) denoting the top left corner of the block of size p X q having all seats non-booked.
Example
Input:
1
2 6
2 3
.####.
.#####
Output:
2
0 1
0 2
|
import sys
times=input()
while times:
times-=1
a,b=[int(x) for x in sys.stdin.readline().strip().split()]
c,d=[int(x) for x in sys.stdin.readline().strip().split()]
p=a
t=[]
while p:
p=p-1
l=list(sys.stdin.readline().strip())
t+=[l]
i=0
count=0
count2=[]
while i<a-c+1:
j=0
while j<b-d+1:
if(t[i][j]=='#'):
k=i
flag=0
while (k<a)&(k<i+c):
h=j
while (h<b)&(h<j+d):
if(t[k][h]=='#'):
flag+=1
else:
flag=0
break
h+=1
k+=1
if(flag==c*d):
count+=1
count2+=[[i,j]]
j+=1
i+=1
print count
for i in count2:
for j in i:
print j," ",
print
|
Given a number n , find its factorial.
Input
There is a single positive integer T on the first line of input. It stands for the number of numbers to follow. Then there are T lines, each containing exactly one positive integer number N, 1 ≤ N ≤ 10000
Output
For every input number N, output a single line containing the factorial of N.
Example
Input:
3
5
2
7
Output:
120
2
5040
|
import math
t = input();
for i in range(t):
x = input();
print math.factorial(x);
|
Leonid is developing new programming language. The key feature of his language is fast multiplication and raising to a power operations. He is asking you to help with the following task.
You have an expression S and positive integer M. S has the following structure: A1*A2*...*An where "*" is multiplication operation. Each Ai is an expression Xi**Yi where Xi and Yi are non-negative integers and "**" is raising Xi to power Yi operation.
.
Your task is just to find the value of an expression S modulo M
Input
The first line of the input contains an integer T denoting the number of test cases. Each of the following T testcases is described by one line which contains one positive integer M and expression S separated by whitespace.
Output
For each test case, output a single line containing one integer corresponding to value of S modulo M
Constraints
1 ≤ T ≤ 20
1 ≤ M ≤ 10^18
1 ≤ length of S ≤ 10^4
0 ≤ Xi, Yi ≤ 10^9997
It's guaranteed that there will not be 0**0 expression
Example
Input:
2
1000 2**3*3**1
100000 11**2*2**4
Output:
24
1936
|
import math
t = int(input())
for _ in range(t):
M,S = raw_input().split()
M = int(M)
S = S.split('*')
ans = 1
for i in range(0, len(S), 3):
ans = (ans * pow(int(S[i]), int(S[i+2]), M)) % M
print(ans)
|
Some programming contest problems are really tricky: not only do they
require a different output format from what you might have expected, but
also the sample output does not show the difference. For an example,
let us look at permutations.
A permutation of the integers 1 to n is an
ordering of
these integers. So the natural way to represent a permutation is
to list the integers in this order. With n = 5, a
permutation might look like 2, 3, 4, 5, 1.
However, there is another possibility of representing a permutation:
You create a list of numbers where the i-th number is the
position of the integer i in the permutation.
Let us call this second
possibility an inverse permutation. The inverse permutation
for the sequence above is 5, 1, 2, 3, 4.
An ambiguous permutation is a permutation which cannot be
distinguished from its inverse permutation. The permutation 1, 4, 3, 2
for example is ambiguous, because its inverse permutation is the same.
To get rid of such annoying sample test cases, you have to write a
program which detects if a given permutation is ambiguous or not.
Input Specification
The input contains several test cases.
The first line of each test case contains an integer n
(1 ≤ n ≤ 100000).
Then a permutation of the integers 1 to n follows
in the next line. There is exactly one space character
between consecutive integers.
You can assume that every integer between 1 and n
appears exactly once in the permutation.
The last test case is followed by a zero.
Output Specification
For each test case output whether the permutation is ambiguous or not.
Adhere to the format shown in the sample output.
Sample Input
4
1 4 3 2
5
2 3 4 5 1
1
1
0
Sample Output
ambiguous
not ambiguous
ambiguous
|
while True:
n=int(raw_input())
if n==0:
break
else:
A=[]
A = map(int,raw_input().split())
j=1
flag=0
for i in A:
if j!=A[i-1]:
flag=1
break
j+=1
if flag == 0:
print "ambiguous"
else:
print "not ambiguous"
|
For Turbo C++ Users : Read the following document before attempting the question :
For C and C++ users, use long long instead of int. For Java users, use long.
Problem description
Data here, Data There. Data Everywhere.
Which one is mine though?
Main Proconist Dhruv has been given the task of encrypting a classified data file to be sent to Stockholm Convention. The encryption is as follows:
Given a number N, the encryption is a string made up of alphabets (a-z) such that the "sum of the rank of letters" is equal to the number N.
The Rank of a letter is the position of the letter in the alphabet. For eg. Rank("a") = 1 and Rank("t") = 20.
So according to the encryption, the no. 5 can be represented as "aac" or "ad" or "e" etc.
Since the network is slow, Dhruv wants to keep the size of the string as minimum as possible.
And he has asked for your help.
Input
The first line consists of T: the no. of test cases.
Every test case has one positive integer N.
Output
For every test case, output the minimum length of the encrypted string corresponding to the input N.
Constraints
1 ≤ T ≤ 10^5
1 ≤ N ≤ 10^12
Example
Input:
3
50
34
23
Output:
2
2
1
Explanation
Example case 1. 50 can be encrypted as "yy"
Example case 2. 34 can be encrypted as "tn"
Example case 3. 23 can be encrypted as "w"
|
for i in range(input()):
n=input()
if n%26!=0:
r=(n/26)+1
else:
r=n/26
print r
|
Maxim wants to buy some games at the local game shop. There are n games in the shop, the i-th game costs c_i.
Maxim has a wallet which can be represented as an array of integers. His wallet contains m bills, the j-th bill has value a_j.
Games in the shop are ordered from left to right, Maxim tries to buy every game in that order.
When Maxim stands at the position i in the shop, he takes the first bill from his wallet (if his wallet is empty then he proceeds to the next position immediately) and tries to buy the i-th game using this bill. After Maxim tried to buy the n-th game, he leaves the shop.
Maxim buys the i-th game if and only if the value of the first bill (which he takes) from his wallet is greater or equal to the cost of the i-th game. If he successfully buys the i-th game, the first bill from his wallet disappears and the next bill becomes first. Otherwise Maxim leaves the first bill in his wallet (this bill still remains the first one) and proceeds to the next game.
For example, for array c = [2, 4, 5, 2, 4] and array a = [5, 3, 4, 6] the following process takes place: Maxim buys the first game using the first bill (its value is 5), the bill disappears, after that the second bill (with value 3) becomes the first one in Maxim's wallet, then Maxim doesn't buy the second game because c_2 > a_2, the same with the third game, then he buys the fourth game using the bill of value a_2 (the third bill becomes the first one in Maxim's wallet) and buys the fifth game using the bill of value a_3.
Your task is to get the number of games Maxim will buy.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of games and the number of bills in Maxim's wallet.
The second line of the input contains n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ 1000), where c_i is the cost of the i-th game.
The third line of the input contains m integers a_1, a_2, ..., a_m (1 ≤ a_j ≤ 1000), where a_j is the value of the j-th bill from the Maxim's wallet.
Output
Print a single integer — the number of games Maxim will buy.
Examples
Input
5 4
2 4 5 2 4
5 3 4 6
Output
3
Input
5 2
20 40 50 20 40
19 20
Output
0
Input
6 4
4 8 15 16 23 42
1000 1000 1000 1000
Output
4
Note
The first example is described in the problem statement.
In the second example Maxim cannot buy any game because the value of the first bill in his wallet is smaller than the cost of any game in the shop.
In the third example the values of the bills in Maxim's wallet are large enough to buy any game he encounter until he runs out of bills in his wallet.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int shell_length;
long long int wallet_length;
cin >> shell_length >> wallet_length;
std::vector<long long int> vct(shell_length);
for (long long int &i : vct) cin >> i;
std::deque<long long int> wallet;
while (wallet_length--) {
long long int tmp;
cin >> tmp;
wallet.push_back(tmp);
};
long long int out = 0;
for (long long int i : vct) {
if (wallet.front() >= i) {
out++;
wallet.pop_front();
}
if (!wallet.size()) break;
};
std::cout << out;
}
|
You are given a matrix of size n × n filled with lowercase English letters. You can change no more than k letters in this matrix.
Consider all paths from the upper left corner to the lower right corner that move from a cell to its neighboring cell to the right or down. Each path is associated with the string that is formed by all the letters in the cells the path visits. Thus, the length of each string is 2n - 1.
Find the lexicographically smallest string that can be associated with a path after changing letters in at most k cells of the matrix.
A string a is lexicographically smaller than a string b, if the first different letter in a and b is smaller in a.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2000, 0 ≤ k ≤ n^2) — the size of the matrix and the number of letters you can change.
Each of the next n lines contains a string of n lowercase English letters denoting one row of the matrix.
Output
Output the lexicographically smallest string that can be associated with some valid path after changing no more than k letters in the matrix.
Examples
Input
4 2
abcd
bcde
bcad
bcde
Output
aaabcde
Input
5 3
bwwwz
hrhdh
sepsp
sqfaf
ajbvw
Output
aaaepfafw
Input
7 6
ypnxnnp
pnxonpm
nxanpou
xnnpmud
nhtdudu
npmuduh
pmutsnz
Output
aaaaaaadudsnz
Note
In the first sample test case it is possible to change letters 'b' in cells (2, 1) and (3, 1) to 'a', then the minimum path contains cells (1, 1), (2, 1), (3, 1), (4, 1), (4, 2), (4, 3), (4, 4). The first coordinate corresponds to the row and the second coordinate corresponds to the column.
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = 0;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return f ? x : -x;
}
long long n, k, dp[2010][2010], maxn, vis[2010][2010], cnt, siz;
long long dx[] = {1, 0};
long long dy[] = {0, 1};
char ch[2010][2010], ans[5000], minc;
vector<pair<long long, long long> > vec;
queue<pair<long long, long long> > q;
signed main() {
n = read(), k = read();
for (long long i = 1; i <= n; i++) scanf("%s", ch[i] + 1);
memset(dp, 0x3f, sizeof(dp));
dp[1][1] = (ch[1][1] != 'a');
for (long long i = 1; i <= n; i++)
for (long long j = ((i == 1) ? 2 : 1); j <= n; j++)
dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + (ch[i][j] != 'a');
if (!k) {
vec.push_back(make_pair(1, 1));
vis[1][1] = 1;
ans[++cnt] = ch[1][1];
maxn = 2;
goto ling;
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= n; j++) {
if (dp[i][j] <= k) {
vis[i][j] = 1;
if (i + j > maxn) {
maxn = i + j;
vec.clear();
vec.push_back(make_pair(i, j));
} else if (i + j == maxn)
vec.push_back(make_pair(i, j));
}
}
}
ling:;
siz = vec.size();
for (long long i = 0; i < siz; i++) q.push(vec[i]);
vec.clear();
for (long long i = maxn; i < (n << 1); i++) {
minc = 'z';
while (!q.empty()) {
long long x = q.front().first, y = q.front().second;
q.pop();
for (long long dir = 0; dir < 2; dir++) {
long long nx = x + dx[dir], ny = y + dy[dir];
if (nx > n || ny > n || vis[nx][ny]) continue;
if (ch[nx][ny] < minc) {
minc = ch[nx][ny];
vis[nx][ny] = 1;
vec.clear();
vec.push_back(make_pair(nx, ny));
} else if (ch[nx][ny] == minc) {
vis[nx][ny] = 1;
vec.push_back(make_pair(nx, ny));
}
}
}
ans[++cnt] = minc;
siz = vec.size();
for (long long i = 0; i < siz; i++) q.push(vec[i]);
vec.clear();
}
if (k)
for (long long i = 1; i < maxn; i++) putchar('a');
for (long long i = 1; i <= cnt; i++) putchar(ans[i]);
return 0;
}
|
At a break Vanya came to the class and saw an array of n k-bit integers a_1, a_2, …, a_n on the board. An integer x is called a k-bit integer if 0 ≤ x ≤ 2^k - 1.
Of course, Vanya was not able to resist and started changing the numbers written on the board. To ensure that no one will note anything, Vanya allowed himself to make only one type of changes: choose an index of the array i (1 ≤ i ≤ n) and replace the number a_i with the number \overline{a_i}. We define \overline{x} for a k-bit integer x as the k-bit integer such that all its k bits differ from the corresponding bits of x.
Vanya does not like the number 0. Therefore, he likes such segments [l, r] (1 ≤ l ≤ r ≤ n) such that a_l ⊕ a_{l+1} ⊕ … ⊕ a_r ≠ 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR). Determine the maximum number of segments he likes Vanya can get applying zero or more operations described above.
Input
The first line of the input contains two integers n and k (1 ≤ n ≤ 200 000, 1 ≤ k ≤ 30).
The next line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 2^k - 1), separated by spaces — the array of k-bit integers.
Output
Print one integer — the maximum possible number of segments with XOR not equal to 0 that can be obtained by making several (possibly 0) operations described in the statement.
Examples
Input
3 2
1 3 0
Output
5
Input
6 3
1 4 4 7 3 4
Output
19
Note
In the first example if Vasya does not perform any operations, he gets an array that has 5 segments that Vanya likes. If he performs the operation with i = 2, he gets an array [1, 0, 0], because \overline{3} = 0 when k = 2. This array has 3 segments that Vanya likes. Also, to get an array with 5 segments that Vanya likes, he can perform two operations with i = 3 and with i = 2. He then gets an array [1, 0, 3]. It can be proven that he can't obtain 6 or more segments that he likes.
In the second example, to get 19 segments that Vanya likes, he can perform 4 operations with i = 3, i = 4, i = 5, i = 6 and get an array [1, 4, 3, 0, 4, 3].
|
#include <bits/stdc++.h>
using namespace std;
inline char nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
template <typename T = int>
inline T nxt() {
char c = nc();
T x = 0;
int f = 1;
for (; c > '9' || c < '0'; c = nc())
if (c == '-') f = -1;
for (; c >= '0' && c <= '9'; x = x * 10 + c - '0', c = nc())
;
x *= f;
return x;
}
const int maxn = 200123;
long long a[maxn];
unordered_map<long long, long long> cnt;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
long long n = nxt(), k = nxt();
long long m = 1 << k;
m--;
a[0] = 0, cnt[0] = 1;
for (int i = 1; i < (n + 1); ++i) {
long long x = nxt();
a[i] = a[i - 1] ^ x;
}
for (int i = 1; i < (n + 1); ++i) {
long long v = min(a[i], a[i] ^ m);
cnt[v]++;
}
long long ans = n * 1ll * (n - 1) / 2;
ans += n;
for (auto& q : cnt) {
long long w = q.second;
long long v = w / 2;
w -= v;
ans -= v * (v - 1) / 2;
ans -= w * (w - 1) / 2;
}
cout << ans << endl;
}
|
You are given an undirected connected weighted graph consisting of n vertices and m edges. Let's denote the length of the shortest path from vertex 1 to vertex i as d_i.
You have to erase some edges of the graph so that at most k edges remain. Let's call a vertex i good if there still exists a path from 1 to i with length d_i after erasing the edges.
Your goal is to erase the edges in such a way that the number of good vertices is maximized.
Input
The first line contains three integers n, m and k (2 ≤ n ≤ 3 ⋅ 10^5, 1 ≤ m ≤ 3 ⋅ 10^5, n - 1 ≤ m, 0 ≤ k ≤ m) — the number of vertices and edges in the graph, and the maximum number of edges that can be retained in the graph, respectively.
Then m lines follow, each containing three integers x, y, w (1 ≤ x, y ≤ n, x ≠ y, 1 ≤ w ≤ 10^9), denoting an edge connecting vertices x and y and having weight w.
The given graph is connected (any vertex can be reached from any other vertex) and simple (there are no self-loops, and for each unordered pair of vertices there exists at most one edge connecting these vertices).
Output
In the first line print e — the number of edges that should remain in the graph (0 ≤ e ≤ k).
In the second line print e distinct integers from 1 to m — the indices of edges that should remain in the graph. Edges are numbered in the same order they are given in the input. The number of good vertices should be as large as possible.
Examples
Input
3 3 2
1 2 1
3 2 1
1 3 3
Output
2
1 2
Input
4 5 2
4 1 8
2 4 1
2 1 3
3 4 9
3 1 5
Output
2
3 2
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, M = 6e5 + 5;
int n, m, k, x, y, w;
int tot = 1, to[M], v[M], nex[M], head[N];
long long dis[N];
bool vis[N];
struct node {
int dot;
long long dis;
};
struct cmp {
bool operator()(node a, node b) { return a.dis > b.dis; }
};
priority_queue<node, vector<node>, cmp> q;
void add(int x, int y, int w) {
to[++tot] = y;
v[tot] = w;
nex[tot] = head[x];
head[x] = tot;
}
void dij() {
memset(dis, 63, sizeof(dis));
dis[1] = 0;
q.push((node){1, 0});
while (!q.empty()) {
int x = q.top().dot;
q.pop();
if (vis[x]) continue;
vis[x] = 1;
for (int i = head[x]; i; i = nex[i]) {
int y = to[i], w = v[i];
if (dis[y] > dis[x] + w) {
dis[y] = dis[x] + w;
q.push((node){y, dis[y]});
}
}
}
}
void dfs(int x) {
if (k == 0) return;
vis[x] = 1;
for (int i = head[x]; i; i = nex[i]) {
if (k == 0) return;
int y = to[i], w = v[i];
if (vis[y]) continue;
if (dis[y] == dis[x] + w) {
printf("%d ", i / 2);
k--;
dfs(y);
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &w);
add(x, y, w);
add(y, x, w);
}
dij();
if (k < n)
printf("%d\n", k);
else
printf("%d\n", n - 1);
memset(vis, 0, sizeof(vis));
dfs(1);
return 0;
}
|
Makoto has a big blackboard with a positive integer n written on it. He will perform the following action exactly k times:
Suppose the number currently written on the blackboard is v. He will randomly pick one of the divisors of v (possibly 1 and v) and replace v with this divisor. As Makoto uses his famous random number generator (RNG) and as he always uses 58 as his generator seed, each divisor is guaranteed to be chosen with equal probability.
He now wonders what is the expected value of the number written on the blackboard after k steps.
It can be shown that this value can be represented as P/Q where P and Q are coprime integers and Q not≡ 0 \pmod{10^9+7}. Print the value of P ⋅ Q^{-1} modulo 10^9+7.
Input
The only line of the input contains two integers n and k (1 ≤ n ≤ 10^{15}, 1 ≤ k ≤ 10^4).
Output
Print a single integer — the expected value of the number on the blackboard after k steps as P ⋅ Q^{-1} \pmod{10^9+7} for P, Q defined above.
Examples
Input
6 1
Output
3
Input
6 2
Output
875000008
Input
60 5
Output
237178099
Note
In the first example, after one step, the number written on the blackboard is 1, 2, 3 or 6 — each occurring with equal probability. Hence, the answer is (1+2+3+6)/(4)=3.
In the second example, the answer is equal to 1 ⋅ 9/16+2 ⋅ 3/16+3 ⋅ 3/16+6 ⋅ 1/16=15/8.
|
import java.util.*;
import java.io.*;
public class Practice {
BufferedReader br;
PrintWriter out;
StringTokenizer st;
boolean eof;
private static final long MOD = 1000L * 1000L * 1000L + 7;
private static final int[] dx = {0, -1, 0, 1};
private static final int[] dy = {1, 0, -1, 0};
private static final String yes = "Yes";
private static final String no = "No";
void solve() {
int T = 1;
// int T = nextInt();
for (int i = 0; i < T; i++) {
helper();
}
}
List<List<Long>> powers;
List<List<Long>> probs;
long combine;
void helper() {
long n = nextLong();
int k = nextInt();
powers = new ArrayList<>();
probs = new ArrayList<>();
Map<Long, Integer> factors = factor(n);
long[] inv = new long[200];
inv[1] = 1;
for (int i = 2; i < inv.length; i++) {
inv[i] = powMod(i, MOD - 2, MOD);
}
for (Map.Entry<Long, Integer> entry : factors.entrySet()) {
long base = entry.getKey();
int highest = entry.getValue();
long[] init = new long[1 + highest];
init[highest] = 1;
for (int i = 0; i < k; i++) {
long[] nxt = new long[1 + highest];
for (int j = 0; j <= highest; j++) {
// 1 / (j + 1)
for (int p = 0; p <= j; p++) {
long extra = inv[j + 1] * init[j] % MOD;
nxt[p] += extra;
if (nxt[p] >= MOD) {
nxt[p] -= MOD;
}
}
}
init = nxt;
}
List<Long> power = new ArrayList<>();
List<Long> prob = new ArrayList<>();
for (long v : init) {
prob.add(v);
}
long start = 1;
for (int i = 0; i <= highest; i++) {
power.add(start);
start = start * base % MOD;
}
powers.add(power);
probs.add(prob);
}
combine = 0;
rec(0, 1L);
outln(combine % MOD);
}
void rec(int idx, long prev) {
if (idx >= powers.size()) {
combine += prev;
if (combine >= MOD) {
combine -= MOD;
}
return;
}
List<Long> power = powers.get(idx);
List<Long> prob = probs.get(idx);
for (int i = 0; i < power.size(); i++) {
long nxt = prev * power.get(i) % MOD;
nxt = nxt * prob.get(i) % MOD;
rec(idx + 1, nxt);
}
}
// Power Calculate N^M % MOD, N and M can be long (up to 2^64, ~10^18)
public long powMod(long N, long M, long MOD){//N^M % MOD
if(M == 0L)
return 1L;
long[] hp = new long[64];
boolean[] bp = new boolean[64];
hp[0] = N;
for(int i = 1; i < hp.length; i++) {
hp[i] = (hp[i - 1] * hp[i - 1]) % MOD;
}
for(int j = 0; j < hp.length; j++) {
if((M & (1L << j)) != 0)
bp[j] = true;
}
long res = 1;
for(int i = 0;i < bp.length; i++){
if(bp[i]) {
res = (res * hp[i]) % MOD;
}
}
return res;
}
// factorization of a long num
public Map<Long, Integer> factor(long N) {
List<Long> res = new ArrayList<>();
for (long i = 2; i * i <= N; i++) {
while (N % i == 0) {
res.add(i);
N = N / i;
}
}
if (N != 1L) {
res.add(N);
}
Map<Long, Integer> cnt = new HashMap<>();
for (long v : res) {
cnt.put(v, cnt.getOrDefault(v, 0) + 1);
}
return cnt;
}
void shuffle(long[] a) {
int n = a.length;
for(int i = 0; i < n; i++) {
int r = i + (int) (Math.random() * (n - i));
long tmp = a[i];
a[i] = a[r];
a[r] = tmp;
}
}
long gcd(long a, long b) {
while(a != 0 && b != 0) {
long c = b;
b = a % b;
a = c;
}
return a + b;
}
private void outln(Object o) {
out.println(o);
}
private void out(Object o) {
out.print(o);
}
private void formatPrint(double val) {
outln(String.format("%.9f%n", val));
}
public Practice() {
br = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
solve();
out.close();
}
public static void main(String[] args) {
new Practice();
}
public long[] nextLongArr(int n) {
long[] res = new long[n];
for(int i = 0; i < n; i++)
res[i] = nextLong();
return res;
}
public int[] nextIntArr(int n) {
int[] res = new int[n];
for(int i = 0; i < n; i++)
res[i] = nextInt();
return res;
}
public String nextToken() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
eof = true;
return null;
}
}
return st.nextToken();
}
public String nextString() {
try {
return br.readLine();
} catch (IOException e) {
eof = true;
return null;
}
}
public int nextInt() {
return Integer.parseInt(nextToken());
}
public long nextLong() {
return Long.parseLong(nextToken());
}
public double nextDouble() {
return Double.parseDouble(nextToken());
}
}
|
The only difference between easy and hard versions is the constraints.
Polycarp has to write a coursework. The coursework consists of m pages.
Polycarp also has n cups of coffee. The coffee in the i-th cup Polycarp has a_i caffeine in it. Polycarp can drink some cups of coffee (each one no more than once). He can drink cups in any order. Polycarp drinks each cup instantly and completely (i.e. he cannot split any cup into several days).
Surely, courseworks are not being written in a single day (in a perfect world of Berland, at least).
Let's consider some day of Polycarp's work. Consider Polycarp drinks k cups of coffee during this day and caffeine dosages of cups Polycarp drink during this day are a_{i_1}, a_{i_2}, ..., a_{i_k}. Then the first cup he drinks gives him energy to write a_{i_1} pages of coursework, the second cup gives him energy to write max(0, a_{i_2} - 1) pages, the third cup gives him energy to write max(0, a_{i_3} - 2) pages, ..., the k-th cup gives him energy to write max(0, a_{i_k} - k + 1) pages.
If Polycarp doesn't drink coffee during some day, he cannot write coursework at all that day.
Polycarp has to finish his coursework as soon as possible (spend the minimum number of days to do it). Your task is to find out this number of days or say that it is impossible.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 10^9) — the number of cups of coffee and the number of pages in the coursework.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the caffeine dosage of coffee in the i-th cup.
Output
If it is impossible to write the coursework, print -1. Otherwise print the minimum number of days Polycarp needs to do it.
Examples
Input
5 8
2 3 1 1 2
Output
4
Input
7 10
1 3 4 2 1 4 2
Output
2
Input
5 15
5 5 5 5 5
Output
1
Input
5 16
5 5 5 5 5
Output
2
Input
5 26
5 5 5 5 5
Output
-1
Note
In the first example Polycarp can drink fourth cup during first day (and write 1 page), first and second cups during second day (and write 2 + (3 - 1) = 4 pages), fifth cup during the third day (and write 2 pages) and third cup during the fourth day (and write 1 page) so the answer is 4. It is obvious that there is no way to write the coursework in three or less days.
In the second example Polycarp can drink third, fourth and second cups during first day (and write 4 + (2 - 1) + (3 - 2) = 6 pages) and sixth cup during second day (and write 4 pages) so the answer is 2. It is obvious that Polycarp cannot write the whole coursework in one day in this test.
In the third example Polycarp can drink all cups of coffee during first day and write 5 + (5 - 1) + (5 - 2) + (5 - 3) + (5 - 4) = 15 pages of coursework.
In the fourth example Polycarp cannot drink all cups during first day and should drink one of them during the second day. So during first day he will write 5 + (5 - 1) + (5 - 2) + (5 - 3) = 14 pages of coursework and during second day he will write 5 pages of coursework. This is enough to complete it.
In the fifth example Polycarp cannot write the whole coursework at all, even if he will drink one cup of coffee during each day, so the answer is -1.
|
import java.util.*;
public class coffeeeeeeyoy {
static Long[] a;
static int n;
static long k;
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
n=scan.nextInt();
k=scan.nextInt();
a=new Long[n];
long sum=0L;
for(int i=0;i<n;i++) {
a[i]=scan.nextLong();
sum+=a[i];
}
Arrays.sort(a);//jesus christ im dumb
if(k>sum) {
System.out.println(-1);
return;
}
long lo=1, hi=n;
while(hi>=lo) {
long mid=(hi+lo)/2;
if(go(mid)) hi=mid-1;
else lo=mid+1;
}
System.out.println(lo);
}
public static boolean go(long mid) {
// System.out.println("TESTING "+mid);
long res=0L;
int ct=n-1;
coffee:for(long loss=0;;loss++) {
for(long i=0;i<mid;i++) {
res+=Math.max(a[ct]-loss,0);
// System.out.println(a[ct]+" "+loss+" "+res);
if(--ct<0) break coffee;
}
}
return res>=k;
}
}
|
[Thanos sort](https://codegolf.stackexchange.com/questions/182221/implement-the-thanos-sorting-algorithm) is a supervillain sorting algorithm, which works as follows: if the array is not sorted, snap your fingers* to remove the first or the second half of the items, and repeat the process.
Given an input array, what is the size of the longest sorted array you can obtain from it using Thanos sort?
*Infinity Gauntlet required.
Input
The first line of input contains a single number n (1 ≤ n ≤ 16) — the size of the array. n is guaranteed to be a power of 2.
The second line of input contains n space-separated integers a_i (1 ≤ a_i ≤ 100) — the elements of the array.
Output
Return the maximal length of a sorted array you can obtain using Thanos sort. The elements of the array have to be sorted in non-decreasing order.
Examples
Input
4
1 2 2 4
Output
4
Input
8
11 12 1 2 13 14 3 4
Output
2
Input
4
7 6 5 4
Output
1
Note
In the first example the array is already sorted, so no finger snaps are required.
In the second example the array actually has a subarray of 4 sorted elements, but you can not remove elements from different sides of the array in one finger snap. Each time you have to remove either the whole first half or the whole second half, so you'll have to snap your fingers twice to get to a 2-element sorted array.
In the third example the array is sorted in decreasing order, so you can only save one element from the ultimate destruction.
|
n = int(input())
a = list(map(int, input().split(' ')))
ans = 1
length = 2
while length <= n:
for i in range(0, n // length):
b = a[i * length: (i + 1) * length]
ok = True
for j in range(len(b) - 1):
if b[j] > b[j + 1]:
ok = False
break
if ok:
ans = length
break
length *= 2
print(ans)
|
The only difference between easy and hard versions is constraints.
Ivan plays a computer game that contains some microtransactions to make characters look cooler. Since Ivan wants his character to be really cool, he wants to use some of these microtransactions — and he won't start playing until he gets all of them.
Each day (during the morning) Ivan earns exactly one burle.
There are n types of microtransactions in the game. Each microtransaction costs 2 burles usually and 1 burle if it is on sale. Ivan has to order exactly k_i microtransactions of the i-th type (he orders microtransactions during the evening).
Ivan can order any (possibly zero) number of microtransactions of any types during any day (of course, if he has enough money to do it). If the microtransaction he wants to order is on sale then he can buy it for 1 burle and otherwise he can buy it for 2 burles.
There are also m special offers in the game shop. The j-th offer (d_j, t_j) means that microtransactions of the t_j-th type are on sale during the d_j-th day.
Ivan wants to order all microtransactions as soon as possible. Your task is to calculate the minimum day when he can buy all microtransactions he want and actually start playing.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of types of microtransactions and the number of special offers in the game shop.
The second line of the input contains n integers k_1, k_2, ..., k_n (0 ≤ k_i ≤ 2 ⋅ 10^5), where k_i is the number of copies of microtransaction of the i-th type Ivan has to order. It is guaranteed that sum of all k_i is not less than 1 and not greater than 2 ⋅ 10^5.
The next m lines contain special offers. The j-th of these lines contains the j-th special offer. It is given as a pair of integers (d_j, t_j) (1 ≤ d_j ≤ 2 ⋅ 10^5, 1 ≤ t_j ≤ n) and means that microtransactions of the t_j-th type are on sale during the d_j-th day.
Output
Print one integer — the minimum day when Ivan can order all microtransactions he wants and actually start playing.
Examples
Input
5 6
1 2 0 2 0
2 4
3 3
1 5
1 2
1 5
2 3
Output
8
Input
5 3
4 2 1 3 2
3 5
4 2
2 5
Output
20
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * (2e5 + 5);
const int MOD = 998244353;
int n, m;
int sumK = 0;
int k[MAXN];
vector<pair<int, int> > oriSp;
bool canFin(const int day) {
vector<int> ks(k, k + MAXN);
vector<int> sp(MAXN, 0);
for (int i = 0; i < m; ++i) {
const int d = oriSp[i].first;
const int t = oriSp[i].second;
if (d <= day) {
sp[t] = max(d, sp[t]);
}
}
vector<vector<int> > spe(MAXN, vector<int>());
for (int type = 1; type <= n; ++type) {
if (sp[type] != 0) {
spe[sp[type]].push_back(type);
}
}
int burle = 0;
int restK = sumK;
for (int i = 1; i <= day; ++i) {
++burle;
for (int type : spe[i]) {
int sub = min(ks[type], burle);
burle -= sub;
ks[type] -= sub;
restK -= sub;
if (restK <= 0) {
return true;
}
}
}
bool suc;
if (restK * 2 <= burle) {
suc = true;
} else {
suc = false;
}
return suc;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &k[i]);
sumK += k[i];
}
for (int i = 1; i <= m; ++i) {
int d, t;
scanf("%d%d", &d, &t);
oriSp.push_back({d, t});
}
int low = sumK;
int high = sumK * 2;
while (low < high) {
int mid = (low + high) / 2;
if (canFin(mid)) {
high = mid;
} else {
low = mid + 1;
}
}
int ans = low;
printf("%d\n", ans);
}
|
Heidi found out that the Daleks have created a network of bidirectional Time Corridors connecting different destinations (at different times!). She suspects that they are planning another invasion on the entire Space and Time. In order to counter the invasion, she plans to deploy a trap in the Time Vortex, along a carefully chosen Time Corridor. She knows that tinkering with the Time Vortex is dangerous, so she consulted the Doctor on how to proceed. She has learned the following:
* Different Time Corridors require different amounts of energy to keep stable.
* Daleks are unlikely to use all corridors in their invasion. They will pick a set of Corridors that requires the smallest total energy to maintain, yet still makes (time) travel possible between any two destinations (for those in the know: they will use a minimum spanning tree).
* Setting the trap may modify the energy required to keep the Corridor stable.
Heidi decided to carry out a field test and deploy one trap, placing it along the first Corridor. But she needs to know whether the Daleks are going to use this corridor after the deployment of the trap.
She gives you a map of Time Corridors (an undirected graph) with energy requirements for each Corridor.
For a Corridor c, E_{max}(c) is the largest e ≤ 10^9 such that if we changed the required amount of energy of c to e, then the Daleks may still be using c in their invasion (that is, it belongs to some minimum spanning tree). Your task is to calculate E_{max}(c_1) for the Corridor c_1 that Heidi plans to arm with a trap, which is the first edge in the graph.
Input
The first line contains integers n and m (2 ≤ n ≤ 10^5, n - 1 ≤ m ≤ 10^6), number of destinations to be invaded and the number of Time Corridors.
Each of the next m lines describes a Corridor: destinations a, b and energy e (1 ≤ a, b ≤ n, a ≠ b, 0 ≤ e ≤ 10^9).
It's guaranteed, that no pair \\{a, b\} will repeat and that the graph is connected — that is, it is possible to travel between any two destinations using zero or more Time Corridors.
Output
Output a single integer: E_{max}(c_1) for the first Corridor c_1 from the input.
Example
Input
3 3
1 2 8
2 3 3
3 1 4
Output
4
Note
After the trap is set, the new energy requirement for the first Corridor may be either smaller, larger, or equal to the old energy requiremenet.
In the example, if the energy of the first Corridor is set to 4 or less, then the Daleks may use the set of Corridors \{ \{ 1,2 \}, \{ 2,3 \} \} (in particular, if it were set to less than 4, then this would be the only set of Corridors that they would use). However, if it is larger than 4, then they will instead use the set \{ \{2,3\}, \{3,1\} \}.
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int MAXM = 1000005;
int n, m;
int a[MAXM], b[MAXM], w[MAXM];
pair<int, int> p[MAXM];
int par[MAXN];
int nadi(int x) {
if (par[x] == x) return x;
return par[x] = nadi(par[x]);
}
bool spoji(int x, int y) {
x = nadi(x);
y = nadi(y);
if (x == y) return 0;
par[y] = x;
return 1;
}
bool mst(int e, int val) {
for (int i = 1; i <= n; i++) {
par[i] = i;
}
for (int i = 1; i <= m; i++) {
if (i == e) {
p[i] = make_pair(val, -i);
} else {
p[i] = make_pair(w[i], i);
}
}
sort(p + 1, p + 1 + m);
for (int i = 1; i <= m; i++) {
int ind = p[i].second;
if (ind > 0) {
spoji(a[ind], b[ind]);
} else {
return spoji(a[e], b[e]);
}
}
}
int bs(int e) {
int lo = 0, hi = 1000000000;
while (lo < hi) {
int mid = (lo + hi + 1) / 2;
if (mst(e, mid)) {
lo = mid;
} else {
hi = mid - 1;
}
}
return lo;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a[i] >> b[i] >> w[i];
}
cout << bs(1);
return 0;
}
|
You are given an array a consisting of n integers.
Your task is to say the number of such positive integers x such that x divides each number from the array. In other words, you have to find the number of common divisors of all elements in the array.
For example, if the array a will be [2, 4, 6, 2, 10], then 1 and 2 divide each number from the array (so the answer for this test is 2).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 4 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{12}), where a_i is the i-th element of a.
Output
Print one integer — the number of such positive integers x such that x divides each number from the given array (in other words, the answer is the number of common divisors of all elements in the array).
Examples
Input
5
1 2 3 4 5
Output
1
Input
6
6 90 12 18 30 18
Output
4
|
import math
n = int(input())
l=list(map(int,input().split()))
hcf = l[0]
for i in l[1:]:
hcf = math.gcd(hcf,i)
count = 0
for i in range(1, int(math.sqrt(hcf))+1):
if hcf % i == 0 : count += 2
if hcf == 1: print(count - 1)
else:
if int(math.sqrt(hcf)) * int(math.sqrt(hcf)) == hcf :
count -= 1
print(count)
|
Petya loves lucky numbers. Everybody knows that lucky numbers are positive integers whose decimal representation contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya has an array consisting of n numbers. He wants to perform m operations of two types:
* add l r d — add an integer d to all elements whose indexes belong to the interval from l to r, inclusive (1 ≤ l ≤ r ≤ n, 1 ≤ d ≤ 104);
* count l r — find and print on the screen how many lucky numbers there are among elements with indexes that belong to the interval from l to r inclusive (1 ≤ l ≤ r ≤ n). Each lucky number should be counted as many times as it appears in the interval.
Petya has a list of all operations. The operations are such that after all additions the array won't have numbers that would exceed 104. Help Petya write a program that would perform these operations.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of numbers in the array and the number of operations correspondingly. The second line contains n positive integers, none of which exceeds 104 — those are the array numbers. Next m lines contain operations, one per line. They correspond to the description given in the statement.
It is guaranteed that after all operations are fulfilled each number in the array will not exceed 104.
Output
For each operation of the second type print the single number on the single line — the number of lucky numbers in the corresponding interval.
Examples
Input
3 6
2 3 4
count 1 3
count 1 2
add 1 3 2
count 1 3
add 2 3 3
count 1 3
Output
1
0
1
1
Input
4 5
4 4 4 4
count 1 4
add 1 4 3
count 1 4
add 2 3 40
count 1 4
Output
4
4
4
Note
In the first sample after the first addition the array will look in the following manner:
4 5 6
After the second addition:
4 8 9
The second sample after the first addition:
7 7 7 7
After the second addition:
7 47 47 7
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ans;
int a[1000000];
int tree[1000000];
int b[50] = {
0, 4, 7, 44, 47, 74, 77, 444, 447, 474, 477,
744, 747, 774, 777, 4444, 4447, 4474, 4477, 4744, 4747, 4774,
4777, 7444, 7447, 7474, 7477, 7744, 7747, 7774, 7777,
};
int f[1000000];
void pushup(int id) { tree[id] = tree[id * 2] + tree[id * 2 + 1]; }
void Update(int id, int le, int ri, int x, int k) {
if (le == ri) {
tree[id] += k;
return;
}
int mid = (le + ri) / 2;
if (x <= mid)
Update(id * 2, le, mid, x, k);
else
Update(id * 2 + 1, mid + 1, ri, x, k);
pushup(id);
}
int query(int id, int le, int ri, int ll, int rr) {
if (ll <= le && ri <= rr) return tree[id];
int mid = (le + ri) / 2, k = 0;
if (ll <= mid) k += query(id * 2, le, mid, ll, rr);
if (rr > mid) k += query(id * 2 + 1, mid + 1, ri, ll, rr);
return k;
}
int main() {
int i, n, m;
scanf("%d%d", &n, &m);
memset(f, 0, sizeof(f));
for (i = 1; i <= 50; i++) f[b[i]] = 1;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (f[a[i]]) Update(1, 1, n, i, 1);
}
while (m--) {
char ch[100];
scanf("%s", &ch);
int x, y, z;
scanf("%d%d", &x, &y);
if (!strcmp(ch, "add")) {
scanf("%d", &z);
for (int i = x; i <= y; i++) {
int k = 0;
if (f[a[i]]) k--;
a[i] += z;
if (f[a[i]]) k++;
if (k) Update(1, 1, n, i, k);
}
} else
printf("%d\n", query(1, 1, n, x, y));
}
return 0;
}
|
Let n be a positive integer. Let a, b, c be nonnegative integers such that a + b + c = n.
Alice and Bob are gonna play rock-paper-scissors n times. Alice knows the sequences of hands that Bob will play. However, Alice has to play rock a times, paper b times, and scissors c times.
Alice wins if she beats Bob in at least ⌈ n/2 ⌉ (n/2 rounded up to the nearest integer) hands, otherwise Alice loses.
Note that in rock-paper-scissors:
* rock beats scissors;
* paper beats rock;
* scissors beat paper.
The task is, given the sequence of hands that Bob will play, and the numbers a, b, c, determine whether or not Alice can win. And if so, find any possible sequence of hands that Alice can use to win.
If there are multiple answers, print any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
Then, t testcases follow, each consisting of three lines:
* The first line contains a single integer n (1 ≤ n ≤ 100).
* The second line contains three integers, a, b, c (0 ≤ a, b, c ≤ n). It is guaranteed that a + b + c = n.
* The third line contains a string s of length n. s is made up of only 'R', 'P', and 'S'. The i-th character is 'R' if for his i-th Bob plays rock, 'P' if paper, and 'S' if scissors.
Output
For each testcase:
* If Alice cannot win, print "NO" (without the quotes).
* Otherwise, print "YES" (without the quotes). Also, print a string t of length n made up of only 'R', 'P', and 'S' — a sequence of hands that Alice can use to win. t must contain exactly a 'R's, b 'P's, and c 'S's.
* If there are multiple answers, print any of them.
The "YES" / "NO" part of the output is case-insensitive (i.e. "yEs", "no" or "YEs" are all valid answers). Note that 'R', 'P' and 'S' are case-sensitive.
Example
Input
2
3
1 1 1
RPS
3
3 0 0
RPS
Output
YES
PSR
NO
Note
In the first testcase, in the first hand, Alice plays paper and Bob plays rock, so Alice beats Bob. In the second hand, Alice plays scissors and Bob plays paper, so Alice beats Bob. In the third hand, Alice plays rock and Bob plays scissors, so Alice beats Bob. Alice beat Bob 3 times, and 3 ≥ ⌈ 3/2 ⌉ = 2, so Alice wins.
In the second testcase, the only sequence of hands that Alice can play is "RRR". Alice beats Bob only in the last hand, so Alice can't win. 1 < ⌈ 3/2 ⌉ = 2.
|
from math import ceil
t = int(input())
slow = {"S": "R", "R": "P", "P": "S"}
for _ in range(t):
n = int(input())
a, b, c = map(int, input().split())
s = input()
slow2 = {"S": a, "R": b, "P": c}
res = 0
ans = [''] * n
for i in range(n):
if slow2[s[i]] > 0:
res += 1
ans[i] = slow[s[i]]
slow2[s[i]] -= 1
if res >= ceil(n / 2):
for i in range(n):
if ans[i] == '':
if slow2[s[i]] > 0:
ans[i] = slow[s[i]]
slow2[s[i]] -= 1
elif slow2[slow[s[i]]] > 0:
ans[i] = slow[slow[s[i]]]
slow2[slow[s[i]]] -= 1
else:
slow2[slow[slow[s[i]]]] -= 1
ans[i] = slow[slow[slow[s[i]]]]
print("YES")
print(''.join(ans))
else:
print("NO")
|
The well-known Fibonacci sequence F_0, F_1, F_2,… is defined as follows:
* F_0 = 0, F_1 = 1.
* For each i ≥ 2: F_i = F_{i - 1} + F_{i - 2}.
Given an increasing arithmetic sequence of positive integers with n elements: (a, a + d, a + 2⋅ d,…, a + (n - 1)⋅ d).
You need to find another increasing arithmetic sequence of positive integers with n elements (b, b + e, b + 2⋅ e,…, b + (n - 1)⋅ e) such that:
* 0 < b, e < 2^{64},
* for all 0≤ i < n, the decimal representation of a + i ⋅ d appears as substring in the last 18 digits of the decimal representation of F_{b + i ⋅ e} (if this number has less than 18 digits, then we consider all its digits).
Input
The first line contains three positive integers n, a, d (1 ≤ n, a, d, a + (n - 1) ⋅ d < 10^6).
Output
If no such arithmetic sequence exists, print -1.
Otherwise, print two integers b and e, separated by space in a single line (0 < b, e < 2^{64}).
If there are many answers, you can output any of them.
Examples
Input
3 1 1
Output
2 1
Input
5 1 2
Output
19 5
Note
In the first test case, we can choose (b, e) = (2, 1), because F_2 = 1, F_3 = 2, F_4 = 3.
In the second test case, we can choose (b, e) = (19, 5) because:
* F_{19} = 4181 contains 1;
* F_{24} = 46368 contains 3;
* F_{29} = 514229 contains 5;
* F_{34} = 5702887 contains 7;
* F_{39} = 63245986 contains 9.
|
#include <bits/stdc++.h>
using namespace std;
const long long T = 614945049;
const long long MOD = 1000000000;
long long n, a, d;
inline void File() {
freopen(".in", "r", stdin);
freopen(".out", "w", stdout);
}
signed main() {
scanf("%lld %lld %lld", &n, &a, &d);
cout << (T * a % MOD * 15 * (MOD / 10) + 1) << " "
<< (T * d % MOD * 15 * (MOD / 10)) << endl;
return 0;
}
|
This problem is different with hard version only by constraints on total answers length
It is an interactive problem
Venya joined a tour to the madhouse, in which orderlies play with patients the following game. Orderlies pick a string s of length n, consisting only of lowercase English letters. The player can ask two types of queries:
* ? l r – ask to list all substrings of s[l..r]. Substrings will be returned in random order, and in every substring, all characters will be randomly shuffled.
* ! s – guess the string picked by the orderlies. This query can be asked exactly once, after that the game will finish. If the string is guessed correctly, the player wins, otherwise he loses.
The player can ask no more than 3 queries of the first type.
To make it easier for the orderlies, there is an additional limitation: the total number of returned substrings in all queries of the first type must not exceed (n+1)^2.
Venya asked you to write a program, which will guess the string by interacting with the orderlies' program and acting by the game's rules.
Your program should immediately terminate after guessing the string using a query of the second type. In case your program guessed the string incorrectly, or it violated the game rules, it will receive verdict Wrong answer.
Note that in every test case the string is fixed beforehand and will not change during the game, which means that the interactor is not adaptive.
Input
First line contains number n (1 ≤ n ≤ 100) — the length of the picked string.
Interaction
You start the interaction by reading the number n.
To ask a query about a substring from l to r inclusively (1 ≤ l ≤ r ≤ n), you should output
? l r
on a separate line. After this, all substrings of s[l..r] will be returned in random order, each substring exactly once. In every returned substring all characters will be randomly shuffled.
In the case, if you ask an incorrect query, ask more than 3 queries of the first type or there will be more than (n+1)^2 substrings returned in total, you will receive verdict Wrong answer.
To guess the string s, you should output
! s
on a separate line.
After printing each query, do not forget to flush the output. Otherwise, you will get Idleness limit exceeded. To flush the output, you can use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
If you received - (dash) as an answer to any query, you need to terminate your program with exit code 0 (for example, by calling exit(0)). This means that there was an error in the interaction protocol. If you don't terminate with exit code 0, you can receive any unsuccessful verdict.
Hack format
To hack a solution, use the following format:
The first line should contain one integer n (1 ≤ n ≤ 100) — the length of the string, and the following line should contain the string s.
Example
Input
4
a
aa
a
cb
b
c
c
Output
? 1 2
? 3 4
? 4 4
! aabc
|
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long exp(long long a, long long b, long long m) {
if (b == 0) return 1;
if (b == 1) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
long long n;
map<string, long long> m1, m2;
long long cnt[30];
long long cnt2[30];
long long cmp(string a, string b) { return a.size() < b.size(); }
long long cnt3[110][30];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long N;
cin >> N;
if (N == 1) {
cout << "? 1 1"
<< "\n";
cout.flush();
string s;
cin >> s;
cout << "! " << s << "\n";
return 0;
}
long long n = N / 2;
cout << "? " << 1 << " " << n << "\n";
cout.flush();
string s;
for (long long i = 0; i < (n * (n + 1)) / 2; i++) {
cin >> s;
sort(s.begin(), s.end());
m1[s]++;
}
string t = "";
if (n == 1) {
t = s;
} else {
cout << "? " << 1 << " " << n - 1 << "\n";
cout.flush();
for (long long i = 0; i < (n * (n - 1)) / 2; i++) {
cin >> s;
sort(s.begin(), s.end());
m1[s]--;
}
vector<string> v;
for (map<string, long long>::iterator it = m1.begin(); it != m1.end();
it++) {
if (it->second > 0) v.push_back(it->first);
}
sort(v.begin(), v.end(), cmp);
for (long long i = 0; i < v.size(); i++) {
string x = v[i];
for (long long j = 0; j < 26; j++) {
cnt2[j] = 0;
}
for (long long j = 0; j < x.size(); j++) {
cnt2[x[j] - 'a']++;
}
for (long long j = 0; j < 26; j++) {
if (cnt[j] != cnt2[j]) {
t += 'a' + j;
cnt[j]++;
break;
}
}
}
reverse(t.begin(), t.end());
}
while (t.size() < N) t += '?';
cout << "? " << 1 << " " << N << "\n";
cout.flush();
for (long long i = 0; i < N * (N + 1) / 2; i++) {
cin >> s;
sort(s.begin(), s.end());
for (long long j = 0; j < s.size(); j++) {
cnt3[s.size()][s[j] - 'a']++;
}
}
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < 26; j++) {
long long c1 = cnt3[i + 1][j] - cnt3[i][j];
long long c2 = cnt3[i + 2][j] - cnt3[i + 1][j];
long long vez = c1 - c2;
if (vez == 0) continue;
if (vez == 2) {
t[N - 1 - i] = 'a' + j;
} else {
if (t[i] == 'a' + j) {
} else
t[N - 1 - i] = 'a' + j;
}
}
}
memset(cnt, 0, sizeof(cnt));
for (long long i = 0; i < t.size(); i++) {
if (t[i] != '?') cnt[t[i] - 'a']++;
}
for (long long j = 0; j < 26; j++) {
if (cnt3[N][j] != cnt[j]) t[N - 1] = 'a' + j;
}
cout << "! " << t << "\n";
cout.flush();
}
|
This is an interactive problem.
After getting AC after 13 Time Limit Exceeded verdicts on a geometry problem, Kuroni went to an Italian restaurant to celebrate this holy achievement. Unfortunately, the excess sauce disoriented him, and he's now lost!
The United States of America can be modeled as a tree (why though) with n vertices. The tree is rooted at vertex r, wherein lies Kuroni's hotel.
Kuroni has a phone app designed to help him in such emergency cases. To use the app, he has to input two vertices u and v, and it'll return a vertex w, which is the lowest common ancestor of those two vertices.
However, since the phone's battery has been almost drained out from live-streaming Kuroni's celebration party, he could only use the app at most ⌊ n/2 ⌋ times. After that, the phone would die and there will be nothing left to help our dear friend! :(
As the night is cold and dark, Kuroni needs to get back, so that he can reunite with his comfy bed and pillow(s). Can you help him figure out his hotel's location?
Interaction
The interaction starts with reading a single integer n (2 ≤ n ≤ 1000), the number of vertices of the tree.
Then you will read n-1 lines, the i-th of them has two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i), denoting there is an edge connecting vertices x_i and y_i. It is guaranteed that the edges will form a tree.
Then you can make queries of type "? u v" (1 ≤ u, v ≤ n) to find the lowest common ancestor of vertex u and v.
After the query, read the result w as an integer.
In case your query is invalid or you asked more than ⌊ n/2 ⌋ queries, the program will print -1 and will finish interaction. You will receive a Wrong answer verdict. Make sure to exit immediately to avoid getting other verdicts.
When you find out the vertex r, print "! r" and quit after that. This query does not count towards the ⌊ n/2 ⌋ limit.
Note that the tree is fixed beforehand and will not change during the queries, i.e. the interactor is not adaptive.
After printing any query do not forget to print end of line and flush the output. Otherwise, you might 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, use the following format:
The first line should contain two integers n and r (2 ≤ n ≤ 1000, 1 ≤ r ≤ n), denoting the number of vertices and the vertex with Kuroni's hotel.
The i-th of the next n-1 lines should contain two integers x_i and y_i (1 ≤ x_i, y_i ≤ n) — denoting there is an edge connecting vertex x_i and y_i.
The edges presented should form a tree.
Example
Input
6
1 4
4 2
5 3
6 3
2 3
3
4
4
Output
? 5 6
? 3 1
? 1 2
! 4
Note
Note that the example interaction contains extra empty lines so that it's easier to read. The real interaction doesn't contain any empty lines and you shouldn't print any extra empty lines as well.
The image below demonstrates the tree in the sample test:
<image>
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long double EPS = 1e-10;
const long long INF = 1e18;
const long double PI = acos(-1.0L);
vector<int> paths[1005];
int N;
int ret;
void query(int a, int b) {
cout << "? " << a << " " << b << endl;
cin >> ret;
}
vector<int> v;
void dfs(int now, int from) {
v.push_back(now);
for (auto to : paths[now]) {
if (to == from) continue;
dfs(to, now);
}
}
bool CUT(int root, int now, int from, int t) {
if (now == t) return true;
for (auto to : paths[now]) {
if (to == from) continue;
if (CUT(root, to, now, t)) {
if (root == now) {
auto itr = lower_bound(paths[now].begin(), paths[now].end(), to);
paths[now].erase(itr);
}
return true;
}
}
return false;
}
bool END = false;
void solve(int root) {
v.clear();
dfs(root, -1);
if (v.size() == 1) {
cout << "! " << root << endl;
END = true;
return;
}
if (v.size() == 2) {
query(v[0], v[1]);
cout << "! " << ret << endl;
END = true;
return;
}
bool ok = false;
for (int i = 0; i < v.size(); i++) {
if (ok) break;
for (int j = 0; j < i; j++) {
if (ok) break;
auto itr = lower_bound(paths[v[i]].begin(), paths[v[i]].end(), v[j]);
if (itr == paths[v[i]].end() or *itr != v[j]) {
query(v[i], v[j]);
if (ret == v[i]) {
CUT(v[i], v[i], -1, v[j]);
}
if (ret == v[j]) {
CUT(v[j], v[j], -1, v[i]);
}
if (ret != v[i] and ret != v[j]) {
CUT(ret, ret, -1, v[i]);
CUT(ret, ret, -1, v[j]);
}
ok = true;
}
}
}
}
int main() {
cin >> N;
for (int i = 0; i < N - 1; i++) {
int a, b;
cin >> a >> b;
paths[a].push_back(b);
paths[b].push_back(a);
}
for (int i = 1; i <= N; i++) {
sort(paths[i].begin(), paths[i].end());
}
ret = 1;
while (true) {
solve(ret);
if (END) break;
}
return 0;
}
|
INTERCAL is the oldest of esoteric programming languages. One of its many weird features is the method of character-based output, known as Turing Tape method. It converts an array of unsigned 8-bit integers into a sequence of characters to print, using the following method.
The integers of the array are processed one by one, starting from the first. Processing i-th element of the array is done in three steps:
1. The 8-bit binary notation of the ASCII-code of the previous printed character is reversed. When the first element of the array is processed, the result of this step is considered to be 0.
2. The i-th element of the array is subtracted from the result of the previous step modulo 256.
3. The binary notation of the result of the previous step is reversed again to produce ASCII-code of the i-th character to be printed.
You are given the text printed using this method. Restore the array used to produce this text.
Input
The input will consist of a single line text which contains the message printed using the described method. String text will contain between 1 and 100 characters, inclusive. ASCII-code of each character of text will be between 32 (space) and 126 (tilde), inclusive.
Output
Output the initial array, which was used to produce text, one integer per line.
Examples
Input
Hello, World!
Output
238
108
112
0
64
194
48
26
244
168
24
16
162
Note
Let's have a closer look at the beginning of the example. The first character is "H" with ASCII-code 72 = 010010002. Its reverse is 000100102 = 18, and this number should become the result of the second step of processing. The result of the first step is considered to be 0, so the first element of the array has to be (0 - 18) mod 256 = 238, where a mod b is the remainder of division of a by b.
|
#include <bits/stdc++.h>
char s[100010];
int calc(int x) {
int a[10];
for (int i = 0; i < 8; i++) {
a[i] = x & 1;
x >>= 1;
}
int ret = 0;
for (int i = 0; i < 8; i++) ret = ret << 1 | a[i];
return (ret);
}
int getmod(int x) {
x %= 256;
if (x < 0) x += 256;
return (x);
}
int main() {
gets(s);
int n = strlen(s), now = 0;
for (int i = 0; i < n; i++) {
int p = calc(int(s[i])), x = getmod(now - p);
printf("%d\n", x);
now = p;
}
return (0);
}
|
Note that the only differences between easy and hard versions are the constraints on n and the time limit. You can make hacks only if all versions are solved.
Slime is interested in sequences. He defined good positive integer sequences p of length n as follows:
* For each k>1 that presents in p, there should be at least one pair of indices i,j, such that 1 ≤ i < j ≤ n, p_i = k - 1 and p_j = k.
For the given integer n, the set of all good sequences of length n is s_n. For the fixed integer k and the sequence p, let f_p(k) be the number of times that k appears in p. For each k from 1 to n, Slime wants to know the following value:
$$$\left(∑_{p∈ s_n} f_p(k)\right)\ mod\ 998 244 353$$$
Input
The first line contains one integer n\ (1≤ n≤ 5000).
Output
Print n integers, the i-th of them should be equal to \left(∑_{p∈ s_n} f_p(i)\right)\ mod\ 998 244 353.
Examples
Input
2
Output
3 1
Input
3
Output
10 7 1
Input
1
Output
1
Note
In the first example, s=\{[1,1],[1,2]\}.
In the second example, s=\{[1,1,1],[1,1,2],[1,2,1],[1,2,2],[2,1,2],[1,2,3]\}.
In the third example, s=\{[1]\}.
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int N = 5e3 + 10;
const long long mod2 = 1e9 + 7;
const long long mod = 998244353;
const long long inf = 8e18;
const int LOG = 22;
long long pw(long long a, long long b, long long M) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % M, b / 2, M)) % M
: pw(a * a % M, b / 2, M)));
}
long long dp[N][N], Ans[N], first[N], I[N];
long long E(long long r, long long n) {
if (r > n || r < 0) return 0ll;
return (first[n] * I[r] % mod) * I[n - r] % mod;
}
int main() {
first[0] = 1;
for (int i = 1; i < N; i++) first[i] = (i * first[i - 1]) % mod;
I[N - 1] = pw(first[N - 1], mod - 2, mod);
for (int i = N - 2; ~i; i--) I[i] = I[i + 1] * (i + 1) % mod;
int n;
scanf("%d", &n);
dp[1][1] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j] =
((dp[i - 1][j] * j % mod) + (dp[i - 1][j - 1] * (i - j + 1) % mod)) %
mod;
}
}
for (int i = 1; i <= n; i++) {
Ans[i] = 0;
for (int j = 1; j <= n; j++) {
Ans[i] = (Ans[i] + (first[n] * I[j] % mod) * dp[j][i]) % mod;
}
}
for (int i = 1; i <= n; i++) {
printf("%lld ", Ans[i]);
}
return 0;
}
|
Little Petya very much likes rectangles and especially squares. Recently he has received 8 points on the plane as a gift from his mother. The points are pairwise distinct. Petya decided to split them into two sets each containing 4 points so that the points from the first set lay at the vertexes of some square and the points from the second set lay at the vertexes of a rectangle. Each point of initial 8 should belong to exactly one set. It is acceptable for a rectangle from the second set was also a square. If there are several partitions, Petya will be satisfied by any of them. Help him find such partition. Note that the rectangle and the square from the partition should have non-zero areas. The sides of the figures do not have to be parallel to the coordinate axes, though it might be the case.
Input
You are given 8 pairs of integers, a pair per line — the coordinates of the points Petya has. The absolute value of all coordinates does not exceed 104. It is guaranteed that no two points coincide.
Output
Print in the first output line "YES" (without the quotes), if the desired partition exists. In the second line output 4 space-separated numbers — point indexes from the input, which lie at the vertexes of the square. The points are numbered starting from 1. The numbers can be printed in any order. In the third line print the indexes of points lying at the vertexes of a rectangle in the similar format. All printed numbers should be pairwise distinct.
If the required partition does not exist, the first line should contain the word "NO" (without the quotes), after which no output is needed.
Examples
Input
0 0
10 11
10 0
0 11
1 1
2 2
2 1
1 2
Output
YES
5 6 7 8
1 2 3 4
Input
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
Output
NO
Input
0 0
4 4
4 0
0 4
1 2
2 3
3 2
2 1
Output
YES
1 2 3 4
5 6 7 8
Note
Pay attention to the third example: the figures do not necessarily have to be parallel to the coordinate axes.
|
#include <bits/stdc++.h>
using namespace std;
struct pnt {
int x, y;
} p[10];
int h[10];
int s1[10];
int s2[10];
bool fnd;
int dist2(pnt a, pnt b) {
return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
bool squ(pnt a, pnt b, pnt c, pnt d) {
int dab = dist2(a, b);
int dbc = dist2(b, c);
if (dbc != dab) return false;
int dcd = dist2(c, d);
if (dcd != dab) return false;
int dda = dist2(d, a);
if (dda != dab) return false;
int dac = dist2(a, c);
if (dac != dab * 2) return false;
int dbd = dist2(b, d);
if (dbd != dab * 2) return false;
return true;
}
bool square() {
pnt a = p[s1[0]];
pnt b = p[s1[1]];
pnt c = p[s1[2]];
pnt d = p[s1[3]];
if (squ(a, b, c, d)) return true;
if (squ(a, b, d, c)) return true;
if (squ(a, c, b, d)) return true;
if (squ(a, c, d, b)) return true;
if (squ(a, d, b, c)) return true;
if (squ(a, d, c, b)) return true;
return false;
}
bool rec(pnt a, pnt b, pnt c, pnt d) {
int dab = dist2(a, b);
int dbc = dist2(b, c);
int dcd = dist2(c, d);
if (dcd != dab) return false;
int dda = dist2(d, a);
if (dda != dbc) return false;
int dac = dist2(a, c);
int dbd = dist2(b, d);
if (dac != dbd) return false;
return true;
}
bool rect() {
pnt a = p[s2[0]];
pnt b = p[s2[1]];
pnt c = p[s2[2]];
pnt d = p[s2[3]];
if (rec(a, b, c, d)) return true;
if (rec(a, b, d, c)) return true;
if (rec(a, c, b, d)) return true;
if (rec(a, c, d, b)) return true;
if (rec(a, d, b, c)) return true;
if (rec(a, d, c, b)) return true;
return false;
}
void dfs(int x, int y, int z) {
if (fnd) return;
if (x == 8) {
if (square() && rect()) {
printf("YES\n");
int i, j;
j = 0;
for (i = 0; i < 8; i++) {
if (h[i] == 0) {
if (j) printf(" ");
printf("%d", i + 1);
j++;
}
}
printf("\n");
j = 0;
for (i = 0; i < 8; i++) {
if (h[i] == 1) {
if (j) printf(" ");
printf("%d", i + 1);
j++;
}
}
printf("\n");
fnd = true;
}
return;
}
if (y < 4) {
h[x] = 0;
s1[y] = x;
dfs(x + 1, y + 1, z);
}
if (z < 4) {
h[x] = 1;
s2[z] = x;
dfs(x + 1, y, z + 1);
}
}
int main() {
int i;
for (i = 0; i < 8; i++) scanf("%d%d", &p[i].x, &p[i].y);
fnd = false;
dfs(0, 0, 0);
if (!fnd) printf("NO\n");
return 0;
}
|
Omkar is playing his favorite pixelated video game, Bed Wars! In Bed Wars, there are n players arranged in a circle, so that for all j such that 2 ≤ j ≤ n, player j - 1 is to the left of the player j, and player j is to the right of player j - 1. Additionally, player n is to the left of player 1, and player 1 is to the right of player n.
Currently, each player is attacking either the player to their left or the player to their right. This means that each player is currently being attacked by either 0, 1, or 2 other players. A key element of Bed Wars strategy is that if a player is being attacked by exactly 1 other player, then they should logically attack that player in response. If instead a player is being attacked by 0 or 2 other players, then Bed Wars strategy says that the player can logically attack either of the adjacent players.
Unfortunately, it might be that some players in this game are not following Bed Wars strategy correctly. Omkar is aware of whom each player is currently attacking, and he can talk to any amount of the n players in the game to make them instead attack another player — i. e. if they are currently attacking the player to their left, Omkar can convince them to instead attack the player to their right; if they are currently attacking the player to their right, Omkar can convince them to instead attack the player to their left.
Omkar would like all players to be acting logically. Calculate the minimum amount of players that Omkar needs to talk to so that after all players he talked to (if any) have changed which player they are attacking, all players are acting logically according to Bed Wars strategy.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4). The descriptions of the test cases follows.
The first line of each test case contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the amount of players (and therefore beds) in this game of Bed Wars.
The second line of each test case contains a string s of length n. The j-th character of s is equal to L if the j-th player is attacking the player to their left, and R if the j-th player is attacking the player to their right.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output one integer: the minimum number of players Omkar needs to talk to to make it so that all players are acting logically according to Bed Wars strategy.
It can be proven that it is always possible for Omkar to achieve this under the given constraints.
Example
Input
5
4
RLRL
6
LRRRRL
8
RLLRRRLL
12
LLLLRRLRRRLL
5
RRRRR
Output
0
1
1
3
2
Note
In the first test case, players 1 and 2 are attacking each other, and players 3 and 4 are attacking each other. Each player is being attacked by exactly 1 other player, and each player is attacking the player that is attacking them, so all players are already being logical according to Bed Wars strategy and Omkar does not need to talk to any of them, making the answer 0.
In the second test case, not every player acts logically: for example, player 3 is attacked only by player 2, but doesn't attack him in response. Omkar can talk to player 3 to convert the attack arrangement to LRLRRL, in which you can see that all players are being logical according to Bed Wars strategy, making the answer 1.
|
import java.io.*;
import java.util.*;
public class Rating{
public static Scanner in=new Scanner(System.in);
public static void rotate(StringBuffer s) {
char tmp=s.charAt(0);
s.delete(0, 1);
s.append(tmp);
}
public static void main(String args[]) {
int T_T=in.nextInt();
String s[]= {"RL","RRL","RLL","RRLL"};
while(T_T-->0) {
int n=in.nextInt();
int mn=Integer.MAX_VALUE;
StringBuffer tmp=new StringBuffer(in.next());
for(int i=0;i<4;++i) {
rotate(tmp);
int dp[]=new int[n+3];
Arrays.fill(dp,(int)(1e9));dp[0]=0;
for(int j=0;j<n;++j) {
for(int k=0;k<4;++k) {
int len=s[k].length();
if(j+len>n)continue;
int cnt=0;
for(int t=0;t<len;++t)if(tmp.charAt(j+t)!=s[k].charAt(t))++cnt;
dp[j+len]=Math.min(dp[j]+cnt,dp[j+len]);
}
}
mn=Math.min(mn,dp[n]);
}System.out.println(mn);
}
}
}
|
Another dull quarantine day was going by when BThero decided to start researching matrices of size n × m. The rows are numerated 1 through n from top to bottom, and the columns are numerated 1 through m from left to right. The cell in the i-th row and j-th column is denoted as (i, j).
For each cell (i, j) BThero had two values:
1. The cost of the cell, which is a single positive integer.
2. The direction of the cell, which is one of characters L, R, D, U. Those characters correspond to transitions to adjacent cells (i, j - 1), (i, j + 1), (i + 1, j) or (i - 1, j), respectively. No transition pointed outside of the matrix.
Let us call a cell (i_2, j_2) reachable from (i_1, j_1), if, starting from (i_1, j_1) and repeatedly moving to the adjacent cell according to our current direction, we will, sooner or later, visit (i_2, j_2).
BThero decided to create another matrix from the existing two. For a cell (i, j), let us denote S_{i, j} as a set of all reachable cells from it (including (i, j) itself). Then, the value at the cell (i, j) in the new matrix will be equal to the sum of costs of all cells in S_{i, j}.
After quickly computing the new matrix, BThero immediately sent it to his friends. However, he did not save any of the initial matrices! Help him to restore any two valid matrices, which produce the current one.
Input
The first line of input file contains a single integer T (1 ≤ T ≤ 100) denoting the number of test cases. The description of T test cases follows.
First line of a test case contains two integers n and m (1 ≤ n ⋅ m ≤ 10^5).
Each of the following n lines contain exactly m integers — the elements of the produced matrix. Each element belongs to the segment [2, 10^9].
It is guaranteed that ∑{(n ⋅ m)} over all test cases does not exceed 10^5.
Output
For each test case, if an answer does not exist, print a single word NO. Otherwise, print YES and both matrices in the same format as in the input.
* The first matrix should be the cost matrix and the second matrix should be the direction matrix.
* All integers in the cost matrix should be positive.
* All characters in the direction matrix should be valid. No direction should point outside of the matrix.
Example
Input
2
3 4
7 6 7 8
5 5 4 4
5 7 4 4
1 1
5
Output
YES
1 1 1 1
2 1 1 1
3 2 1 1
R D L L
D R D L
U L R U
NO
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class C>
void mini(C &a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C &a4, C b4) {
a4 = max(a4, b4);
}
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
long long dx[] = {0, 0, 1, -1};
long long dy[] = {-1, 1, 0, 0};
string kier = "LRDU";
struct Sol {
vector<vector<long long>> t;
vector<vector<long long>> typ;
vector<long long> vis;
vector<vector<long long>> d;
vector<long long> s;
vector<vector<long long>> res;
vector<string> resk;
long long get(long long a, long long b) { return a * m + b; }
void add_edge(long long a, long long b) {
d[a].push_back(b);
d[b].push_back(a);
}
bool dfs(long long v) {
if (vis[v]) return 0;
vis[v] = 1;
for (long long el : d[v]) {
if (s[el] == -1 || dfs(s[el])) {
s[v] = el;
s[el] = v;
return 1;
}
}
return 0;
}
void sko() {
bool x = 1;
while (x) {
x = 0;
for (long long i = (0); i <= ((long long)(n * m) - 1); i++) vis[i] = 0;
for (long long i = (0); i <= ((long long)(n)-1); i++)
for (long long j = (0); j <= ((long long)(m)-1); j++)
if (typ[i][j] == 2) {
long long id = get(i, j);
if (s[id] == -1 && dfs(id)) {
x = 1;
}
}
}
}
long long n, m;
void run() {
cin >> n >> m;
t.resize(n, vector<long long>(m));
typ.resize(n, vector<long long>(m));
res.resize(n, vector<long long>(m));
resk.resize(n, string(m, '?'));
d.resize(n * m);
s.resize(n * m, -1);
vis.resize(n * m);
for (long long i = (0); i <= ((long long)(n)-1); i++)
for (long long j = (0); j <= ((long long)(m)-1); j++) {
cin >> t[i][j];
}
for (long long i = (0); i <= ((long long)(n)-1); i++)
for (long long j = (0); j <= ((long long)(m)-1); j++)
for (long long k = (0); k <= ((long long)(4) - 1); k++) {
long long ni = i + dx[k];
long long nj = j + dy[k];
if (ni >= 0 && ni < n && nj >= 0 && nj < m) {
(i, j, ni, nj);
if (t[i][j] > t[ni][nj]) {
typ[i][j] |= 1;
} else if (t[i][j] == t[ni][nj]) {
typ[i][j] |= 2;
}
}
}
(typ);
for (long long i = (0); i <= ((long long)(n)-1); i++)
for (long long j = (0); j <= ((long long)(m)-1); j++) {
if (typ[i][j] == 0) {
cout << "NO\n";
return;
}
}
for (long long i = (0); i <= ((long long)(n - 1) - 1); i++)
for (long long j = (0); j <= ((long long)(m)-1); j++) {
if (typ[i][j] == 2 && typ[i + 1][j] == 2 && t[i][j] == t[i + 1][j]) {
add_edge(get(i, j), get(i + 1, j));
}
}
for (long long i = (0); i <= ((long long)(n)-1); i++)
for (long long j = (0); j <= ((long long)(m - 1) - 1); j++) {
if (typ[i][j] == 2 && typ[i][j + 1] == 2 && t[i][j] == t[i][j + 1]) {
add_edge(get(i, j), get(i, j + 1));
}
}
sko();
for (long long i = (0); i <= ((long long)(n - 1) - 1); i++)
for (long long j = (0); j <= ((long long)(m)-1); j++) {
if (typ[i][j] + typ[i + 1][j] == 5 && t[i][j] == t[i + 1][j]) {
add_edge(get(i, j), get(i + 1, j));
}
}
for (long long i = (0); i <= ((long long)(n)-1); i++)
for (long long j = (0); j <= ((long long)(m - 1) - 1); j++) {
if (typ[i][j] + typ[i][j + 1] == 5 && t[i][j] == t[i][j + 1]) {
add_edge(get(i, j), get(i, j + 1));
}
}
sko();
for (long long i = (0); i <= ((long long)(n)-1); i++)
for (long long j = (0); j <= ((long long)(m)-1); j++) {
if (typ[i][j] == 2 && s[get(i, j)] == -1) {
cout << "NO\n";
return;
}
}
for (long long i = (0); i <= ((long long)(n)-1); i++)
for (long long j = (0); j <= ((long long)(m)-1); j++) {
if (s[get(i, j)] == -1) {
for (long long k = (0); k <= ((long long)(4) - 1); k++) {
long long ni = i + dx[k];
long long nj = j + dy[k];
if (ni >= 0 && ni < n && nj >= 0 && nj < m) {
if (t[i][j] > t[ni][nj]) {
res[i][j] = t[i][j] - t[ni][nj];
resk[i][j] = kier[k];
break;
}
}
}
} else {
for (long long k = (0); k <= ((long long)(4) - 1); k++) {
long long ni = i + dx[k];
long long nj = j + dy[k];
if (ni >= 0 && ni < n && nj >= 0 && nj < m) {
if (s[get(i, j)] == get(ni, nj)) {
res[i][j] = t[i][j] / 2;
res[ni][nj] = (t[i][j] + 1) / 2;
resk[i][j] = kier[k];
break;
}
}
}
}
}
cout << "YES\n";
for (long long i = (0); i <= ((long long)(n)-1); i++) {
for (long long j = (0); j <= ((long long)(m)-1); j++)
cout << res[i][j] << " ";
cout << "\n";
}
for (long long i = (0); i <= ((long long)(n)-1); i++) {
for (long long j = (0); j <= ((long long)(m)-1); j++)
cout << resk[i][j] << " ";
cout << "\n";
}
}
};
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(11);
if (0) cout << fixed << setprecision(6);
long long t;
cin >> t;
while (t--) {
Sol sol;
sol.run();
}
}
|
One day, n people (n is an even number) met on a plaza and made two round dances, each round dance consists of exactly n/2 people. Your task is to find the number of ways n people can make two round dances if each round dance consists of exactly n/2 people. Each person should belong to exactly one of these two round dances.
Round dance is a dance circle consisting of 1 or more people. Two round dances are indistinguishable (equal) if one can be transformed to another by choosing the first participant. For example, round dances [1, 3, 4, 2], [4, 2, 1, 3] and [2, 1, 3, 4] are indistinguishable.
For example, if n=2 then the number of ways is 1: one round dance consists of the first person and the second one of the second person.
For example, if n=4 then the number of ways is 3. Possible options:
* one round dance — [1,2], another — [3,4];
* one round dance — [2,4], another — [3,1];
* one round dance — [4,1], another — [3,2].
Your task is to find the number of ways n people can make two round dances if each round dance consists of exactly n/2 people.
Input
The input contains one integer n (2 ≤ n ≤ 20), n is an even number.
Output
Print one integer — the number of ways to make two round dances. It is guaranteed that the answer fits in the 64-bit integer data type.
Examples
Input
2
Output
1
Input
4
Output
3
Input
8
Output
1260
Input
20
Output
12164510040883200
|
import java.io.*;
import java.util.*;
public class Dance
{
public static void main(String[]args)
{
Scanner sc = new Scanner(System.in);
long n ;
n = sc.nextLong();
System.out.println(fact(n)/((int)Math.pow(n/2,2)*2));
}
public static long fact(long n)
{
long f=1;
for(int i=1;i<=n;i++)
{
f = f*i ;
}
return f;
}
}
|
You are given a string s of 0's and 1's. You are allowed to perform the following operation:
* choose a non-empty contiguous substring of s that contains an equal number of 0's and 1's;
* flip all characters in the substring, that is, replace all 0's with 1's, and vice versa;
* reverse the substring.
For example, consider s = 00111011, and the following operation:
* Choose the first six characters as the substring to act upon: 00111011. Note that the number of 0's and 1's are equal, so this is a legal choice. Choosing substrings 0, 110, or the entire string would not be possible.
* Flip all characters in the substring: 11000111.
* Reverse the substring: 10001111.
Find the lexicographically smallest string that can be obtained from s after zero or more operations.
Input
The first line contains a single integer T (1 ≤ T ≤ 5 ⋅ 10^5) — the number of test cases. Each of the following T lines contains a single non-empty string — the input string s for the respective test case.
All strings consist of characters 0 and 1, and their total length does not exceed 5 ⋅ 10^5.
Output
For each test case, on a separate line print the lexicographically smallest string that can be obtained from s after zero or more operations.
Example
Input
3
100101
1100011
10101010
Output
010110
0110110
10101010
Note
In the first test case a single operation should be applied to the entire string.
In the second test case two operations are needed: 0111001, 0110110.
In the third test case the string stays the same after any operation.
|
/**
*
* 这就是 Legendary Grandmaster 级别的贪心题🐎？
*
* 解释题意：每次选择一段连续的字串，进行如下的变换
* - 子串满足 1 的数量和 0 的数量相等
* - 将子串的每一位都取反
* - 将子串的顺序翻转为倒序
* 现在要求求出这个 01 串可以变换达到的字典序最小的串
*
* 贪心做法：
*
* 发现：如果子串是 10 型或者 01 型，这种变换将毫无意义
* 启发：将所有的 0 替换为 -1，统计前缀和，并以此建图：
* - 对于每一个前缀和的值建立节点
* - 这个节点只会连接到 -1（0）和 +1（1）的节点
* - 得到的图一定包含一条完整的欧拉路（环），从 0 出发
* 对于操作，每次操作都是先翻转再倒转：
* + 限制条件相当于限定了这段区间的路径是一个欧拉环
* + 翻转相当于将这条欧拉路的一段节点的走向取反
* + 倒转相当于修改这段区间的前驱后继情况
* + 总的来看，相当于使得这个欧拉环反向进行
* 最小的欧拉环是基于两个节点的双向边，一定是先走反向边更优
* 因此可以建图后贪心，尽可能向更小的节点走，并记录走向
* 这样得到的记录（走向）组成的串一定是字典序最小的
*
* 折线做法（没有看懂）：
* REFERENCE: https://www.cnblogs.com/2005lz/p/14161455.html
*
* 对于 01 串，有一种处理方法是将 0 处理为 -1，1 处理为 +1
* - 首先，把这样替换的前缀和画成折线图
* - 那么，一次操作就等价于将一段折线“左右翻转”
* （没有看懂）
*
* 这竟然是 3100 题🐎，真狠啊（
* 不愧是优秀的 字节Camp ==
*
* WA4: 没有处理回不来的情况，这种时候就只能后走了
*/
#include <bits/stdc++.h>
using namespace std;
using longs = long long;
using uint = unsigned;
using ulongs = unsigned long long;
using longd = long double;
using lll = __int128;
#define minimize(a, b...) ((a) = min({(a), b}))
#define maximize(a, b...) ((a) = max({(a), b}))
#define sgn(x) ((x) < 0 ? -1 : (x) > 0)
#define puti(n) puts(to_string(n).c_str())
#if 1
#define eprintf(x...) fprintf(stderr, x)
#define eputs(str) fputs(str, stderr), fputc('\n', stderr)
#define var(x) ""#x" = " << x
#define watch(...) trace(#__VA_ARGS__, __VA_ARGS__)
#else
#define eprintf(...)
#define eputs(...)
#define watch(...)
#endif
template <class printable>
void trace(const char *name, printable &&value)
{cerr << name << " = " << value << endl;}
template <class printable, class ...args>
void trace(const char *names, printable &&value, args &&...list)
{
const char *separate = strchr(names + 1, ',');
cerr.write(names, separate - names) << " = " << value << ',';
trace(separate + 1, list...);
}
template <class T>
void print(T x)
{
if (x < 0) { putchar('-'); x = -x; }
static char str[40]; int cnt = 0;
while (x > 9) { str[cnt ++] = (x % 10) + 48; x /= 10;}
str[cnt ++] = x + 48;
while (cnt --) putchar(str[cnt]);
}
void print(string &s) {printf(s.c_str());}
void print(const char *s) {printf(s);}
void print(char *s) {printf(s);}
void print(char ch) {putchar(ch);}
template <class T, class ...Ts>
void print(T x, Ts ...xs) {print(x), print(xs...);}
void println() {puts("");}
template <class T>
void println(T x)
{print(x), putchar('\n');}
static class Scanner
{
template<class T>
inline T read()
{
T x = 0; int f = 0, ch = getchar();
while (!isdigit(ch)) ch == '-' && (f = !f), ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - 48, ch = getchar();
return f ? -x : x;
}
static inline bool isBlank(int x)
{return x == ' ' || x == '\n';}
public:
template <class T>
void operator()(T &x){x = read<T>();}
template <class T, class... Ts>
void operator()(T &x, Ts &... y)
{(*this)(x), (*this)(y...);}
template <class T, class... Ts>
void operator()(T &&x, Ts &&... y)
{(*this)(x), (*this)(y...);}
void operator()(char *x){scanf("%s", x);}
void operator()(char &x){do x = (char)getchar(); while (isBlank(x));}
int nextInt() {return read<int>();}
longs nextLongs() {return read<longs>();}
lll nextInt128() {return read<lll>();}
char nextChar() {char x; (*this)(x); return x;}
} scanner;
const int N = 5e5 + 5;
char s[N];
bitset<N> ans;
signed main()
{
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
#if 0
freopen("in.txt", "r", stdin);
#endif
int T = scanner.nextInt();
unordered_map<int, pair<int, int>> graph;
while (T --)
{
scanner(s + 1), graph.clear();
const int n = strlen(s + 1);
for (int i = 1, now = 0; i <= n; ++ i)
if (s[i] - '0') ++ graph[now ++].second;
else ++ graph[now --].first;
for (int now = 0, i = 1; i <= n; ++ i)
if (!graph[now].first || !graph[now - 1].second) // 大环化小环
{
if (graph[now].second)
ans[i] = true, --graph[now++].second;
else ans[i] = false, --graph[now--].first;
} else ans[i] = false, --graph[now--].first;
for (int i = 1; i <= n; ++ i) print((int)ans[i]);
println();
}
return 0;
}
|
Your friend Salem is Warawreh's brother and only loves math and geometry problems. He has solved plenty of such problems, but according to Warawreh, in order to graduate from university he has to solve more graph problems. Since Salem is not good with graphs he asked your help with the following problem.
<image>
You are given a complete directed graph with n vertices without self-loops. In other words, you have n vertices and each pair of vertices u and v (u ≠ v) has both directed edges (u, v) and (v, u).
Every directed edge of the graph is labeled with a single character: either 'a' or 'b' (edges (u, v) and (v, u) may have different labels).
You are also given an integer m > 0. You should find a path of length m such that the string obtained by writing out edges' labels when going along the path is a palindrome. The length of the path is the number of edges in it.
You can visit the same vertex and the same directed edge any number of times.
Input
The first line contains a single integer t (1 ≤ t ≤ 500) — the number of test cases.
The first line of each test case contains two integers n and m (2 ≤ n ≤ 1000; 1 ≤ m ≤ 10^{5}) — the number of vertices in the graph and desirable length of the palindrome.
Each of the next n lines contains n characters. The j-th character of the i-th line describes the character on the edge that is going from node i to node j.
Every character is either 'a' or 'b' if i ≠ j, or '*' if i = j, since the graph doesn't contain self-loops.
It's guaranteed that the sum of n over test cases doesn't exceed 1000 and the sum of m doesn't exceed 10^5.
Output
For each test case, if it is possible to find such path, print "YES" and the path itself as a sequence of m + 1 integers: indices of vertices in the path in the appropriate order. If there are several valid paths, print any of them.
Otherwise, (if there is no answer) print "NO".
Example
Input
5
3 1
*ba
b*b
ab*
3 3
*ba
b*b
ab*
3 4
*ba
b*b
ab*
4 6
*aaa
b*ba
ab*a
bba*
2 6
*a
b*
Output
YES
1 2
YES
2 1 3 2
YES
1 3 1 3 1
YES
1 2 1 3 4 1 4
NO
Note
The graph from the first three test cases is shown below:
<image>
In the first test case, the answer sequence is [1,2] which means that the path is:
$$$1 \xrightarrow{b} 2$$$
So the string that is obtained by the given path is b.
In the second test case, the answer sequence is [2,1,3,2] which means that the path is:
$$$2 \xrightarrow{b} 1 \xrightarrow{a} 3 \xrightarrow{b} 2$$$
So the string that is obtained by the given path is bab.
In the third test case, the answer sequence is [1,3,1,3,1] which means that the path is:
$$$1 \xrightarrow{a} 3 \xrightarrow{a} 1 \xrightarrow{a} 3 \xrightarrow{a} 1$$$
So the string that is obtained by the given path is aaaa.
The string obtained in the fourth test case is abaaba.
|
#include <iostream>
#include <set>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <map>
#include <string.h>
#include <cstdlib>
#include <bitset>
#include <unordered_map>
#include <iomanip>
#include <unordered_set>
#include <sstream>
using namespace std;
#define ll long long
ll mod=1e9+7;
char g[1000][1000];
signed main() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
int m;
cin >> m;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> g[i][j];
}
}
if (m == 1) {
cout << "yes\n1 2\n";
continue;
}
bool fl1 = 0, fl2 = 0;
int v1, v2;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (i != j && g[i][j] == g[j][i]) {
fl1 = 1;
v1 = i, v2 = j;
break;
}
}
}
if (fl1 == 1) {
cout << "yes\n";
for (int i = 0; i <= m; ++i) {
if (i % 2 == 0)
cout << v1 + 1 << ' ';
else
cout << v2 + 1 << ' ';
}
cout << '\n';
continue;
}
if (m % 2 == 1) {
cout << "yes\n";
for (int i = 0; i < m / 2 + 1; ++i) {
cout << "1 2 ";
}
cout << '\n';
continue;
}
bool flag = 0;
for (int v = 0; v < n && !flag; ++v) {
v1 = -1, v2 = -1;
int a = 0, b = 0;
for (int j = 0; j < n; ++j) {
if (j != v) {
if (g[v][j] == 'a')
a++;
else
b++;
}
}
if (a != n - 1 && b != n - 1) {
for (int j = 0; j < n; ++j) {
if (j != v) {
if (g[v][j] == 'a')
v1 = j;
else
v2 = j;
}
}
}
if(v1==-1||v2==-1)
continue;
v++, v1++, v2++;
if (m == 2) {
cout << "yes\n";
cout << v1 << ' ' << v << ' ' << v2 << '\n';
flag = 1;
break;
}
if (m % 4 == 0) {
cout << "yes\n";
cout << v << ' ';
for (int i = 0; i < m / 4; ++i) {
cout << v1 << ' ' << v << ' ' << v2 << ' ' << v << ' ';
}
flag = 1;
cout << '\n';
break;
}
if (m % 4 == 2) {
cout << "yes\n";
flag = 1;
cout << v2 << ' ' << v << ' ' << v1 << ' ';
for (int i = 0; i < m / 4; ++i) {
cout << v << ' ' << v2 << ' ' << v << ' ' << v1 << ' ';
}
cout << '\n';
break;
}
}
if (!flag) {
cout << "no\n";
}
}
return 0;
}
|
Yuu Koito and Touko Nanami are newlyweds! On the wedding day, Yuu gifted Touko a directed tree with n nodes and rooted at 1, and a labeling a which is some DFS order of the tree. Every edge in this tree is directed away from the root.
After calling dfs(1) the following algorithm returns a as a DFS order of a tree rooted at 1 :
order := 0
a := array of length n
function dfs(u):
order := order + 1
a[u] := order
for all v such that there is a directed edge (u -> v):
dfs(v)
Note that there may be different DFS orders for a given tree.
Touko likes the present so much she decided to play with it! On each day following the wedding day, Touko performs this procedure once:
* Among all directed edges u → v such that a_u < a_v, select the edge u' → v' with the lexicographically smallest pair (a_{u'}, a_{v'}).
* Swap a_{u'} and a_{v'}.
Days have passed since their wedding, and Touko has somehow forgotten which date the wedding was and what was the original labeling a! Fearing that Yuu might get angry, Touko decided to ask you to derive these two pieces of information using the current labeling.
Being her good friend, you need to find the number of days that have passed since the wedding, and the original labeling of the tree. However, there is a chance that Touko might have messed up her procedures, which result in the current labeling being impossible to obtain from some original labeling; in that case, please inform Touko as well.
Input
The first line of the input contains an integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of nodes on the tree.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n, all a_i are distinct) — the current labeling of the tree.
Each of the next n - 1 lines contains two integers u_i and v_i (1 ≤ u, v ≤ n, u ≠ v), describing an directed edge from u_i to v_i. The edges form a directed tree rooted at 1.
Output
If the current labeling is impossible to arrive at from any DFS order, print NO.
Else, on the first line, print YES. On the second line, print a single integer denoting the number of days since the wedding. On the third line, print n numbers space-separated denoting the original labeling of the tree.
If there are multiple correct outputs, print any. This means: you are allowed to output any pair (DFS order, number of days), such that we get the current configuration from the DFS order you provided in exactly the number of days you provided.
Examples
Input
7
4 5 2 1 7 6 3
1 5
7 6
1 2
2 7
3 4
1 3
Output
YES
5
1 4 2 3 7 6 5
Input
7
7 6 5 3 1 4 2
4 3
2 5
3 7
1 4
7 2
2 6
Output
NO
Note
The following animation showcases the first sample test case. The white label inside the node represents the index of the node i, while the boxed orange label represents the value a_i.
<image>
|
#include <bits/stdc++.h>
#define ll long long
#define sz(x) ((int) (x).size())
#define all(x) (x).begin(), (x).end()
#define vi vector<int>
#define pii pair<int, int>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
using namespace std;
template<typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vi a(n + 1), ainv(n + 1);
rep(i, 1, n + 1) {
cin >> a[i];
ainv[a[i]] = i;
}
vector<vi> g(n + 1);
vi par(n + 1), dep(n + 1), ti(n + 1), tout(n + 1), post;
post.push_back(-1);
int t = 1;
rep(i, 0, n - 1) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
par[v] = u;
}
rep(i, 1, n + 1) {
sort(all(g[i]), [&](int u, int v) { return a[u] < a[v]; });
}
function<void(int)> dfs = [&](int x) {
ti[x] = t++;
for(int y : g[x]) {
dep[y] = 1 + dep[x];
dfs(y);
}
tout[x] = t;
post.push_back(x);
};
dfs(1);
ll k = 0;
int sad = n + 1;
rep(i, 1, n + 1) {
k += dep[ainv[i]];
if(ainv[i] != post[i]) {
sad = i;
int x = ainv[i];
if(ti[ainv[i]] > ti[post[i]] || tout[post[i]] > tout[ainv[i]]) {
cout << "NO\n";
return 0;
}
while(x != 1) {
swap(ainv[a[x]], ainv[a[par[x]]]);
swap(a[x], a[par[x]]);
x = par[x];
}
break;
}
}
rep(i, sad, n) {
if(ti[ainv[i]] > ti[ainv[i + 1]]) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
cout << k << '\n';
rep(i, 1, n + 1) cout << ti[i] << ' ';
cout << '\n';
}
|
This is the easy version of the problem. The difference between the versions is the constraints on a_i. You can make hacks only if all versions of the problem are solved.
Little Dormi has recently received a puzzle from his friend and needs your help to solve it.
The puzzle consists of an upright board with n rows and m columns of cells, some empty and some filled with blocks of sand, and m non-negative integers a_1,a_2,…,a_m (0 ≤ a_i ≤ n). In this version of the problem, a_i will be equal to the number of blocks of sand in column i.
When a cell filled with a block of sand is disturbed, the block of sand will fall from its cell to the sand counter at the bottom of the column (each column has a sand counter). While a block of sand is falling, other blocks of sand that are adjacent at any point to the falling block of sand will also be disturbed and start to fall. Specifically, a block of sand disturbed at a cell (i,j) will pass through all cells below and including the cell (i,j) within the column, disturbing all adjacent cells along the way. Here, the cells adjacent to a cell (i,j) are defined as (i-1,j), (i,j-1), (i+1,j), and (i,j+1) (if they are within the grid). Note that the newly falling blocks can disturb other blocks.
In one operation you are able to disturb any piece of sand. The puzzle is solved when there are at least a_i blocks of sand counted in the i-th sand counter for each column from 1 to m.
You are now tasked with finding the minimum amount of operations in order to solve the puzzle. Note that Little Dormi will never give you a puzzle that is impossible to solve.
Input
The first line consists of two space-separated positive integers n and m (1 ≤ n ⋅ m ≤ 400 000).
Each of the next n lines contains m characters, describing each row of the board. If a character on a line is '.', the corresponding cell is empty. If it is '#', the cell contains a block of sand.
The final line contains m non-negative integers a_1,a_2,…,a_m (0 ≤ a_i ≤ n) — the minimum amount of blocks of sand that needs to fall below the board in each column. In this version of the problem, a_i will be equal to the number of blocks of sand in column i.
Output
Print one non-negative integer, the minimum amount of operations needed to solve the puzzle.
Examples
Input
5 7
#....#.
.#.#...
#....#.
#....##
#.#....
4 1 1 1 0 3 1
Output
3
Input
3 3
#.#
#..
##.
3 1 1
Output
1
Note
For example 1, by disturbing both blocks of sand on the first row from the top at the first and sixth columns from the left, and the block of sand on the second row from the top and the fourth column from the left, it is possible to have all the required amounts of sand fall in each column. It can be proved that this is not possible with fewer than 3 operations, and as such the answer is 3. Here is the puzzle from the first example.
<image>
For example 2, by disturbing the cell on the top row and rightmost column, one can cause all of the blocks of sand in the board to fall into the counters at the bottom. Thus, the answer is 1. Here is the puzzle from the second example.
<image>
|
/*
v:r:1BRBI.7J. jIJ27IUYUuri:7:::::::v7::ri..::irRBb71P2qKbu7i.::... :vIKr:i:rRS:::XXJur:iLIsS7LLrr1r
r .:JBRBL.:r. ...:iiuIIr:.r:..... .iir:.:. .:2I7i.2g7Pgd2IJ:.. rYr .:..i:...i5vsi:i2j11r7Yiir:
i.:rSRgZXi7irir:::r7ivZ5ii5s.r7iii::i:Yv::i.......i7bSJRdqDbX7ii:....:qr..:ir:irr::s2j7r1q15b77uv7r:
:..sgi7Xs:irirr71SP1J1U::i7rv2rr7s7Y::i7i:r:.:...iii.:DB.UZXs7iii:.. .iir::irr7iiij7JuY1qYssrr7 77:
. .LB:.qRi:iri7vMgg2XEXiBUY7LMqr517Yi:r7r:i:..:.::ii:YBg.PDSUr::i::.. .ir7Yriii:iirvi:I1KqsYjLu7rrvr
d1irRYiBBYsKSu7SSXDUUdZv5Bg17qQRPPg5ri7vi:.:::.:. :rIq1.LU5L:::::::..:r:rrrir:::i:7:.:u55LJj1Y777rr
QDX:i77RBDuuEs7L:.rr1PgsLdBQZX5::rL:.rj7ri:::..::.iri:i:r7vv:...::::..ii::i::::.:::rv: .vU2YuY7irr7i
. .:....v1i:rrrr7vr:i::i.7Qj.rr .:.:v7::irYPQBBQQZDdKPgEd5u77:.::..ir::.vKUUUr:..:: :j2uI1uvriii:
:.:.:::.::::7rvrr7Li... . ...... .:...:::.1gBBBQBQQgggMMBBBQQRQgPY: .ir7vJSPKdX1vr:rirLJ7Lvv77rrrr:
. ........ . . .... ... . igBQgMgMggDDDQQBMgRQggZPbEP7 .7s7rr7777i:riiiiiYvv7v7vvYvYLr
U7jsjLYvYvLvvvv77777v77r7r7r7r7rriri:.rgBQgDRMQRQggEDPSJv75ZRggqqPZZXJsr:.:::....::..::7JYJYsLLvLvLr
5UIX5SIS5XIS55I5ISIX5X5SISIXIS2S22jv2BBBMMQQggPX1Jv7r::.:i71qgZZbPPgdKKSi.:i.:.irirsYsvY7rir::::7Yvr
vrv77777v7777777777r7r7r7r7rrrrrr:.vBBQQBQg5sii::.:...:...::rjZDDEbPMbKdq::rL1X151uii:::riiir7vvvvsr
i:iiiririiiiiiiiiiiiiiii:i:i:i:::.jBQQQBdsi:...:::::::::::::.:7dgMdPdgPXEMYYs1vL7LLrr77vvsYsYsvYvvvr
:.:::::::::::::.:.:.:.:.:.:...:. rBQBBgv:.....:::::::::::.:::::7gRMPPdDKKgE:::::::irjLJssvYvLvvvLvYr
:.::::::::::::::::::::::::::.:. .BBBBPi::ri:.:::::::.........:::vRRMPEZbXPB7 :::::.::::r7vLsvsvYvYLr
i.::::::::::::::::::::::::::::. QBQBbr2ZBQBgKvr:i:i:rvuU5SIs7:::iXBggZZbPXgM:.::i:i:::::ii7YjsjLsYjr
:.:::::::::::::::::::::::::::: IBBQQv1Jr:i7uU27riri7ubZgddqPX5ri:vMBMDggPbKBv:iir7riii::......71uU1v
:.:::::::::::::::::::::::::::..QBQBPr::777vi7vvi:i7L1vrirr:::ivriiPBQDDRDEEg1.i::::::::::.:...:::::.
i.:::::::::::::::::::::::::::..BQBBL:1BBQjvSLuvi.:r1UuEBIJPPvi:iiivBQgEMDgDMi .........::i:i::......
:.:.:::::::::::::::::::::::::.:BBQQ:LPZDEiijYr7:.:rr7PBQv.rEM2vrr:ibBRQZRgMMs:rr7r7r7rrr7rrr7r7rrr2:
i:rrriiriiiiirrriririririririi7BBDviiiirrsYriii:.::::r7v7YriiL7rirrPBBQRRRgQ1i77r7r7r777777v7v7rYQ7
rivvvrr:iiriiri:iiiiiiriiirir:.. :rv::::::::i:.:::...:irrir:.::r:.:iSBBBRBQI:r7v7v7v77rrirr7riuBBi
rij2Js7r:irL77i:::::::::::::...:7viri::i::.:i:...:::...:...r7..:7s.. .1BQbBPrr7r7r77vLJvrirri:UBBBR
:.r7r:iYuiirrri.:::.:.:.:::...iv7..:rrvi:.iri::::.:ii::.:.:vu...rBU.... 7BPDj.::ii::....iiiii:i. .7I
i..::::7v777r7ii:::::::i:i...rv:..71uZU::iivMg5KQQ77ii::::i1s...rBP...:. KQE1rir:r::.... .:ri
i.::::rLY7Ysuvv77rr77rrJ5Iv..:vr:.JK75jiiii:1u25IPUrrii:irYu:.ii5gv...:. rRDPIKZv7r::ii...:. .vr.:
r:::iLYjLJvjsJv7r777rvr7SSjvi:vsi:.5L117ii::.......::rirv1j:.ir1Pi .:L7:.:DMPIPD:::rri.....r7: .:::.
r:iirrriiiriiirir7Yvv77ruUUjJrrYv:..r227irvUZEPPqJrirrrvur..:vuv:.:iY1YLYJBgggBP .i::.:....:v1Ji....
rirs177Lr7rrrvrirr:77r:7SbPPJs:77i:..7XUvXEMZEPEEgDQQP1s:..irjr.:7J2u1uY:2BRQBBM..::::........:svi..
UYUuUvrj1Lvv7rriL7ri7L7LDEZgX7u7vrri:.rX5rr7Yj2u1Lvr7J7..:irv7irYu1u2J77PBBBBBBQ:::ir...::::i..:i::.
JsujLvrsJjvvrrr7rr7LvsvYvuIZqL2UUUL7ri.:LsvvvsJUus77r:.:i7JUYLLuLvvsvvsvLMKZg2vi.::iriirrL7vvi. .:.
2u5Jsv7rs12vv7Y7LJu1JYYriir1jYq2U1uLri:..:7ri:::::ii..ir7vsvYLussLvi7jK:i: .....:rrvsI1uJYLsvriii:
ggD5sY7L7vssr7jYjUL7iiii:i:i:Y5S1I1J7rii:..:ri:i::..:irr7L7vvLvjJsr1Qqui::.. ..:r2PKsYvJIqSPZSjSS1
:.:irLL77rv777s77rv77ri:::r1vrJ5PII1Jv7ri:..:1X7:.::ir77vvLYJYJvJ17QBSJrvr:....... :7Ss2PIs7LPjU1IL
i:rv77vv7777vv7rrvv7i:.:::2Zs7rrLPIuYs7vrr::.iL.:iirr77vvYYJjjJuY77BX7ubL::i::.:...:..7BZPvr7I2jJUui
i.irrr7vsvL777r::::::.:ii:7Ijr7i.YqjLvY77rr:::::iirrrrv7vvsJU2u71PBRjLDX::i::::..:i::..Kq7iisu2U51vr
:.irrri7sjLLs7::rYv7rr::ii7Pj7rrrrr2vv77ii::r7:::::irrrv77L5IIsKQBQK7Z5::i:::::i7r::::..75vYYvi7777D
:.rrrrri7sv7vi:12jUJsJJiii7Qsivrrii7sii:::::J1::::::::ir7rPbXIqEQRD7DX::i:::::i7rr7i:::.:RBMDj7vvYXQ
::rririririiiii77Yu1jYIIii:dEr7Y:rr7i....::i5Br:::.....:ijBdKddgDg1Eb::i:i:i::rrrrr7r:::..uP222q1LYv
i.rrrrrrr:ii:iriii7jX5U2uii7QbrLsi7::.:.:::7ZB2:i::.:....iQgggP5gqdMi:iri:i::7vrriiir7i::. LI1I21Yuv
i::rrrrr:i:i:rrrrriYs5KX2sir5RP7jr:::::iiiiKPQKriii:::::..:BBX7ZZdMs:ivr:i::ujrir777r7r::::......:.
i:ririi:::i:rrrr77vj2uu5qXvi5PQ7::::iirrrr2ZDMQLririi::::..:S2dRbDE::7r:ir:Ljrvvv77ri:::riusvr7r7sr.
i:rriiiiii:ir7r7rrivY21UPdIrP2:::::iirr77uZdBQQQ7rrrii::::.. IBgXMv:rr:iirr5u1J5YL7ri:isYiYBIvvvvj1J
:.:::.....:rr7v7vrrs2Lu2qQPrr:::::iiii77jdUURBQBRrririi::::.. YZQdri1viivrPbPSsvrivvuLirIj:P1iiiiir:
uL122IU5Iq7777r7v1IPXKPQQQL:.::::iiir77JX2:EPBRQBdrriiii::::.. :RPi7SPi7UZgbJ7iiiiis5EIr:viiKsvv7Lv7
DqdbbPdPdb1LsvY7JY15dPQBP:.:::::iirr77sUDu:dMgBQBBXr7irii:::::. .rvuSXr2MZurirJ5Pu7::rqPKv7.1BQRQRQR
X5SK5KSS5P1v7suIuurrDBbr..:::i:iirrvvu1PPb77q1QBBg5J77iiii::::::..:IKqsDZsr1PgRMPEZEj:.r77i.:BBBBBBB
S152II55PP7irirsUuUKDs..::::i:iir7YsUIdbbEur7r7U11uS2v7rrii::::::...1QREXIEZd1v:..::YJi.. .i:77rrir:
2uU5UIII7L7LsIJuSgQq:..::::iiri77sjXXEZPXPI1IdqPK5s5s177rrii::::::.. JQgdZPK7::i::::.::ivKgPriii:ri:
5J52I2K7:ivJIuUU5Li.::::i:iirr7vjuX5YLv5IuIvIqgdKus7LqU77rrii:i:::::. :gMS2vrirri:::i7KDdKPvrirr7EY:
5UIS2SK7:r:iir7vi:::::iiirirrvvJjXIi::iq5U5vr5qP55775ZqJ77rrrrii::::.. .iiii:i:i:i:rJUsr:i7Jsvirrii:
d5dPbPMjir7vL7r:::i:iirirrrrvLuu2DUiiiiJbUS5r7JEXsrUEKdXsvv7rrrii::::::..:iiiiii77Li:.::::irvv7rrir:
svLY7LJ7i7r7ri:i:i:iirirr77vvsjIPQurrrii2qKEriYPvrvEKPPDKJ7v77rriii::::::..irv777JjUYr::::rL:777iiri
r:7r7vrirrrii:i:iiiirrrr77LvJJ2PgD5iY7ri7PPP1:UIrr5PdbgZb2u7v77rrrrii::::::.:7Lri:::ir7i::iB2irrrrr:
ZdZgR2r7iiiiiiiiiiirrrr7vLvJuIPgdMX7svrriKKPI:2XJPPZdZEPuUXj7L77rrrrii::::::.:irr77rii:i::.PBg7vsJvr
1uZQbr7rriiiririrrrr77vLYs11SPMEgMEvuvvrrXD2IrIXBMQEEPdX1sU5JLsvv77rriiii:::::::irv7L77rrri..rXBDuYr
S2XL:::::::::iiiirr7r77LvJuXIDgggRDL7vri.vKuU2j5bPqdqPPP5Y7L1Y7777rrii::::...........::::::rri.:vYLr*/
//This disgusting code is written by Juruo D0zingbear
//Please don't hack me! 0v0 <3
/*
_/_/_/_/ _/_/_/_/_/ _/_/_/
_/ _/ _/ _/ _/
_/ _/ _/ _/ _/
_/ _/ _/ _/ _/
_/ _/ _/ _/ _/ _/
_/ _/ _/ _/ _/ _/_/
_/_/_/_/ _/_/ _/_/_/_/_/
_/_/_/_/ _/ _/ _/ _/
_/ _/ _/ _/ _/_/ _/_/
_/ _/ _/_/ _/ _/_/ _/
_/ _/ _/ _/ _/ _/
_/ _/ _/_/ _/ _/
_/ _/ _/ _/ _/ _/
_/_/_/_/ _/ _/ _/ _/
_/_/_/_/_/ _/_/_/_/_/ _/_/_/_/_/
_/ _/ _/
_/ _/ _/
_/ _/ _/_/_/_/
_/ _/ _/
_/ _/ _/
_/ _/_/_/_/_/ _/_/_/_/_/
_/_/_/_/_/ _/_/_/_/_/ _/_/_/_/_/
_/ _/ _/
_/ _/ _/
_/ _/ _/_/_/_/
_/ _/ _/
_/ _/ _/
_/ _/_/_/_/_/ _/_/_/_/_/
*/
#include<bits/stdc++.h>
#define LL long long
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
using namespace std;
namespace IO
{
const int sz=1<<15;
char inbuf[sz],outbuf[sz];
char *pinbuf=inbuf+sz;
char *poutbuf=outbuf;
inline char _getchar()
{
if (pinbuf==inbuf+sz)fread(inbuf,1,sz,stdin),pinbuf=inbuf;
return *(pinbuf++);
}
inline void _putchar(char x)
{
if (poutbuf==outbuf+sz)fwrite(outbuf,1,sz,stdout),poutbuf=outbuf;
*(poutbuf++)=x;
}
inline void flush()
{
if (poutbuf!=outbuf)fwrite(outbuf,1,poutbuf-outbuf,stdout),poutbuf=outbuf;
}
}
inline int read(){
int v=0,f=1;
char c=getchar();
while (c<'0' || c>'9'){
if (c=='-') f=-1;
c=getchar();
}
while (c>='0' && c<='9'){
v=v*10+c-'0';
c=getchar();
}
return v*f;
}
const int Maxn=400005;
const int dx[]={0,0,1,-1};
const int dy[]={1,-1,0,0};
int n,m,A[Maxn];
vector<char> V[Maxn];
vector<int> pos[Maxn];
vector<int> G[Maxn],nG[Maxn],vG[Maxn];
int col[Maxn],vis[Maxn],O[Maxn],ko,bad[Maxn],kc,I[Maxn];
void dfs1(int x){
vis[x]=1;
for (int i=0;i<G[x].size();i++){
int v=G[x][i];
if (!vis[v]){
dfs1(v);
}
}
O[ko++]=x;
}
void dfs2(int x,int C){
col[x]=C;vis[x]=1;
for (int i=0;i<nG[x].size();i++){
int v=nG[x][i];
if (!vis[v]){
dfs2(v,C);
}
}
}
void Kos(){
for (int i=0;i<n*m;i++){
for (int j=0;j<G[i].size();j++){
//cerr<<i<<' '<<G[i][j]<<endl;
nG[G[i][j]].pb(i);
}
}
memset(vis,0,sizeof(vis));
for (int i=0;i<n*m;i++){
if (!vis[i] && !bad[i]){
dfs1(i);
}
}
memset(vis,0,sizeof(vis));
for (int i=ko-1;i>=0;i--){
int x=O[i];
if (!vis[x]){
dfs2(x,++kc);
}
}
for (int i=0;i<n*m;i++){
for (int j=0;j<G[i].size();j++){
int x=col[i],y=col[G[i][j]];
if (x!=y) vG[x].pb(y),I[y]=1;
}
}
int ans=0;
for (int i=1;i<=kc;i++){
if (!I[i]) ans++;
}
printf("%d\n",ans);
}
int Lim[Maxn];
int par[Maxn];
int main(){
n=read();m=read();
for (int i=0;i<n;i++){
for (int j=0;j<m;j++){
char ch=getchar();
while (ch=='\n' || ch==' ') ch=getchar();
V[i].pb(ch);
if (ch=='#'){
pos[j].pb(i);
}
}
}
for (int i=0;i<m;i++){
scanf("%d",&A[i]);
assert(pos[i].size()>=A[i]);
if (!A[i]) {
Lim[i]=-1;
continue;
}
reverse(pos[i].begin(),pos[i].end());
Lim[i]=pos[i][A[i]-1];
reverse(pos[i].begin(),pos[i].end());
}
// cerr<<123<<endl;
for (int i=0;i<m;i++){
if (pos[i].empty()) continue;
for (int j=0;j<pos[i].size()-1;j++){
int A=pos[i][j]*m+i,B=pos[i][j+1]*m+i;
G[A].pb(B);
if (pos[i][j]==pos[i][j+1]-1) G[B].pb(A);
}
for (int j=0;j<pos[i].size();j++){
int A=pos[i][j]*m+i;
if (i){
int p=lower_bound(pos[i-1].begin(),pos[i-1].end(),pos[i][j])-pos[i-1].begin();
if (p!=pos[i-1].size()){
p=pos[i-1][p];
G[A].pb(p*m+(i-1));
}
}
if (i!=m-1){
int p=lower_bound(pos[i+1].begin(),pos[i+1].end(),pos[i][j])-pos[i+1].begin();
if (p==pos[i+1].size()) continue;
p=pos[i+1][p];
G[A].pb(p*m+(i+1));
}
}
}
// cerr<<123<<endl;
for (int i=0;i<n;i++){
for (int j=0;j<m;j++){
if (V[i][j]=='.') bad[i*m+j]=true;
}
}
Kos();
}
/*
5 7
#..###.
.#.#...
#....#.
#....##
#######
4 1 1 1 0 3 1
*/
|
Let's consider one interesting word game. In this game you should transform one word into another through special operations.
Let's say we have word w, let's split this word into two non-empty parts x and y so, that w = xy. A split operation is transforming word w = xy into word u = yx. For example, a split operation can transform word "wordcut" into word "cutword".
You are given two words start and end. Count in how many ways we can transform word start into word end, if we apply exactly k split operations consecutively to word start.
Two ways are considered different if the sequences of applied operations differ. Two operation sequences are different if exists such number i (1 ≤ i ≤ k), that in the i-th operation of the first sequence the word splits into parts x and y, in the i-th operation of the second sequence the word splits into parts a and b, and additionally x ≠ a holds.
Input
The first line contains a non-empty word start, the second line contains a non-empty word end. The words consist of lowercase Latin letters. The number of letters in word start equals the number of letters in word end and is at least 2 and doesn't exceed 1000 letters.
The third line contains integer k (0 ≤ k ≤ 105) — the required number of operations.
Output
Print a single number — the answer to the problem. As this number can be rather large, print it modulo 1000000007 (109 + 7).
Examples
Input
ab
ab
2
Output
1
Input
ababab
ababab
1
Output
2
Input
ab
ba
2
Output
0
Note
The sought way in the first sample is:
ab → a|b → ba → b|a → ab
In the second sample the two sought ways are:
* ababab → abab|ab → ababab
* ababab → ab|abab → ababab
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 28;
const double INF = 1e12, EPS = 1e-9;
const int mod = (int)1e9 + 7;
int n, k;
long long dp[2][2], ans;
void run() {
string a, b;
cin >> a >> b >> k;
dp[0][0] = 1;
n = a.size();
if (b.size() != n) {
cout << 0 << endl;
return;
}
int cur = 0, next = 1;
for (int i = 0; i < k; i++) {
dp[next][0] = dp[cur][1] * (n - 1) % mod;
dp[next][1] = (dp[cur][0] + dp[cur][1] * (n - 2)) % mod;
swap(cur, next);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
if (a[j] != b[(i + j) % n]) goto NEXT;
(ans += dp[cur][i != 0]) %= mod;
NEXT:;
}
cout << ans << endl;
}
int main() { run(); }
|
The Little Elephant loves Ukraine very much. Most of all he loves town Rozdol (ukr. "Rozdil").
However, Rozdil is dangerous to settle, so the Little Elephant wants to go to some other town. The Little Elephant doesn't like to spend much time on travelling, so for his journey he will choose a town that needs minimum time to travel to. If there are multiple such cities, then the Little Elephant won't go anywhere.
For each town except for Rozdil you know the time needed to travel to this town. Find the town the Little Elephant will go to or print "Still Rozdil", if he stays in Rozdil.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of cities. The next line contains n integers, separated by single spaces: the i-th integer represents the time needed to go from town Rozdil to the i-th town. The time values are positive integers, not exceeding 109.
You can consider the cities numbered from 1 to n, inclusive. Rozdil is not among the numbered cities.
Output
Print the answer on a single line — the number of the town the Little Elephant will go to. If there are multiple cities with minimum travel time, print "Still Rozdil" (without the quotes).
Examples
Input
2
7 4
Output
2
Input
7
7 4 47 100 4 9 12
Output
Still Rozdil
Note
In the first sample there are only two cities where the Little Elephant can go. The travel time for the first town equals 7, to the second one — 4. The town which is closest to Rodzil (the only one) is the second one, so the answer is 2.
In the second sample the closest cities are cities two and five, the travelling time to both of them equals 4, so the answer is "Still Rozdil".
|
n = int(input())
string = input()
times = list(map(int, string.split()))
a = min(times)
if times.count(a) == 1:
print(times.index(a) + 1)
else:
print("Still Rozdil")
|
Once upon a time an old man and his wife lived by the great blue sea. One day the old man went fishing and caught a real live gold fish. The fish said: "Oh ye, old fisherman! Pray set me free to the ocean and I will grant you with n gifts, any gifts you wish!". Then the fish gave the old man a list of gifts and their prices. Some gifts on the list can have the same names but distinct prices. However, there can't be two gifts with the same names and the same prices. Also, there can be gifts with distinct names and the same prices. The old man can ask for n names of items from the list. If the fish's list has p occurrences of the given name, then the old man can't ask for this name of item more than p times.
The old man knows that if he asks for s gifts of the same name, the fish will randomly (i.e. uniformly amongst all possible choices) choose s gifts of distinct prices with such name from the list. The old man wants to please his greedy wife, so he will choose the n names in such a way that he can get n gifts with the maximum price. Besides, he isn't the brightest of fishermen, so if there are several such ways, he chooses one of them uniformly.
The old man wondered, what is the probability that he can get n most expensive gifts. As the old man isn't good at probability theory, he asks you to help him.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 1000) — the number of the old man's wishes and the number of distinct names in the goldfish's list, correspondingly. Then m lines follow: the i-th line first contains integer ki (ki > 0) — the number of distinct prices of gifts with the i-th name, then ki distinct space-separated integers cij (1 ≤ cij ≤ 109), the gifts' prices.
It is guaranteed that the sum of all ki doesn't exceed 1000. It is guaranteed that n is not greater than the total number of the gifts.
Output
On a single line print one real number — the probability of getting n most valuable gifts. The answer will be considered correct if its absolute or relative error does not exceed 10 - 9.
Examples
Input
3 1
3 10 20 30
Output
1.000000000
Input
3 2
1 40
4 10 20 30 40
Output
0.166666667
|
#include <bits/stdc++.h>
using namespace std;
int Get() {
char c;
while (c = getchar(), c < '0' || c > '9')
;
int X = 0;
while (c >= '0' && c <= '9') {
X = X * 10 + c - 48;
c = getchar();
}
return X;
}
const double eps = 1e-7;
int main() {
int N = Get(), M = Get(), Total = 0;
static int K[1000], Value[1000][1000], Data[1000];
for (int i = 0; i < M; i++) {
K[i] = Get();
for (int j = 0; j < K[i]; j++) Value[i][j] = Data[Total++] = Get();
}
sort(Data, Data + Total);
int Min = Data[Total - N], Need = 1;
while (Need < N && Data[Total - N + Need] == Min) Need++;
static int A[1000], B[1000];
for (int i = 0; i < M; i++)
for (int j = A[i] = B[i] = 0; j < K[i]; j++)
if (Value[i][j] > Min)
A[i]++;
else if (Value[i][j] == Min)
B[i]++;
static int Sum[1001];
for (int i = Sum[0] = 0; i < M; i++) Sum[i + 1] = Sum[i] + B[i];
static double C[1001][1001];
for (int i = 0; i <= 1000; i++)
for (int j = 0; j <= i; j++)
if (!j || i == j)
C[i][j] = 1;
else
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
static double DP[1001][1000];
memset(DP, 0, sizeof(DP));
DP[0][0] = 1;
for (int i = 0; i < M; i++)
for (int j = 0; j <= Sum[i]; j++)
for (int k = 0; k <= B[i] && j + k <= Need; k++) {
double Temp = DP[i][j];
Temp *= C[B[i]][k] / C[K[i]][A[i] + k];
Temp *= C[Sum[i]][j] / C[Sum[i + 1]][j + k];
DP[i + 1][j + k] += Temp;
}
printf("%0.10lf\n", DP[M][Need]);
return 0;
}
|
Vasya is pressing the keys on the keyboard reluctantly, squeezing out his ideas on the classical epos depicted in Homer's Odysseus... How can he explain to his literature teacher that he isn't going to become a writer? In fact, he is going to become a programmer. So, he would take great pleasure in writing a program, but none — in writing a composition.
As Vasya was fishing for a sentence in the dark pond of his imagination, he suddenly wondered: what is the least number of times he should push a key to shift the cursor from one position to another one?
Let's describe his question more formally: to type a text, Vasya is using the text editor. He has already written n lines, the i-th line contains ai characters (including spaces). If some line contains k characters, then this line overall contains (k + 1) positions where the cursor can stand: before some character or after all characters (at the end of the line). Thus, the cursor's position is determined by a pair of integers (r, c), where r is the number of the line and c is the cursor's position in the line (the positions are indexed starting from one from the beginning of the line).
Vasya doesn't use the mouse to move the cursor. He uses keys "Up", "Down", "Right" and "Left". When he pushes each of these keys, the cursor shifts in the needed direction. Let's assume that before the corresponding key is pressed, the cursor was located in the position (r, c), then Vasya pushed key:
* "Up": if the cursor was located in the first line (r = 1), then it does not move. Otherwise, it moves to the previous line (with number r - 1), to the same position. At that, if the previous line was short, that is, the cursor couldn't occupy position c there, the cursor moves to the last position of the line with number r - 1;
* "Down": if the cursor was located in the last line (r = n), then it does not move. Otherwise, it moves to the next line (with number r + 1), to the same position. At that, if the next line was short, that is, the cursor couldn't occupy position c there, the cursor moves to the last position of the line with number r + 1;
* "Right": if the cursor can move to the right in this line (c < ar + 1), then it moves to the right (to position c + 1). Otherwise, it is located at the end of the line and doesn't move anywhere when Vasya presses the "Right" key;
* "Left": if the cursor can move to the left in this line (c > 1), then it moves to the left (to position c - 1). Otherwise, it is located at the beginning of the line and doesn't move anywhere when Vasya presses the "Left" key.
You've got the number of lines in the text file and the number of characters, written in each line of this file. Find the least number of times Vasya should push the keys, described above, to shift the cursor from position (r1, c1) to position (r2, c2).
Input
The first line of the input contains an integer n (1 ≤ n ≤ 100) — the number of lines in the file. The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 105), separated by single spaces. The third line contains four integers r1, c1, r2, c2 (1 ≤ r1, r2 ≤ n, 1 ≤ c1 ≤ ar1 + 1, 1 ≤ c2 ≤ ar2 + 1).
Output
Print a single integer — the minimum number of times Vasya should push a key to move the cursor from position (r1, c1) to position (r2, c2).
Examples
Input
4
2 1 6 4
3 4 4 2
Output
3
Input
4
10 5 6 4
1 11 4 2
Output
6
Input
3
10 1 10
1 10 1 1
Output
3
Note
In the first sample the editor contains four lines. Let's represent the cursor's possible positions in the line as numbers. Letter s represents the cursor's initial position, letter t represents the last one. Then all possible positions of the cursor in the text editor are described by the following table.
123
12
123s567
1t345
One of the possible answers in the given sample is: "Left", "Down", "Left".
|
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class Solver {
public static void main(String[] args) throws IOException {
br = new BufferedReader(new FileReader("input.txt"));
pw = new PrintWriter("output.txt");
// br = new BufferedReader(new InputStreamReader(System.in));
// pw = new PrintWriter(System.out);
n = nextInt();
a = new int[n];
int max = 0;
for (int i = 0; i < n; i++) {
a[i] = nextInt();
max = max(a[i], max);
}
dist = new int[n][max + 1];
for (int i = 0; i < n; i++) {
for (int j = 0; j < a[i] + 1; j++) {
dist[i][j] = -1;
}
}
int x1 = nextInt() - 1;
int y1 = nextInt() - 1;
int x2 = nextInt() - 1;
int y2 = nextInt() - 1;
dist[x1][y1] = 0;
Queue<Point> q = new ArrayDeque<>();
q.add(new Point(x1, y1));
while (!q.isEmpty()) {
Point v = q.poll();
int x = v.x;
int y = v.y;
if (x - 1 >= 0) {
if (a[x - 1] < y) {
if (dist[x - 1][a[x - 1]] == -1) {
dist[x - 1][a[x - 1]] = dist[x][y] + 1;
q.add(new Point(x - 1, a[x - 1]));
}
}
if (dist[x - 1][y] == -1) {
dist[x - 1][y] = dist[x][y] + 1;
q.add(new Point(x - 1, y));
}
}
if (x + 1 < n) {
if (a[x + 1] < y) {
if (dist[x + 1][a[x + 1]] == -1) {
dist[x + 1][a[x + 1]] = dist[x][y] + 1;
q.add(new Point(x + 1, a[x + 1]));
}
}
if (dist[x + 1][y] == -1) {
dist[x + 1][y] = dist[x][y] + 1;
q.add(new Point(x + 1, y));
}
}
if (y - 1 >= 0) {
if (dist[x][y - 1] == -1) {
dist[x][y - 1] = dist[x][y] + 1;
q.add(new Point(x, y - 1));
}
}
if (y + 1 <= a[x]) {
if (dist[x][y + 1] == -1) {
dist[x][y + 1] = dist[x][y] + 1;
q.add(new Point(x, y + 1));
}
}
// for (int i = 0; i < n; i++) {
// for (int j = 0; j < a[i] + 1; j++) {
// pw.print(dist[i][j] + " ");
// }
// pw.println();
// }
// pw.println();
}
// for (int i = 0; i < n; i++) {
// for (int j = 0; j < max + 1; j++) {
// pw.print(dist[i][j] + " ");
// }
// pw.println();
// }
// pw.println();
pw.println(dist[x2][y2]);
pw.close();
}
static int[] a;
static int[][] dist;
static int n;
static StringTokenizer st = new StringTokenizer("");
static BufferedReader br;
static PrintWriter pw;
static String next() throws IOException {
while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
return st.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
static long nextLong() throws IOException {
return Long.parseLong(next());
}
static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
class Point {
int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
|
Convexity of a set of points on the plane is the size of the largest subset of points that form a convex polygon. Your task is to build a set of n points with the convexity of exactly m. Your set of points should not contain three points that lie on a straight line.
Input
The single line contains two integers n and m (3 ≤ m ≤ 100, m ≤ n ≤ 2m).
Output
If there is no solution, print "-1". Otherwise, print n pairs of integers — the coordinates of points of any set with the convexity of m. The coordinates shouldn't exceed 108 in their absolute value.
Examples
Input
4 3
Output
0 0
3 0
0 3
1 1
Input
6 3
Output
-1
Input
6 6
Output
10 0
-10 0
10 1
9 1
9 -1
0 -2
Input
7 4
Output
176166 6377
709276 539564
654734 174109
910147 434207
790497 366519
606663 21061
859328 886001
|
import static java.lang.Math.*;
import static java.math.BigInteger.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import java.io.*;
import java.lang.reflect.*;
import java.util.*;
public class B {
final int INF = (int) 1e5;
@SuppressWarnings("unused")
public B () {
int N = sc.nextInt();
int M = sc.nextInt();
if (M == 3) {
if (N >= 5)
exit(-1);
int [][] res = { { 0, 0 }, { 3, 0 }, { 0, 3 }, { 1, 1 } };
for (int i : rep(N))
print(res[i]);
exit();
}
int A = ceil(M-4, 2), D = floor(M-4, 2);
int B = floor(N-M, 2), C = ceil(N-M, 2);
int [][] P = { { 0, 0 }, { 0, INF }, { INF, INF }, { INF, 0 } };
for (int [] p : P)
print(p);
int t, x, y;
t = A+4; x = 1; y = INF;
for (int i : rep(A)) {
y += t;
print(x, y);
x += 4; --t;
}
t = B+4; x = 2; y = INF;
for (int i : rep(B)) {
y -= t;
if (i == B-1)
while (x + y <= INF)
x += 4;
print(x, y);
x += 4; --t;
}
t = C+4; x = 3; y = 0;
for (int i : rep(C)) {
y += t;
if (i == C-1)
while (x <= y)
x += 4;
print(x, y);
x += 4; --t;
}
t = D+4; x = 4; y = 0;
for (int i : rep(D)) {
y -= t;
print(x, y);
x += 4; --t;
}
}
int floor (int p, int q) {
return p / q;
}
int ceil (int p, int q) {
return (p + q - 1) / q;
}
////////////////////////////////////////////////////////////////////////////////////
static Iterable<Integer> rep(final int S, final int T) {
return new Iterable<Integer>() {
public Iterator<Integer> iterator() {
return new Iterator<Integer>() {
int i = S;
public void remove() { throw new UnsupportedOperationException(); }
public Integer next() { return i++; }
public boolean hasNext() { return i < T; }
};
}
};
}
static Iterable<Integer> rep(int N) { return rep(0, N); }
static Iterable<Integer> req(int S, int T) { return rep(S, T+1); }
////////////////////////////////////////////////////////////////////////////////////
/* Dear hacker, don't bother reading below this line, unless you want to help me debug my I/O routines :-) */
static MyScanner sc = new MyScanner();
static class MyScanner {
public String next() {
newLine();
return line[index++];
}
public char nextChar() {
return next().charAt(0);
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public String nextLine() {
line = null;
return readLine();
}
public String [] nextStrings() {
line = null;
return readLine().split(" ");
}
public char [] nextChars() {
return next().toCharArray();
}
public Integer [] nextInts() {
String [] L = nextStrings();
Integer [] res = new Integer [L.length];
for (int i = 0; i < L.length; ++i)
res[i] = Integer.parseInt(L[i]);
return res;
}
public Long [] nextLongs() {
String [] L = nextStrings();
Long [] res = new Long [L.length];
for (int i = 0; i < L.length; ++i)
res[i] = Long.parseLong(L[i]);
return res;
}
public Double [] nextDoubles() {
String [] L = nextStrings();
Double [] res = new Double [L.length];
for (int i = 0; i < L.length; ++i)
res[i] = Double.parseDouble(L[i]);
return res;
}
public String [] next (int N) {
String [] res = new String [N];
for (int i = 0; i < N; ++i)
res[i] = sc.next();
return res;
}
public Integer [] nextInt (int N) {
Integer [] res = new Integer [N];
for (int i = 0; i < N; ++i)
res[i] = sc.nextInt();
return res;
}
public Long [] nextLong (int N) {
Long [] res = new Long [N];
for (int i = 0; i < N; ++i)
res[i] = sc.nextLong();
return res;
}
public Double [] nextDouble (int N) {
Double [] res = new Double [N];
for (int i = 0; i < N; ++i)
res[i] = sc.nextDouble();
return res;
}
public String [][] nextStrings (int N) {
String [][] res = new String [N][];
for (int i = 0; i < N; ++i)
res[i] = sc.nextStrings();
return res;
}
public Integer [][] nextInts (int N) {
Integer [][] res = new Integer [N][];
for (int i = 0; i < N; ++i)
res[i] = sc.nextInts();
return res;
}
public Long [][] nextLongs (int N) {
Long [][] res = new Long [N][];
for (int i = 0; i < N; ++i)
res[i] = sc.nextLongs();
return res;
}
public Double [][] nextDoubles (int N) {
Double [][] res = new Double [N][];
for (int i = 0; i < N; ++i)
res[i] = sc.nextDoubles();
return res;
}
//////////////////////////////////////////////
private boolean eol() {
return index == line.length;
}
private String readLine() {
try {
return r.readLine();
} catch (Exception e) {
throw new Error(e);
}
}
private final BufferedReader r;
MyScanner () {
this(new BufferedReader(new InputStreamReader(System.in)));
}
MyScanner(BufferedReader r) {
try {
this.r = r;
while (!r.ready())
Thread.sleep(1);
start();
} catch (Exception e) {
throw new Error(e);
}
}
private String [] line;
private int index;
private void newLine() {
if (line == null || eol()) {
line = readLine().split(" ");
index = 0;
}
}
}
static void print(Object o, Object... a) {
printDelim(" ", o, a);
}
static void cprint(Object o, Object... a) {
printDelim("", o, a);
}
static void printDelim (String delim, Object o, Object... a) {
pw.println(build(delim, o, a));
}
static void exit (Object o, Object... a) {
print(o, a);
exit();
}
static void exit () {
pw.close();
System.out.flush();
System.err.println("------------------");
System.err.println("Time: " + ((millis() - t) / 1000.0));
System.exit(0);
}
void NO() {
throw new Error("NO!");
}
////////////////////////////////////////////////////////////////////////////////////
static String build(String delim, Object o, Object... a) {
StringBuilder b = new StringBuilder();
append(b, o, delim);
for (Object p : a)
append(b, p, delim);
return b.toString().trim();
}
static void append(StringBuilder b, Object o, String delim) {
if (o.getClass().isArray()) {
int L = Array.getLength(o);
for (int i = 0; i < L; ++i)
append(b, Array.get(o, i), delim);
} else if (o instanceof Iterable<?>) {
for (Object p : (Iterable<?>)o)
append(b, p, delim);
} else
b.append(delim).append(o);
}
////////////////////////////////////////////////////////////////////////////////////
static void statics() {
abs(0);
valueOf(0);
sort((int[])null);
reverseOrder();
}
public static void main(String[] args) {
new B();
exit();
}
static void start() {
t = millis();
}
static PrintWriter pw = new PrintWriter(System.out);
static long t;
static long millis() {
return System.currentTimeMillis();
}
}
|
Vitaly is a very weird man. He's got two favorite digits a and b. Vitaly calls a positive integer good, if the decimal representation of this integer only contains digits a and b. Vitaly calls a good number excellent, if the sum of its digits is a good number.
For example, let's say that Vitaly's favourite digits are 1 and 3, then number 12 isn't good and numbers 13 or 311 are. Also, number 111 is excellent and number 11 isn't.
Now Vitaly is wondering, how many excellent numbers of length exactly n are there. As this number can be rather large, he asks you to count the remainder after dividing it by 1000000007 (109 + 7).
A number's length is the number of digits in its decimal representation without leading zeroes.
Input
The first line contains three integers: a, b, n (1 ≤ a < b ≤ 9, 1 ≤ n ≤ 106).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
1 3 3
Output
1
Input
2 3 10
Output
165
|
MOD=10**9+7
a,b,n=list(map(int,input().strip().split(' ')))
#there are i a's. n-i b's
def check(a,b,x):
temp=x%10
if temp!=a and temp!=b:
return 0
while(x>0):
temp=x%10
if temp!=a and temp!=b:
return 0
x=x//10
return 1
fact=[1]
infact=[1]
temp=1
intemp=1
for i in range(1,n+1):
temp*=i
#intemp*=pow(i,MOD-2,MOD)
temp%=MOD
#intemp%=MOD
fact+=[temp]
#infact+=[intemp]
def binom(a,b):
MOD=10**9+7
if b==0:
return 1
else:
temp=pow(fact[a-b]*fact[b],MOD-2,MOD)*fact[a]
return temp%MOD
total=0
for i in range(n+1):
temp=i*a+(n-i)*b
if check(a,b,temp)==1:
total+=binom(n,i)
total%=MOD
#total*=fact[a]
print(total%MOD)
|
Iahub got bored, so he invented a game to be played on paper.
He writes n integers a1, a2, ..., an. Each of those integers can be either 0 or 1. He's allowed to do exactly one move: he chooses two indices i and j (1 ≤ i ≤ j ≤ n) and flips all values ak for which their positions are in range [i, j] (that is i ≤ k ≤ j). Flip the value of x means to apply operation x = 1 - x.
The goal of the game is that after exactly one move to obtain the maximum number of ones. Write a program to solve the little game of Iahub.
Input
The first line of the input contains an integer n (1 ≤ n ≤ 100). In the second line of the input there are n integers: a1, a2, ..., an. It is guaranteed that each of those n values is either 0 or 1.
Output
Print an integer — the maximal number of 1s that can be obtained after exactly one move.
Examples
Input
5
1 0 0 1 0
Output
4
Input
4
1 0 0 1
Output
4
Note
In the first case, flip the segment from 2 to 5 (i = 2, j = 5). That flip changes the sequence, it becomes: [1 1 1 0 1]. So, it contains four ones. There is no way to make the whole sequence equal to [1 1 1 1 1].
In the second case, flipping only the second and the third element (i = 2, j = 3) will turn all numbers into 1.
|
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class Solution {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n=s.nextInt();
int a[]=new int[n];
for(int i=0;i<n;i++)
a[i]=s.nextInt();
int max=0;
for(int i=0;i<n;i++)
{
for(int j=i;j<n;j++)
{
int b[]=new int[n];
for(int k=0;k<n;k++)
b[k]=a[k];
for(int k=i;k<=j;k++)
b[k]=1-a[k];
int count=0;
for(int k=0;k<n;k++)
if(b[k]==1)
count++;
max=Math.max(max,count);
}
}
System.out.println(max);
}
}
|
Igor has fallen in love with Tanya. Now Igor wants to show his feelings and write a number on the fence opposite to Tanya's house. Igor thinks that the larger the number is, the more chance to win Tanya's heart he has.
Unfortunately, Igor could only get v liters of paint. He did the math and concluded that digit d requires ad liters of paint. Besides, Igor heard that Tanya doesn't like zeroes. That's why Igor won't use them in his number.
Help Igor find the maximum number he can write on the fence.
Input
The first line contains a positive integer v (0 ≤ v ≤ 106). The second line contains nine positive integers a1, a2, ..., a9 (1 ≤ ai ≤ 105).
Output
Print the maximum number Igor can write on the fence. If he has too little paint for any digit (so, he cannot write anything), print -1.
Examples
Input
5
5 4 3 2 1 2 3 4 5
Output
55555
Input
2
9 11 1 12 5 8 9 10 6
Output
33
Input
0
1 1 1 1 1 1 1 1 1
Output
-1
|
import java.util.*;
import java.io.*;
public class Main {
static BufferedReader reader
= new BufferedReader(new InputStreamReader(System.in));
static StringBuilder out = new StringBuilder();
public static void main(String[] args){
int ink = nextInt();
int[] cost = nextIntArrayFrom1(); // cost[i] is the cost of painting i
int cheapestDigit = 0;
int cheapestCost = (int) 1e6;
for (int i = 1; i <= 9; i++){
if (cost[i] <= cheapestCost){
cheapestCost = cost[i];
cheapestDigit = i;
}
}
if (ink < cheapestCost){
out.append(-1);
} else {
int len = ink / cheapestCost;
int[] ans = new int[len];
Arrays.fill(ans, cheapestDigit);
ink -= len * cheapestCost;
for (int i = 0; ink > 0 && i < ans.length; i++){
for (int candidate = 9; candidate > cheapestDigit; candidate --){
if (ink >= cost[candidate] - cheapestCost){
ink -= cost[candidate] - cheapestCost;
ans[i] = candidate;
break;
}
}
}
for (int i : ans) out.append(i);
}
System.out.println(out);
}
// the followings are methods to take care of inputs.
static int nextInt(){
return Integer.parseInt(nextLine());
}
static long nextLong(){
return Long.parseLong(nextLine());
}
static int[] nextIntArray(){
String[] inp = nextLine().split("\\s+");
int[] ary = new int[inp.length]; for (int i = 0; i < ary.length; i++){
ary[i] = Integer.parseInt(inp[i]);
}
return ary;
}
static int[] nextIntArrayFrom1(){
String[] inp = nextLine().split("\\s+");
int[] ary = new int[inp.length + 1];
for (int i = 0; i < inp.length; i++){
ary[i+1] = Integer.parseInt(inp[i]);
}
return ary;
}
static long[] nextLongArray(){
String[] inp = nextLine().split("\\s+");
long[] ary = new long[inp.length];
for (int i = 0; i < inp.length; i++){
ary[i] = Long.parseLong(inp[i]);
}
return ary;
}
static long[] nextLongArrayFrom1(){
String[] inp = nextLine().split("\\s+");
long[] ary = new long[inp.length + 1];
for (int i = 0; i < inp.length; i++){
ary[i+1] = Long.parseLong(inp[i]);
}
return ary;
}
static String nextLine(){
try {
return reader.readLine().trim();
} catch (Exception e){}
return null;
}
}
|
A festival will be held in a town's main street. There are n sections in the main street. The sections are numbered 1 through n from left to right. The distance between each adjacent sections is 1.
In the festival m fireworks will be launched. The i-th (1 ≤ i ≤ m) launching is on time ti at section ai. If you are at section x (1 ≤ x ≤ n) at the time of i-th launching, you'll gain happiness value bi - |ai - x| (note that the happiness value might be a negative value).
You can move up to d length units in a unit time interval, but it's prohibited to go out of the main street. Also you can be in an arbitrary section at initial time moment (time equals to 1), and want to maximize the sum of happiness that can be gained from watching fireworks. Find the maximum total happiness.
Note that two or more fireworks can be launched at the same time.
Input
The first line contains three integers n, m, d (1 ≤ n ≤ 150000; 1 ≤ m ≤ 300; 1 ≤ d ≤ n).
Each of the next m lines contains integers ai, bi, ti (1 ≤ ai ≤ n; 1 ≤ bi ≤ 109; 1 ≤ ti ≤ 109). The i-th line contains description of the i-th launching.
It is guaranteed that the condition ti ≤ ti + 1 (1 ≤ i < m) will be satisfied.
Output
Print a single integer — the maximum sum of happiness that you can gain from watching all the fireworks.
Please, do not write the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
50 3 1
49 1 1
26 1 4
6 1 10
Output
-31
Input
10 2 1
1 1000 4
9 1000 4
Output
1992
|
#include <bits/stdc++.h>
using namespace std;
int n, m, d, a[400], b[400], t[400], now, last, L, R, l, Q[150010];
long long dp[2][150010];
void f1(long long x) {
while (L <= R && Q[L] < x) L++;
}
void f3(int l) {
while (L <= R && dp[last][Q[R]] < dp[last][l]) R--;
Q[++R] = l;
}
void f2(long long y) {
while (l <= n && l <= y) f3(l), l++;
}
int main() {
scanf("%d%d%d", &n, &m, &d);
for (int i = 1; i <= m; i++) scanf("%d%d%d", &a[i], &b[i], &t[i]);
for (int i = 1; i <= m; i++) {
now ^= 1;
last = now ^ 1;
L = l = 1, R = 0;
for (int j = 1; j <= n; j++) {
long long k1 = j - 1ll * (t[i] - t[i - 1]) * d;
long long k2 = j + 1ll * (t[i] - t[i - 1]) * d;
f1(k1);
f2(k2);
dp[now][j] = dp[last][Q[L]] + b[i] - abs(a[i] - j);
}
}
long long ans = -10101010;
for (long long i = 1; i <= n; i++) ans = max(ans, dp[now][i]);
cout << ans << endl;
return 0;
}
|
Everyone knows what the Fibonacci sequence is. This sequence can be defined by the recurrence relation:
F1 = 1, F2 = 2, Fi = Fi - 1 + Fi - 2 (i > 2).
We'll define a new number sequence Ai(k) by the formula:
Ai(k) = Fi × ik (i ≥ 1).
In this problem, your task is to calculate the following sum: A1(k) + A2(k) + ... + An(k). The answer can be very large, so print it modulo 1000000007 (109 + 7).
Input
The first line contains two space-separated integers n, k (1 ≤ n ≤ 1017; 1 ≤ k ≤ 40).
Output
Print a single integer — the sum of the first n elements of the sequence Ai(k) modulo 1000000007 (109 + 7).
Examples
Input
1 1
Output
1
Input
4 1
Output
34
Input
5 2
Output
316
Input
7 4
Output
73825
|
#include <bits/stdc++.h>
using namespace std;
struct matrix {
long long m[90][90];
matrix() { memset(m, 0, sizeof m); }
long long *operator[](int i) { return m[i]; }
friend matrix operator*(const matrix &a, const matrix &b) {
matrix r;
for (int i = (0); i < (90); ++i)
for (int j = (0); j < (90); ++j)
for (int k = (0); k < (90); ++k)
r[i][j] =
(r[i][j] + ((long long)a.m[i][k]) * b.m[k][j]) % (int)(1e9 + 7);
return r;
}
};
matrix pow(matrix a, long long e) {
if (e == 1) return a;
if (e % 2) return a * pow(a, e - 1);
a = pow(a, e / 2);
return a * a;
}
long long n;
int k;
long long C[90][90];
int main() {
scanf("%I64d %d", &n, &k);
if (n == 1) {
printf("1\n");
return 0;
}
for (int i = 0; i <= k; ++i) {
C[i][0] = 1;
for (int j = 1; j <= i; ++j)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % (int)(1e9 + 7);
}
matrix a, b;
k++;
for (int i = 0; i < k; ++i) {
a[i][0] = 2;
a[i + k][0] = 1;
for (int j = 0; j < i; ++j) a[i][0] = (2L * a[i][0]) % (int)(1e9 + 7);
}
a[2 * k][0] = 1;
for (int i = 0; i < k; ++i) {
for (int j = 0; j <= i; ++j) {
b[i][j] = b[i][j + k] = C[i][j];
for (int d = 0; d < i - j; ++d)
b[i][j + k] = (2L * b[i][j + k]) % (int)(1e9 + 7);
}
b[i + k][i] = 1;
}
b[2 * k][k - 1] = 1;
b[2 * k][2 * k] = 1;
matrix ret = pow(b, n - 1) * a;
printf("%d\n", (int)ret[2 * k][0]);
return 0;
}
|
The finalists of the "Russian Code Cup" competition in 2214 will be the participants who win in one of the elimination rounds.
The elimination rounds are divided into main and additional. Each of the main elimination rounds consists of c problems, the winners of the round are the first n people in the rating list. Each of the additional elimination rounds consists of d problems. The winner of the additional round is one person. Besides, k winners of the past finals are invited to the finals without elimination.
As a result of all elimination rounds at least n·m people should go to the finals. You need to organize elimination rounds in such a way, that at least n·m people go to the finals, and the total amount of used problems in all rounds is as small as possible.
Input
The first line contains two integers c and d (1 ≤ c, d ≤ 100) — the number of problems in the main and additional rounds, correspondingly. The second line contains two integers n and m (1 ≤ n, m ≤ 100). Finally, the third line contains an integer k (1 ≤ k ≤ 100) — the number of the pre-chosen winners.
Output
In the first line, print a single integer — the minimum number of problems the jury needs to prepare.
Examples
Input
1 10
7 2
1
Output
2
Input
2 2
2 1
2
Output
0
|
import java.util.Scanner;
public class A {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int c=sc.nextInt(),d=sc.nextInt(), n=sc.nextInt(), m=sc.nextInt(), k=sc.nextInt();
if(((n*m)-k) <= 0) {
System.out.println(0);
return;
} else {
System.out.println(Math.min(c * (((n*m)-k)/n), d * (((n*m)-k)/n) * n) + Math.min(c, d * (((n*m)-k)%n)));
}
}
}
|
Andrey needs one more problem to conduct a programming contest. He has n friends who are always willing to help. He can ask some of them to come up with a contest problem. Andrey knows one value for each of his fiends — the probability that this friend will come up with a problem if Andrey asks him.
Help Andrey choose people to ask. As he needs only one problem, Andrey is going to be really upset if no one comes up with a problem or if he gets more than one problem from his friends. You need to choose such a set of people that maximizes the chances of Andrey not getting upset.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of Andrey's friends. The second line contains n real numbers pi (0.0 ≤ pi ≤ 1.0) — the probability that the i-th friend can come up with a problem. The probabilities are given with at most 6 digits after decimal point.
Output
Print a single real number — the probability that Andrey won't get upset at the optimal choice of friends. The answer will be considered valid if it differs from the correct one by at most 10 - 9.
Examples
Input
4
0.1 0.2 0.3 0.8
Output
0.800000000000
Input
2
0.1 0.2
Output
0.260000000000
Note
In the first sample the best strategy for Andrey is to ask only one of his friends, the most reliable one.
In the second sample the best strategy for Andrey is to ask all of his friends to come up with a problem. Then the probability that he will get exactly one problem is 0.1·0.8 + 0.9·0.2 = 0.26.
|
#include <bits/stdc++.h>
using namespace std;
vector<double> s;
int n;
double cal(int i) {
double res = 0;
for (int j = i; j < n; j++) {
double temp = 1;
for (int k = i; k < n; k++) {
if (k == j)
temp *= s[j];
else
temp *= (1 - s[k]);
}
res += temp;
}
return res;
}
int main() {
cin >> n;
double temp;
for (int i = 0; i < n; i++) {
cin >> temp;
s.push_back(temp);
}
sort(s.begin(), s.end());
double result = 0;
for (int i = n - 1; i >= 0; i--) {
if (cal(i) > result) result = cal(i);
}
cout.precision(12);
cout << fixed << result << endl;
}
|
Andrew and Eugene are playing a game. Initially, Andrew has string s, consisting of digits. Eugene sends Andrew multiple queries of type "di → ti", that means "replace all digits di in string s with substrings equal to ti". For example, if s = 123123, then query "2 → 00" transforms s to 10031003, and query "3 → " ("replace 3 by an empty string") transforms it to s = 1212. After all the queries Eugene asks Andrew to find the remainder after division of number with decimal representation equal to s by 1000000007 (109 + 7). When you represent s as a decimal number, please ignore the leading zeroes; also if s is an empty string, then it's assumed that the number equals to zero.
Andrew got tired of processing Eugene's requests manually and he asked you to write a program for that. Help him!
Input
The first line contains string s (1 ≤ |s| ≤ 105), consisting of digits — the string before processing all the requests.
The second line contains a single integer n (0 ≤ n ≤ 105) — the number of queries.
The next n lines contain the descriptions of the queries. The i-th query is described by string "di->ti", where di is exactly one digit (from 0 to 9), ti is a string consisting of digits (ti can be an empty string). The sum of lengths of ti for all queries doesn't exceed 105. The queries are written in the order in which they need to be performed.
Output
Print a single integer — remainder of division of the resulting number by 1000000007 (109 + 7).
Examples
Input
123123
1
2->00
Output
10031003
Input
123123
1
3->
Output
1212
Input
222
2
2->0
0->7
Output
777
Input
1000000008
0
Output
1
Note
Note that the leading zeroes are not removed from string s after the replacement (you can see it in the third sample).
|
MOD = 10**9+7
s = raw_input()
n = int(raw_input())
query = [['',s]]+[raw_input().split('->') for i in range(n)]
value = {}
pow10 = {}
for i in range(10):
value[str(i)] = i
pow10[str(i)] = 10
for i in range(n,-1,-1):
newValue = 0
newPow10 = 1
for d in query[i][1]:
newValue = (newValue*pow10[d] + value[d])%MOD
newPow10 = (newPow10 * pow10[d])%MOD
value[query[i][0]], pow10[query[i][0]] = (newValue, newPow10)
print value['']
|
Tomash keeps wandering off and getting lost while he is walking along the streets of Berland. It's no surprise! In his home town, for any pair of intersections there is exactly one way to walk from one intersection to the other one. The capital of Berland is very different!
Tomash has noticed that even simple cases of ambiguity confuse him. So, when he sees a group of four distinct intersections a, b, c and d, such that there are two paths from a to c — one through b and the other one through d, he calls the group a "damn rhombus". Note that pairs (a, b), (b, c), (a, d), (d, c) should be directly connected by the roads. Schematically, a damn rhombus is shown on the figure below:
<image>
Other roads between any of the intersections don't make the rhombus any more appealing to Tomash, so the four intersections remain a "damn rhombus" for him.
Given that the capital of Berland has n intersections and m roads and all roads are unidirectional and are known in advance, find the number of "damn rhombi" in the city.
When rhombi are compared, the order of intersections b and d doesn't matter.
Input
The first line of the input contains a pair of integers n, m (1 ≤ n ≤ 3000, 0 ≤ m ≤ 30000) — the number of intersections and roads, respectively. Next m lines list the roads, one per line. Each of the roads is given by a pair of integers ai, bi (1 ≤ ai, bi ≤ n;ai ≠ bi) — the number of the intersection it goes out from and the number of the intersection it leads to. Between a pair of intersections there is at most one road in each of the two directions.
It is not guaranteed that you can get from any intersection to any other one.
Output
Print the required number of "damn rhombi".
Examples
Input
5 4
1 2
2 3
1 4
4 3
Output
1
Input
4 12
1 2
1 3
1 4
2 1
2 3
2 4
3 1
3 2
3 4
4 1
4 2
4 3
Output
12
|
#include <bits/stdc++.h>
using namespace std;
vector<int long long> vis;
vector<vector<int long long> > a;
int long long ans = 0;
void dfs(int long long i, int long long step, int long long father) {
if (step == 2) {
vis[i]++;
if (vis[i] >= 2) ans += vis[i] - 1;
return;
}
for (long long j = 0; j < a[i].size(); j++) {
if (father != a[i][j]) dfs(a[i][j], step + 1, i);
}
}
int main() {
ios_base::sync_with_stdio(false);
;
int long long n, m, x, y;
cin >> n >> m;
a.resize(n);
vis.resize(n);
for (long long i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
a[x].push_back(y);
}
for (long long i = 0; i < n; i++) {
for (long long i = 0; i < n; i++) vis[i] = 0;
dfs(i, 0, -1);
}
cout << ans << endl;
}
|
You are given a permutation p of numbers 1, 2, ..., n. Let's define f(p) as the following sum:
<image>
Find the lexicographically m-th permutation of length n in the set of permutations having the maximum possible value of f(p).
Input
The single line of input contains two integers n and m (1 ≤ m ≤ cntn), where cntn is the number of permutations of length n with maximum possible value of f(p).
The problem consists of two subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem B1 (3 points), the constraint 1 ≤ n ≤ 8 will hold.
* In subproblem B2 (4 points), the constraint 1 ≤ n ≤ 50 will hold.
Output
Output n number forming the required permutation.
Examples
Input
2 2
Output
2 1
Input
3 2
Output
1 3 2
Note
In the first example, both permutations of numbers {1, 2} yield maximum possible f(p) which is equal to 4. Among them, (2, 1) comes second in lexicographical order.
|
n, m = map(int, input().split())
s = 1
c = n - 1
arr = [0] * n
i = 0
while i <= c:
r = 0
j = s
while j <= n and r < m:
if j < n:
r += 2 ** (n - j - 1)
j += 1
#print(s, j, r, m)
if j > s and j != n + 1:
r -= 2 ** (n - j)
m -= r
j -= 1
arr[i] = j
while s < j:
arr[c] = s
c -= 1
s += 1
s += 1
i += 1
for i in arr:
print(i, end = ' ')
|
Igor has been into chess for a long time and now he is sick of the game by the ordinary rules. He is going to think of new rules of the game and become world famous.
Igor's chessboard is a square of size n × n cells. Igor decided that simple rules guarantee success, that's why his game will have only one type of pieces. Besides, all pieces in his game are of the same color. The possible moves of a piece are described by a set of shift vectors. The next passage contains a formal description of available moves.
Let the rows of the board be numbered from top to bottom and the columns be numbered from left to right from 1 to n. Let's assign to each square a pair of integers (x, y) — the number of the corresponding column and row. Each of the possible moves of the piece is defined by a pair of integers (dx, dy); using this move, the piece moves from the field (x, y) to the field (x + dx, y + dy). You can perform the move if the cell (x + dx, y + dy) is within the boundaries of the board and doesn't contain another piece. Pieces that stand on the cells other than (x, y) and (x + dx, y + dy) are not important when considering the possibility of making the given move (for example, like when a knight moves in usual chess).
Igor offers you to find out what moves his chess piece can make. He placed several pieces on the board and for each unoccupied square he told you whether it is attacked by any present piece (i.e. whether some of the pieces on the field can move to that cell). Restore a possible set of shift vectors of the piece, or else determine that Igor has made a mistake and such situation is impossible for any set of shift vectors.
Input
The first line contains a single integer n (1 ≤ n ≤ 50).
The next n lines contain n characters each describing the position offered by Igor. The j-th character of the i-th string can have the following values:
* o — in this case the field (i, j) is occupied by a piece and the field may or may not be attacked by some other piece;
* x — in this case field (i, j) is attacked by some piece;
* . — in this case field (i, j) isn't attacked by any piece.
It is guaranteed that there is at least one piece on the board.
Output
If there is a valid set of moves, in the first line print a single word 'YES' (without the quotes). Next, print the description of the set of moves of a piece in the form of a (2n - 1) × (2n - 1) board, the center of the board has a piece and symbols 'x' mark cells that are attacked by it, in a format similar to the input. See examples of the output for a full understanding of the format. If there are several possible answers, print any of them.
If a valid set of moves does not exist, print a single word 'NO'.
Examples
Input
5
oxxxx
x...x
x...x
x...x
xxxxo
Output
YES
....x....
....x....
....x....
....x....
xxxxoxxxx
....x....
....x....
....x....
....x....
Input
6
.x.x..
x.x.x.
.xo..x
x..ox.
.x.x.x
..x.x.
Output
YES
...........
...........
...........
....x.x....
...x...x...
.....o.....
...x...x...
....x.x....
...........
...........
...........
Input
3
o.x
oxx
o.x
Output
NO
Note
In the first sample test the piece is a usual chess rook, and in the second sample test the piece is a usual chess knight.
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const int MOD = INF + 7;
const int MAXN = 51;
string s[MAXN];
bool val[MAXN][MAXN];
int main() {
int n;
while (cin >> n) {
vector<pair<int, int> > pieces;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < n; j++) {
if (s[i][j] == 'o') {
pieces.push_back(pair<int, int>(i, j));
}
}
}
set<pair<int, int> > moves;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (s[i][j] == 'x') {
for (pair<int, int> piece : pieces) {
moves.insert(pair<int, int>(i - piece.first, j - piece.second));
}
}
}
}
vector<pair<int, int> > valid;
memset(val, 0, sizeof val);
for (pair<int, int> move : moves) {
bool all = true;
for (pair<int, int> piece : pieces) {
int x = piece.first + move.first;
int y = piece.second + move.second;
if (x < 0 || y < 0 || x >= n || y >= n) continue;
all &= (s[x][y] != '.');
}
if (all) {
valid.push_back(move);
for (pair<int, int> piece : pieces) {
int x = piece.first + move.first;
int y = piece.second + move.second;
if (x < 0 || y < 0 || x >= n || y >= n) continue;
val[x][y] = 1;
}
}
}
bool sw = true;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (s[i][j] == 'x') {
sw &= val[i][j];
}
}
}
if (sw) {
cout << "YES" << endl;
vector<string> ans(2 * n - 1, string(2 * n - 1, '.'));
int x = n - 1, y = n - 1;
ans[x][y] = 'o';
for (pair<int, int> p : valid) {
ans[x + p.first][y + p.second] = 'x';
}
for (int i = 0; i < 2 * n - 1; i++) {
cout << ans[i] << endl;
}
} else {
cout << "NO" << endl;
}
}
return 0;
}
|
Archaeologists found some information about an ancient land of Treeland. We know for sure that the Treeland consisted of n cities connected by the n - 1 road, such that you can get from each city to any other one along the roads. However, the information about the specific design of roads in Treeland has been lost. The only thing that the archaeologists can use is the preserved information about near cities.
Two cities of Treeland were called near, if it were possible to move from one city to the other one by moving through at most two roads. Also, a city is considered near to itself. During the recent excavations archaeologists found a set of n notes, each of them represents a list of cities, near to some of the n cities of the country. However, unfortunately, none of the found records lets you understand in what order the cities go in the list and for which city in the list the near to it cities were listed.
Help the archaeologists and restore any variant of the map of Treeland that meets the found information.
Input
The first line contains integer n (2 ≤ n ≤ 1000) — the number of cities in the country.
Next n lines describe the found lists of near cities. Each list starts from number k (1 ≤ k ≤ n), representing the number of cities in the list followed by k city numbers. All numbers in each list are distinct.
It is guaranteed that the given information determines at least one possible road map.
Output
Print n - 1 pairs of numbers representing the roads of the country. The i-th line must contain two integers ai, bi (1 ≤ ai, bi ≤ n, ai ≠ bi), showing that there is a road between cities ai and bi.
The answer you print must satisfy the description of close cities from the input. You may print the roads of the countries in any order. The cities that are connected by a road may also be printed in any order.
If there are multiple good answers, you may print any of them.
Examples
Input
5
4 3 2 4 1
5 5 3 2 4 1
5 4 2 1 5 3
4 2 1 4 3
3 1 4 5
Output
1 4
1 2
1 3
4 5
Input
6
5 6 1 3 4 2
5 2 1 3 4 6
6 3 6 2 5 4 1
6 6 1 2 5 3 4
3 5 2 4
5 3 1 2 4 6
Output
2 4
1 2
2 3
2 6
4 5
|
#include <bits/stdc++.h>
using namespace std;
int N, M, V[1005];
bitset<1005> T, A[1005], E[1005], G[1005];
int IN() {
int x = 0, ch;
for (; (ch = getchar()) < '0' || ch > '9';)
;
for (; ch >= '0' && ch <= '9'; (ch = getchar())) (x *= 10) += ch - '0';
return x;
}
int main() {
N = IN();
for (int i = 1; i <= N; i++) {
int k = IN(), x;
for (; k--;) x = IN(), A[i][x] = 1;
}
for (int i = 1; i <= N; i++)
for (int j = i + 1; j <= N; j++) {
bitset<1005> t = A[i] & A[j];
if (t.count() == 2) {
int u, v;
for (u = 1; !t[u]; u++)
;
for (v = u + 1; !t[v]; v++)
;
if (!E[u][v]) E[u][v] = E[v][u] = 1, M++;
}
}
if (!M) {
for (int i = 2; i <= N; i++) printf("%d %d\n", 1, i);
return 0;
}
for (int i = 1; i <= N; i++)
if (E[i].count())
T[i] = 1, V[i] = (E[i].count() == 1), G[i] = E[i], G[i][i] = 1;
if (T.count() == 2) {
int u, v;
for (u = 1; !T[u]; u++)
;
for (v = N; !T[v]; v--)
;
printf("%d %d\n", u, v);
for (int i = 1; i <= N; i++)
if (!T[i]) {
bitset<1005> t;
for (int j = 1; j <= N; j++)
if (A[j][i] && A[j].count() != N) {
t = A[j];
break;
}
for (int j = 1; j <= N; j++)
if (t[j] && !T[j]) T[j] = 1, printf("%d %d\n", j, u);
u = v;
}
return 0;
}
for (int i = 1; i <= N; i++)
if (!T[i]) {
bitset<1005> t = T;
for (int j = 1; j <= N; j++)
if (A[j][i]) t &= A[j];
if (t.count() == 2) {
for (int j = 1; j <= N; j++)
if (t[j] && V[j]) E[i][j] = E[j][i] = 1;
} else {
for (int j = 1; j <= N; j++)
if (t[j] && ((G[j] & t) == t)) E[i][j] = E[j][i] = 1;
}
}
for (int i = 1; i <= N; i++)
for (int j = i + 1; j <= N; j++)
if (E[i][j]) printf("%d %d\n", i, j);
}
|
Duff is mad at her friends. That's why she sometimes makes Malek to take candy from one of her friends for no reason!
<image>
She has n friends. Her i-th friend's name is si (their names are not necessarily unique). q times, she asks Malek to take candy from her friends. She's angry, but also she acts with rules. When she wants to ask Malek to take candy from one of her friends, like k, she chooses two numbers l and r and tells Malek to take exactly <image> candies from him/her, where occur(t, s) is the number of occurrences of string t in s.
Malek is not able to calculate how many candies to take in each request from Duff. That's why she asked for your help. Please tell him how many candies to take in each request.
Input
The first line of input contains two integers n and q (1 ≤ n, q ≤ 105).
The next n lines contain the names. i-th of them contains an string si, consisting of lowercase English letters (<image>).
The next q lines contain the requests. Each of them contains three integers, l, r and k (says that Malek should take <image> candies from Duff's k-th friend).
Output
Print the answer to each request in one line.
Examples
Input
5 5
a
ab
abab
ababab
b
1 5 4
3 5 4
1 5 2
1 5 3
1 4 1
Output
12
6
3
7
1
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
template <typename T>
inline void read(T &AKNOI) {
T x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
AKNOI = flag * x;
}
char s[MAXN];
int n, q, sl[MAXN], sr[MAXN];
long long sum[MAXN], ans[MAXN];
struct Query {
int id, x, y;
Query() {}
Query(int _id, int _x, int _y) : id(_id), x(_x), y(_y) {}
};
vector<Query> q1[MAXN], q2[MAXN];
struct AC_Automaton {
int tot, ch[MAXN][26], fail[MAXN], edp[MAXN];
int q[MAXN], in[MAXN], out[MAXN], clk;
vector<int> e[MAXN];
void Insert(int id, int l, int r) {
int p = 0;
for (int i = l; i <= r; ++i) {
int x = (s[i] - 'a');
if (!ch[p][x]) {
ch[p][x] = ++tot;
}
p = ch[p][x];
}
edp[id] = p;
}
void FailTree(int u) {
in[u] = ++clk;
for (auto v : e[u]) {
FailTree(v);
}
out[u] = clk;
}
void GetFail() {
int head = 1, tail = 0;
for (int i = 0; i < 26; ++i) {
if (ch[0][i]) {
q[++tail] = ch[0][i];
}
}
while (head <= tail) {
int u = q[head++];
e[fail[u]].push_back(u);
for (int i = 0; i < 26; ++i) {
if (ch[u][i]) {
fail[ch[u][i]] = ch[fail[u]][i];
q[++tail] = ch[u][i];
} else {
ch[u][i] = ch[fail[u]][i];
}
}
}
FailTree(0);
}
} ac;
struct Block {
int siz, bcnt, L[MAXN], R[MAXN], bel[MAXN];
int a[MAXN], tag[MAXN];
void Build(int m) {
siz = sqrt(m);
for (int l = 1; l <= m; l += siz) {
int r = min(m, l + siz - 1);
L[++bcnt] = l;
R[bcnt] = r;
for (int i = l; i <= r; ++i) {
bel[i] = bcnt;
}
}
}
void Modify(int l, int r, int v) {
int bl = bel[l], br = bel[r];
if (bl == br) {
for (int i = l; i <= r; ++i) {
a[i] += v;
}
} else {
for (int i = l; i <= R[bl]; ++i) {
a[i] += v;
}
for (int i = bl + 1; i < br; ++i) {
tag[i] += v;
}
for (int i = L[br]; i <= r; ++i) {
a[i] += v;
}
}
}
int Query(int x) { return a[x] + tag[bel[x]]; }
} blk;
long long GetAns1(int x) {
int p = 0;
long long ret = 0;
for (int i = sl[x]; i <= sr[x]; ++i) {
p = ac.ch[p][s[i] - 'a'];
ret += blk.Query(ac.in[p]);
}
return ret;
}
void GetAns2(int x) {
memset(blk.a, 0, sizeof(blk.a));
memset(blk.tag, 0, sizeof(blk.tag));
int p = 0;
for (int i = sl[x]; i <= sr[x]; ++i) {
p = ac.ch[p][s[i] - 'a'];
blk.Modify(ac.in[p], ac.clk, 1);
}
for (int i = 1; i <= n; ++i) {
int u = ac.edp[i];
sum[i] = sum[i - 1] + blk.Query(ac.out[u]) - blk.Query(ac.in[u] - 1);
}
for (auto v : q2[x]) {
ans[v.id] = sum[v.y] - sum[v.x - 1];
}
}
void init() {
read(n);
read(q);
for (int i = 1; i <= n; ++i) {
sl[i] = sr[i - 1] + 1;
scanf("%s", s + sl[i]);
sr[i] = sr[i - 1] + strlen(s + sl[i]);
ac.Insert(i, sl[i], sr[i]);
}
ac.GetFail();
blk.Build(ac.clk);
for (int i = 1; i <= q; ++i) {
int l, r, k;
read(l);
read(r);
read(k);
if (sr[k] - sl[k] + 1 <= blk.siz) {
q1[l - 1].push_back(Query(i, k, -1));
q1[r].push_back(Query(i, k, 1));
} else {
q2[k].push_back(Query(i, l, r));
}
}
}
void solve() {
for (int i = 1; i <= n; ++i) {
int u = ac.edp[i];
blk.Modify(ac.in[u], ac.out[u], 1);
for (auto v : q1[i]) {
ans[v.id] += GetAns1(v.x) * v.y;
}
}
for (int i = 1; i <= n; ++i) {
if (sr[i] - sl[i] + 1 <= blk.siz) continue;
GetAns2(i);
}
for (int i = 1; i <= q; ++i) {
printf("%lld\n", ans[i]);
}
}
int main() {
init();
solve();
return 0;
}
|
The Cereal Guy's friend Serial Guy likes to watch soap operas. An episode is about to start, and he hasn't washed his plate yet. But he decided to at least put in under the tap to be filled with water. The plate can be represented by a parallelepiped k × n × m, that is, it has k layers (the first layer is the upper one), each of which is a rectangle n × m with empty squares ('.') and obstacles ('#'). The water can only be present in the empty squares. The tap is positioned above the square (x, y) of the first layer, it is guaranteed that this square is empty. Every minute a cubical unit of water falls into the plate. Find out in how many minutes the Serial Guy should unglue himself from the soap opera and turn the water off for it not to overfill the plate. That is, you should find the moment of time when the plate is absolutely full and is going to be overfilled in the next moment.
Note: the water fills all the area within reach (see sample 4). Water flows in each of the 6 directions, through faces of 1 × 1 × 1 cubes.
Input
The first line contains three numbers k, n, m (1 ≤ k, n, m ≤ 10) which are the sizes of the plate. Then follow k rectangles consisting of n lines each containing m characters '.' or '#', which represents the "layers" of the plate in the order from the top to the bottom. The rectangles are separated by empty lines (see the samples). The last line contains x and y (1 ≤ x ≤ n, 1 ≤ y ≤ m) which are the tap's coordinates. x is the number of the line and y is the number of the column. Lines of each layer are numbered from left to right by the integers from 1 to n, columns of each layer are numbered from top to bottom by the integers from 1 to m.
Output
The answer should contain a single number, showing in how many minutes the plate will be filled.
Examples
Input
1 1 1
.
1 1
Output
1
Input
2 1 1
.
#
1 1
Output
1
Input
2 2 2
.#
##
..
..
1 1
Output
5
Input
3 2 2
#.
##
#.
.#
..
..
1 2
Output
7
Input
3 3 3
.#.
###
##.
.##
###
##.
...
...
...
1 1
Output
13
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
string s[10][10];
int cnt = 0;
int dx[6] = {-1, 0, 0, 0, 0, 1};
int dy[6] = {0, 0, -1, 1, 0, 0};
int dz[6] = {0, 1, 0, 0, -1, 0};
void dfs(int x, int y, int z) {
s[z][x][y] = '#';
++cnt;
for (int i = 0; i < 6; ++i) {
int nx = x + dx[i], ny = y + dy[i], nz = z + dz[i];
if (nx >= 0 && nx < n && ny >= 0 && ny < m && nz >= 0 && nz < k &&
s[nz][nx][ny] == '.')
dfs(nx, ny, nz);
}
}
int main() {
cin >> k >> n >> m;
for (int i = 0; i < k; ++i)
for (int j = 0; j < n; ++j) cin >> s[i][j];
int x, y, z = 0;
cin >> x >> y;
--x, --y;
dfs(x, y, z);
cout << cnt;
cin >> n;
return 0;
}
|
Because of budget cuts one IT company established new non-financial reward system instead of bonuses.
Two kinds of actions are rewarded: fixing critical bugs and suggesting new interesting features. A man who fixed a critical bug gets "I fixed a critical bug" pennant on his table. A man who suggested a new interesting feature gets "I suggested a new feature" pennant on his table.
Because of the limited budget of the new reward system only 5 "I fixed a critical bug" pennants and 3 "I suggested a new feature" pennants were bought.
In order to use these pennants for a long time they were made challenge ones. When a man fixes a new critical bug one of the earlier awarded "I fixed a critical bug" pennants is passed on to his table. When a man suggests a new interesting feature one of the earlier awarded "I suggested a new feature" pennants is passed on to his table.
One man can have several pennants of one type and of course he can have pennants of both types on his table. There are n tables in the IT company. Find the number of ways to place the pennants on these tables given that each pennant is situated on one of the tables and each table is big enough to contain any number of pennants.
Input
The only line of the input contains one integer n (1 ≤ n ≤ 500) — the number of tables in the IT company.
Output
Output one integer — the amount of ways to place the pennants on n tables.
Examples
Input
2
Output
24
|
from functools import reduce
def c(n, m):
return 0 if n>m or n<0 else reduce(lambda a,b: a*b, range(m-n+1, m+1), 1)//reduce(lambda a,b: a*b, range(1,n+1), 1)
n = int(input())
print(sum([c(i, n)*c(i-1, 2) for i in range(1, 4)])*sum([c(i, n)*c(i-1, 4) for i in range(1, 6)]))
|
Limak is a little polar bear. He doesn't have many toys and thus he often plays with polynomials.
He considers a polynomial valid if its degree is n and its coefficients are integers not exceeding k by the absolute value. More formally:
Let a0, a1, ..., an denote the coefficients, so <image>. Then, a polynomial P(x) is valid if all the following conditions are satisfied:
* ai is integer for every i;
* |ai| ≤ k for every i;
* an ≠ 0.
Limak has recently got a valid polynomial P with coefficients a0, a1, a2, ..., an. He noticed that P(2) ≠ 0 and he wants to change it. He is going to change one coefficient to get a valid polynomial Q of degree n that Q(2) = 0. Count the number of ways to do so. You should count two ways as a distinct if coefficients of target polynoms differ.
Input
The first line contains two integers n and k (1 ≤ n ≤ 200 000, 1 ≤ k ≤ 109) — the degree of the polynomial and the limit for absolute values of coefficients.
The second line contains n + 1 integers a0, a1, ..., an (|ai| ≤ k, an ≠ 0) — describing a valid polynomial <image>. It's guaranteed that P(2) ≠ 0.
Output
Print the number of ways to change one coefficient to get a valid polynomial Q that Q(2) = 0.
Examples
Input
3 1000000000
10 -9 -3 5
Output
3
Input
3 12
10 -9 -3 5
Output
2
Input
2 20
14 -7 19
Output
0
Note
In the first sample, we are given a polynomial P(x) = 10 - 9x - 3x2 + 5x3.
Limak can change one coefficient in three ways:
1. He can set a0 = - 10. Then he would get Q(x) = - 10 - 9x - 3x2 + 5x3 and indeed Q(2) = - 10 - 18 - 12 + 40 = 0.
2. Or he can set a2 = - 8. Then Q(x) = 10 - 9x - 8x2 + 5x3 and indeed Q(2) = 10 - 18 - 32 + 40 = 0.
3. Or he can set a1 = - 19. Then Q(x) = 10 - 19x - 3x2 + 5x3 and indeed Q(2) = 10 - 38 - 12 + 40 = 0.
In the second sample, we are given the same polynomial. This time though, k is equal to 12 instead of 109. Two first of ways listed above are still valid but in the third way we would get |a1| > k what is not allowed. Thus, the answer is 2 this time.
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, tot, num, now, a[200001], f[200001];
int main() {
cin.sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i <= n; i++) cin >> a[i];
now = -1;
for (int i = 0; i <= n; i++) {
f[i] += a[i];
if (i != n) {
f[i + 1] += f[i] / 2;
f[i] %= 2;
}
if (now == -1 && f[i] != 0) now = i;
}
for (int i = n; i >= 0; i--) {
tot *= 2;
tot += f[i];
if (tot > 2147483647 || tot < -2147483647) break;
if (i <= now) {
long long ans = tot - a[i];
if (ans <= k && ans >= -k && !(i == n && ans == 0)) num++;
}
}
cout << num << endl;
}
|
Codeforces user' handle color depends on his rating — it is red if his rating is greater or equal to 2400; it is orange if his rating is less than 2400 but greater or equal to 2200, etc. Each time participant takes part in a rated contest, his rating is changed depending on his performance.
Anton wants the color of his handle to become red. He considers his performance in the rated contest to be good if he outscored some participant, whose handle was colored red before the contest and his rating has increased after it.
Anton has written a program that analyses contest results and determines whether he performed good or not. Are you able to do the same?
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100) — the number of participants Anton has outscored in this contest .
The next n lines describe participants results: the i-th of them consists of a participant handle namei and two integers beforei and afteri ( - 4000 ≤ beforei, afteri ≤ 4000) — participant's rating before and after the contest, respectively. Each handle is a non-empty string, consisting of no more than 10 characters, which might be lowercase and uppercase English letters, digits, characters «_» and «-» characters.
It is guaranteed that all handles are distinct.
Output
Print «YES» (quotes for clarity), if Anton has performed good in the contest and «NO» (quotes for clarity) otherwise.
Examples
Input
3
Burunduk1 2526 2537
BudAlNik 2084 2214
subscriber 2833 2749
Output
YES
Input
3
Applejack 2400 2400
Fluttershy 2390 2431
Pinkie_Pie -2500 -2450
Output
NO
Note
In the first sample, Anton has outscored user with handle Burunduk1, whose handle was colored red before the contest and his rating has increased after the contest.
In the second sample, Applejack's rating has not increased after the contest, while both Fluttershy's and Pinkie_Pie's handles were not colored red before the contest.
|
#!/usr/bin/env python3
if __name__ == '__main__':
n = int(input())
for _ in range(n):
handle, prev, curr = input().split()
prev = int(prev)
curr = int(curr)
if prev < 2400:
continue
if curr > prev:
print('YES')
break
else: # for ... else
print('NO')
|
After playing with her beautiful array, Mishka decided to learn some math. After learning how to multiply, divide and what is divisibility, she is now interested in solving the following problem.
You are given integer k and array a1, a2, ..., an of n integers. You are to find non-empty subsequence of array elements such that the product of its elements is divisible by k and it contains minimum possible number of elements.
Formally, you are to find a sequence of indices 1 ≤ i1 < i2 < ... < im ≤ n such that <image> is divisible by k while m is minimum possible among all such variants.
If there are more than one such subsequences, you should choose one among them, such that sum of its elements is minimum possible.
Mishka quickly solved this problem. Will you do so?
Input
The first line of the input contains two integers n and k (1 ≤ n ≤ 1 000, 1 ≤ k ≤ 1012).
The second line of the input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1012) — array elements.
Output
Print single positive integer m in the first line — the number of elements in desired sequence.
In the second line print m distinct integers — the sequence of indices of given array elements, which should be taken into the desired sequence.
If there are more than one such subsequence (e.g. subsequence of minimum possible number of elements and with minimum possible sum of elements), you can print any of them.
If there are no such subsequences, print - 1 in the only line.
Example
Input
5 60
2 4 6 5 2
Output
3
4 3 1
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005, MAXD = 1e4 + 10;
int n, dp[MAXN][MAXD];
long long sum[MAXN][MAXD];
vector<long long> d, p;
long long k, a[MAXN];
int prv[MAXN][MAXD];
long long GCD(long long a, long long b) { return !a ? b : GCD(b % a, a); }
int getind(long long val) {
return lower_bound(d.begin(), d.end(), val) - d.begin();
}
int main() {
cin >> n >> k;
if (k == 1) {
int ind = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] < a[ind]) ind = i;
}
cout << 1 << '\n' << ind + 1;
return 0;
}
for (long long i = 1; i * i <= k; i++) {
if (k % i == 0) {
d.push_back(i);
if (k / i != i) d.push_back(k / i);
}
}
long long tmp = k;
for (long long i = 2; i * i <= tmp; i++) {
if (tmp % i == 0) p.push_back(i);
while (tmp % i == 0) tmp /= i;
}
if (tmp != 1) p.push_back(tmp);
sort(d.begin(), d.end());
fill_n(dp[0], MAXD, 1e9);
dp[0][0] = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
long long g = GCD(a[i], k);
for (int j = 0; j < d.size(); j++)
dp[i][j] = dp[i - 1][j], sum[i][j] = sum[i - 1][j];
for (int j = 0; j < d.size(); j++) {
int t = getind(GCD(k / g, d[j]) * g);
if (dp[i][t] > dp[i - 1][j] + 1)
prv[i][t] = j + 1, dp[i][t] = dp[i - 1][j] + 1,
sum[i][t] = sum[i - 1][j] + a[i];
if (dp[i][t] == dp[i - 1][j] + 1 && sum[i - 1][j] + a[i] < sum[i][t])
prv[i][t] = j + 1, sum[i][t] = sum[i - 1][j] + a[i];
}
}
if (dp[n][d.size() - 1] == 1e9)
cout << -1;
else {
cout << dp[n][d.size() - 1] << '\n';
int t = d.size() - 1, lv = n;
while (lv != 0) {
if (prv[lv][t] > 0) cout << lv << ' ', t = prv[lv][t] - 1;
lv--;
}
}
}
|
Alfred wants to buy a toy moose that costs c dollars. The store doesn’t give change, so he must give the store exactly c dollars, no more and no less. He has n coins. To make c dollars from his coins, he follows the following algorithm: let S be the set of coins being used. S is initially empty. Alfred repeatedly adds to S the highest-valued coin he has such that the total value of the coins in S after adding the coin doesn’t exceed c. If there is no such coin, and the value of the coins in S is still less than c, he gives up and goes home. Note that Alfred never removes a coin from S after adding it.
As a programmer, you might be aware that Alfred’s algorithm can fail even when there is a set of coins with value exactly c. For example, if Alfred has one coin worth $3, one coin worth $4, and two coins worth $5, and the moose costs $12, then Alfred will add both of the $5 coins to S and then give up, since adding any other coin would cause the value of the coins in S to exceed $12. Of course, Alfred could instead combine one $3 coin, one $4 coin, and one $5 coin to reach the total.
Bob tried to convince Alfred that his algorithm was flawed, but Alfred didn’t believe him. Now Bob wants to give Alfred some coins (in addition to those that Alfred already has) such that Alfred’s algorithm fails. Bob can give Alfred any number of coins of any denomination (subject to the constraint that each coin must be worth a positive integer number of dollars). There can be multiple coins of a single denomination. He would like to minimize the total value of the coins he gives Alfred. Please find this minimum value. If there is no solution, print "Greed is good". You can assume that the answer, if it exists, is positive. In other words, Alfred's algorithm will work if Bob doesn't give him any coins.
Input
The first line contains c (1 ≤ c ≤ 200 000) — the price Alfred wants to pay. The second line contains n (1 ≤ n ≤ 200 000) — the number of coins Alfred initially has. Then n lines follow, each containing a single integer x (1 ≤ x ≤ c) representing the value of one of Alfred's coins.
Output
If there is a solution, print the minimum possible total value of the coins in a solution. Otherwise, print "Greed is good" (without quotes).
Examples
Input
12
3
5
3
4
Output
5
Input
50
8
1
2
4
8
16
37
37
37
Output
Greed is good
Note
In the first sample, Bob should give Alfred a single coin worth $5. This creates the situation described in the problem statement.
In the second sample, there is no set of coins that will cause Alfred's algorithm to fail.
|
#include <bits/stdc++.h>
using namespace std;
int a[200005];
int main() {
int n, m, x, f;
set<int> v;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d", &x);
a[x]++;
}
for (int i = 0; i <= n; i++) {
if (a[i]) v.insert(i);
}
for (int i = 1; i < n; i++) {
x = n, f = n;
if (!a[i]) v.insert(i);
a[i]++;
while (x) {
set<int>::iterator p = v.upper_bound(f);
if (p == v.begin()) break;
p--;
int y = (*p);
x -= min(x / y, a[y]) * y;
f = min(y - 1, x);
}
if (x) {
printf("%d\n", i);
return 0;
}
if (!(--a[i])) v.erase(i);
}
printf("Greed is good\n");
}
|
A rare article in the Internet is posted without a possibility to comment it. On a Polycarp's website each article has comments feed.
Each comment on Polycarp's website is a non-empty string consisting of uppercase and lowercase letters of English alphabet. Comments have tree-like structure, that means each comment except root comments (comments of the highest level) has exactly one parent comment.
When Polycarp wants to save comments to his hard drive he uses the following format. Each comment he writes in the following format:
* at first, the text of the comment is written;
* after that the number of comments is written, for which this comment is a parent comment (i. e. the number of the replies to this comments);
* after that the comments for which this comment is a parent comment are written (the writing of these comments uses the same algorithm).
All elements in this format are separated by single comma. Similarly, the comments of the first level are separated by comma.
For example, if the comments look like:
<image>
then the first comment is written as "hello,2,ok,0,bye,0", the second is written as "test,0", the third comment is written as "one,1,two,2,a,0,b,0". The whole comments feed is written as: "hello,2,ok,0,bye,0,test,0,one,1,two,2,a,0,b,0". For a given comments feed in the format specified above print the comments in a different format:
* at first, print a integer d — the maximum depth of nesting comments;
* after that print d lines, the i-th of them corresponds to nesting level i;
* for the i-th row print comments of nesting level i in the order of their appearance in the Policarp's comments feed, separated by space.
Input
The first line contains non-empty comments feed in the described format. It consists of uppercase and lowercase letters of English alphabet, digits and commas.
It is guaranteed that each comment is a non-empty string consisting of uppercase and lowercase English characters. Each of the number of comments is integer (consisting of at least one digit), and either equals 0 or does not contain leading zeros.
The length of the whole string does not exceed 106. It is guaranteed that given structure of comments is valid.
Output
Print comments in a format that is given in the statement. For each level of nesting, comments should be printed in the order they are given in the input.
Examples
Input
hello,2,ok,0,bye,0,test,0,one,1,two,2,a,0,b,0
Output
3
hello test one
ok bye two
a b
Input
a,5,A,0,a,0,A,0,a,0,A,0
Output
2
a
A a A a A
Input
A,3,B,2,C,0,D,1,E,0,F,1,G,0,H,1,I,1,J,0,K,1,L,0,M,2,N,0,O,1,P,0
Output
4
A K M
B F H L N O
C D G I P
E J
Note
The first example is explained in the statements.
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
import java.io.BufferedReader;
import java.util.LinkedList;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
MyBufferedReader in = new MyBufferedReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskE solver = new TaskE();
solver.solve(1, in, out);
out.close();
}
static class TaskE {
public void solve(int testNumber, MyBufferedReader in, PrintWriter out) {
String s = in.readLine();
int pos = 0;
List<TaskE.Node> roots = new LinkedList<>();
while (pos < s.length()) {
Stack<TaskE.Node> stack = new Stack<>();
TaskE.Node root = parseString(pos, s);
pos = root.nextPos;
roots.add(root);
stack.add(root);
while (!stack.isEmpty()) {
while (!stack.isEmpty() && stack.peek().children.size() == stack.peek()
.numExpected) {
TaskE.Node done = stack.pop();
if (!stack.isEmpty()) {
stack.peek().children.add(done);
}
}
if (stack.isEmpty()) {
break;
}
if (pos < s.length()) {
TaskE.Node newNode = parseString(pos, s);
pos = newNode.nextPos;
stack.add(newNode);
}
}
}
int maxLevel = 0;
for (TaskE.Node root : roots) {
maxLevel = Math.max(maxLevel, dfs(root, 1));
}
out.println(maxLevel);
List<TaskE.Node> currLevel = roots;
while (currLevel.size() > 0) {
List<TaskE.Node> nextLevel = new LinkedList<>();
for (TaskE.Node n : currLevel) {
out.print(n.c + " ");
nextLevel.addAll(n.children);
}
currLevel = nextLevel;
}
}
private TaskE.Node parseString(int pos, String s) {
int curr = pos;
StringBuilder sb = new StringBuilder();
while (curr < s.length() && s.charAt(curr) != ',') {
sb.append(s.charAt(curr));
curr++;
}
curr++;
StringBuilder nb = new StringBuilder();
while (curr < s.length() && s.charAt(curr) != ',') {
nb.append(s.charAt(curr));
curr++;
}
int num = Integer.parseInt(nb.toString());
return new TaskE.Node(sb.toString(), num, Math.min(curr + 1, s.length()));
}
private int dfs(TaskE.Node curr, int level) {
if (curr.numExpected == 0) {
return level;
}
int res = 0;
for (TaskE.Node child : curr.children) {
res = Math.max(res, dfs(child, level + 1));
}
return res;
}
static class Node {
List<TaskE.Node> children;
String c;
int numExpected;
int nextPos;
public Node(String c, int numExpected, int nextPos) {
this.c = c;
this.numExpected = numExpected;
this.nextPos = nextPos;
children = new ArrayList<>();
}
}
}
static class MyBufferedReader {
BufferedReader in;
public MyBufferedReader(InputStream s) {
this.in = new BufferedReader(new InputStreamReader(s));
}
public String readLine() {
String res = null;
try {
res = in.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return res;
}
}
}
|
Anton has the integer x. He is interested what positive integer, which doesn't exceed x, has the maximum sum of digits.
Your task is to help Anton and to find the integer that interests him. If there are several such integers, determine the biggest of them.
Input
The first line contains the positive integer x (1 ≤ x ≤ 1018) — the integer which Anton has.
Output
Print the positive integer which doesn't exceed x and has the maximum sum of digits. If there are several such integers, print the biggest of them. Printed integer must not contain leading zeros.
Examples
Input
100
Output
99
Input
48
Output
48
Input
521
Output
499
|
#include <bits/stdc++.h>
using namespace std;
long long int digits[20];
long long int digitsclone[20];
int dc = 0;
long long int arrofarr[20][20];
int main() {
long long int input;
cin >> input;
if (input < 10) {
cout << input;
return 0;
}
while (input != 0) {
digits[dc] = input % 10;
digitsclone[dc] = digits[dc];
input = input / 10;
dc++;
}
reverse(digits, digits + dc);
reverse(digitsclone, digitsclone + dc);
for (int k = 0; k < dc; k++) {
if (k == dc - 1) {
for (int i = 0; i < dc; i++) {
arrofarr[dc - 1][i] = digits[i];
}
break;
}
for (int m = 0; m < dc; m++) {
digitsclone[m] = digits[m];
}
if (digitsclone[k] == 0) {
continue;
} else {
digitsclone[k]--;
for (int j = k + 1; j < dc; j++) {
digitsclone[j] = 9;
}
}
for (int m = 0; m < dc; m++) {
arrofarr[k][m] = digitsclone[m];
}
}
long long int sum[20] = {0};
int sumd[20] = {0};
long long int s = 1;
for (int i = 0; i < dc; i++) {
reverse(arrofarr[i], arrofarr[i] + dc);
for (int k = 0; k < dc; k++) {
sum[i] = sum[i] + arrofarr[i][k] * s;
sumd[i] = sumd[i] + arrofarr[i][k];
s *= 10;
}
s = 1;
}
long long maxs = sum[0];
int max = sumd[0];
for (int i = 1; i < dc; i++) {
if (sumd[i] > max) {
max = sumd[i];
maxs = sum[i];
}
if (sumd[i] == max && sum[i] > maxs) {
max = sumd[i];
maxs = sum[i];
}
}
cout << maxs;
return 0;
}
|
Oleg the bank client and Igor the analyst are arguing again. This time, they want to pick a gift as a present for their friend, ZS the coder. After a long thought, they decided that their friend loves to eat carrots the most and thus they want to pick the best carrot as their present.
There are n carrots arranged in a line. The i-th carrot from the left has juiciness ai. Oleg thinks ZS loves juicy carrots whereas Igor thinks that he hates juicy carrots. Thus, Oleg would like to maximize the juiciness of the carrot they choose while Igor would like to minimize the juiciness of the carrot they choose.
To settle this issue, they decided to play a game again. Oleg and Igor take turns to play the game. In each turn, a player can choose a carrot from either end of the line, and eat it. The game ends when only one carrot remains. Oleg moves first. The last remaining carrot will be the carrot that they will give their friend, ZS.
Oleg is a sneaky bank client. When Igor goes to a restroom, he performs k moves before the start of the game. Each move is the same as above (eat a carrot from either end of the line). After Igor returns, they start the game with Oleg still going first.
Oleg wonders: for each k such that 0 ≤ k ≤ n - 1, what is the juiciness of the carrot they will give to ZS if he makes k extra moves beforehand and both players play optimally?
Input
The first line of input contains a single integer n (1 ≤ n ≤ 3·105) — the total number of carrots.
The next line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109). Here ai denotes the juiciness of the i-th carrot from the left of the line.
Output
Output n space-separated integers x0, x1, ..., xn - 1. Here, xi denotes the juiciness of the carrot the friends will present to ZS if k = i.
Examples
Input
4
1 2 3 5
Output
3 3 5 5
Input
5
1000000000 1000000000 1000000000 1000000000 1
Output
1000000000 1000000000 1000000000 1000000000 1000000000
Note
For the first example,
When k = 0, one possible optimal game is as follows:
* Oleg eats the carrot with juiciness 1.
* Igor eats the carrot with juiciness 5.
* Oleg eats the carrot with juiciness 2.
* The remaining carrot has juiciness 3.
When k = 1, one possible optimal play is as follows:
* Oleg eats the carrot with juiciness 1 beforehand.
* Oleg eats the carrot with juiciness 2.
* Igor eats the carrot with juiciness 5.
* The remaining carrot has juiciness 3.
When k = 2, one possible optimal play is as follows:
* Oleg eats the carrot with juiciness 1 beforehand.
* Oleg eats the carrot with juiciness 2 beforehand.
* Oleg eats the carrot with juiciness 3.
* The remaining carrot has juiciness 5.
When k = 3, one possible optimal play is as follows:
* Oleg eats the carrot with juiciness 1 beforehand.
* Oleg eats the carrot with juiciness 2 beforehand.
* Oleg eats the carrot with juiciness 3 beforehand.
* The remaining carrot has juiciness 5.
Thus, the answer is 3, 3, 5, 5.
For the second sample, Oleg can always eat the carrot with juiciness 1 since he always moves first. So, the remaining carrot will always have juiciness 1000000000.
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3 * 1e5 + 10;
int max(int a, int b) {
if (a > b) return a;
return b;
}
int min(int a, int b) {
if (a < b) return a;
return b;
}
int a[MAXN] = {0};
int b[MAXN] = {0};
int c[MAXN] = {0};
int main() {
int n;
cin >> n;
int maxi = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
maxi = max(maxi, a[i]);
}
for (int i = 2; i < n; ++i) b[i] = min(max(a[i - 1], a[i + 1]), a[i]);
for (int i = 1; i < n; ++i) c[i] = max(a[i], a[i + 1]);
int solb = 0;
int solc = 0;
for (int k = 0; k < n - 1; ++k) {
if ((n - k) % 2 == 1) {
solb = max(solb, max(b[(1 + n - k) / 2], b[(k + 1 + n) / 2]));
cout << solb << " ";
} else {
solc = max(solc, max(c[(1 + n - k) / 2], c[(k + 1 + n) / 2]));
cout << solc << " ";
}
}
cout << maxi << endl;
return 0;
}
|
Karen just got home from the supermarket, and is getting ready to go to sleep.
<image>
After taking a shower and changing into her pajamas, she looked at her shelf and saw an album. Curious, she opened it and saw a trading card collection.
She recalled that she used to play with those cards as a child, and, although she is now grown-up, she still wonders a few things about it.
Each card has three characteristics: strength, defense and speed. The values of all characteristics of all cards are positive integers. The maximum possible strength any card can have is p, the maximum possible defense is q and the maximum possible speed is r.
There are n cards in her collection. The i-th card has a strength ai, defense bi and speed ci, respectively.
A card beats another card if at least two of its characteristics are strictly greater than the corresponding characteristics of the other card.
She now wonders how many different cards can beat all the cards in her collection. Two cards are considered different if at least one of their characteristics have different values.
Input
The first line of input contains four integers, n, p, q and r (1 ≤ n, p, q, r ≤ 500000), the number of cards in the collection, the maximum possible strength, the maximum possible defense, and the maximum possible speed, respectively.
The next n lines each contain three integers. In particular, the i-th line contains ai, bi and ci (1 ≤ ai ≤ p, 1 ≤ bi ≤ q, 1 ≤ ci ≤ r), the strength, defense and speed of the i-th collection card, respectively.
Output
Output a single integer on a line by itself, the number of different cards that can beat all the cards in her collection.
Examples
Input
3 4 4 5
2 2 5
1 3 4
4 1 1
Output
10
Input
5 10 10 10
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
Output
972
Note
In the first test case, the maximum possible strength is 4, the maximum possible defense is 4 and the maximum possible speed is 5. Karen has three cards:
* The first card has strength 2, defense 2 and speed 5.
* The second card has strength 1, defense 3 and speed 4.
* The third card has strength 4, defense 1 and speed 1.
There are 10 cards that beat all the cards here:
1. The card with strength 3, defense 3 and speed 5.
2. The card with strength 3, defense 4 and speed 2.
3. The card with strength 3, defense 4 and speed 3.
4. The card with strength 3, defense 4 and speed 4.
5. The card with strength 3, defense 4 and speed 5.
6. The card with strength 4, defense 3 and speed 5.
7. The card with strength 4, defense 4 and speed 2.
8. The card with strength 4, defense 4 and speed 3.
9. The card with strength 4, defense 4 and speed 4.
10. The card with strength 4, defense 4 and speed 5.
In the second test case, the maximum possible strength is 10, the maximum possible defense is 10 and the maximum possible speed is 10. Karen has five cards, all with strength 1, defense 1 and speed 1.
Any of the 972 cards which have at least two characteristics greater than 1 can beat all of the cards in her collection.
|
#include <bits/stdc++.h>
using namespace std;
struct pt {
int x, y, z;
bool operator<(const pt t) const { return z > t.z; }
} P[500050];
int N, X, Y, Z;
map<long long, long long> con;
long long cnt;
void upd(long long x, long long y) {
auto I = con.lower_bound(x);
if (y <= I->second) return;
long long last = I->second;
con[x] = y;
I = con.find(x);
while (I != con.begin()) {
I--;
if (I->second <= y) {
cnt -= (x - I->first) * (I->second - last);
last = I->second;
I = con.erase(I);
} else {
cnt -= (x - I->first) * (y - last);
break;
}
}
}
int main() {
scanf("%d %d %d %d", &N, &X, &Y, &Z);
for (int i = 0; i < N; i++) {
scanf("%d %d %d", &P[i].x, &P[i].y, &P[i].z);
}
sort(P, P + N);
long long up = Z, ans = 0;
cnt = (long long)X * Y;
con[0] = Y + 1;
con[X + 1] = 0;
for (int i = 0; i < N; i++) upd(P[i].x, P[i].y);
for (int i = 0; i < N; i++) {
ans += (up - P[i].z) * cnt;
upd(P[i].x, Y);
upd(X, P[i].y);
up = P[i].z;
}
ans += up * cnt;
printf("%lld\n", ans);
return 0;
}
|
Once, Leha found in the left pocket an array consisting of n integers, and in the right pocket q queries of the form l r k. If there are queries, then they must be answered. Answer for the query is minimal x such that x occurs in the interval l r strictly more than <image> times or - 1 if there is no such number. Help Leha with such a difficult task.
Input
First line of input data contains two integers n and q (1 ≤ n, q ≤ 3·105) — number of elements in the array and number of queries respectively.
Next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ n) — Leha's array.
Each of next q lines contains three integers l, r and k (1 ≤ l ≤ r ≤ n, 2 ≤ k ≤ 5) — description of the queries.
Output
Output answer for each query in new line.
Examples
Input
4 2
1 1 2 2
1 3 2
1 4 2
Output
1
-1
Input
5 3
1 2 1 3 2
2 5 3
1 2 3
5 5 2
Output
2
1
2
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300000 + 77, SQ = 547;
int n, q, a[N], Ql[N], Qr[N], Qk[N], P[N], A[N], T[N];
mt19937 rng;
bool CMP(int x, int y) {
if (Ql[x] / SQ < Ql[y] / SQ) {
return 0;
}
if (Ql[x] / SQ > Ql[y] / SQ) {
return 1;
}
return Qr[x] < Qr[y];
}
int Random(int l, int r) { return l + (rng() % (r - l + 1)); }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
rng.seed(time(0));
cin >> n >> q;
iota(P + 1, P + 1 + q, 1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= q; i++) {
cin >> Ql[i] >> Qr[i] >> Qk[i];
}
sort(P + 1, P + 1 + q, CMP);
int l = 1, r = 1;
T[a[1]]++;
for (int i = 1; i <= q; i++) {
int id = P[i];
int ql = Ql[id], qr = Qr[id], k = Qk[id];
while (ql < l) {
l--;
T[a[l]]++;
}
while (r < qr) {
r++;
T[a[r]]++;
}
while (l < ql) {
T[a[l]]--;
l++;
}
while (qr < r) {
T[a[r]]--;
r--;
}
A[id] = N - 1;
for (int j = 1; j < 150; j++) {
int rnd = a[Random(l, r)];
if (T[rnd] > (r - l + 1) / k) {
A[id] = min(A[id], rnd);
}
}
if (A[id] > n) {
A[id] = -1;
}
}
for (int i = 1; i <= q; i++) {
cout << A[i] << '\n';
}
return 0;
}
|
Arkady words in a large company. There are n employees working in a system of a strict hierarchy. Namely, each employee, with an exception of the CEO, has exactly one immediate manager. The CEO is a manager (through a chain of immediate managers) of all employees.
Each employee has an integer rank. The CEO has rank equal to 1, each other employee has rank equal to the rank of his immediate manager plus 1.
Arkady has a good post in the company, however, he feels that he is nobody in the company's structure, and there are a lot of people who can replace him. He introduced the value of replaceability. Consider an employee a and an employee b, the latter being manager of a (not necessarily immediate). Then the replaceability r(a, b) of a with respect to b is the number of subordinates (not necessarily immediate) of the manager b, whose rank is not greater than the rank of a. Apart from replaceability, Arkady introduced the value of negligibility. The negligibility za of employee a equals the sum of his replaceabilities with respect to all his managers, i.e. <image>, where the sum is taken over all his managers b.
Arkady is interested not only in negligibility of himself, but also in negligibility of all employees in the company. Find the negligibility of each employee for Arkady.
Input
The first line contains single integer n (1 ≤ n ≤ 5·105) — the number of employees in the company.
The second line contains n integers p1, p2, ..., pn (0 ≤ pi ≤ n), where pi = 0 if the i-th employee is the CEO, otherwise pi equals the id of the immediate manager of the employee with id i. The employees are numbered from 1 to n. It is guaranteed that there is exactly one 0 among these values, and also that the CEO is a manager (not necessarily immediate) for all the other employees.
Output
Print n integers — the negligibilities of all employees in the order of their ids: z1, z2, ..., zn.
Examples
Input
4
0 1 2 1
Output
0 2 4 2
Input
5
2 3 4 5 0
Output
10 6 3 1 0
Input
5
0 1 1 1 3
Output
0 3 3 3 5
Note
Consider the first example:
* The CEO has no managers, thus z1 = 0.
* r(2, 1) = 2 (employees 2 and 4 suit the conditions, employee 3 has too large rank). Thus z2 = r(2, 1) = 2.
* Similarly, z4 = r(4, 1) = 2.
* r(3, 2) = 1 (employee 3 is a subordinate of 2 and has suitable rank). r(3, 1) = 3 (employees 2, 3, 4 suit the conditions). Thus z3 = r(3, 2) + r(3, 1) = 4.
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, next;
} e[1000005];
int head[1000005], dep[1000005], fa[1000005];
int top[1000005], sz[1000005], pos[1000005];
long long ans[1000005], s1[1000005], s2[1000005];
vector<int> v[1000005];
int tot, rt, n, T;
void adde(int x, int y) {
e[++tot] = (edge){y, head[x]};
head[x] = tot;
}
void dfs(int x) {
v[dep[x]].push_back(x);
sz[x] = 1;
for (int i = head[x]; i; i = e[i].next) {
fa[e[i].to] = x;
dep[e[i].to] = dep[x] + 1;
dfs(e[i].to);
sz[x] += sz[e[i].to];
}
}
void dfs2(int x, int tp) {
pos[x] = ++T;
top[x] = tp;
int k = 0;
for (int i = head[x]; i; i = e[i].next)
if (sz[e[i].to] > sz[k]) k = e[i].to;
if (k) dfs2(k, tp);
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != k) dfs2(e[i].to, e[i].to);
}
void add(int x, int v) {
for (int k = x; x <= n; x += x & (-x)) s1[x] += v, s2[x] += k * v;
}
long long sum(int x) {
long long ans = 0;
for (int k = x; k; k -= k & (-k)) ans += s1[k];
ans *= (x + 1);
for (int k = x; k; k -= k & (-k)) ans -= s2[k];
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x)
adde(x, i);
else
rt = i;
}
dep[rt] = 1;
dfs(rt);
dfs2(rt, rt);
for (int i = 2; i <= n; i++) {
vector<int>::iterator it;
for (it = v[i].begin(); it != v[i].end(); it++)
for (int k = fa[*it]; k; k = fa[top[k]])
add(pos[top[k]], 1), add(pos[k] + 1, -1);
for (it = v[i].begin(); it != v[i].end(); it++)
for (int k = fa[*it]; k; k = fa[top[k]])
ans[*it] += sum(pos[k]) - sum(pos[top[k]] - 1);
}
for (int i = 1; i <= n; i++) printf("%I64d ", ans[i]);
}
|
There are two main kinds of events in the life of top-model: fashion shows and photo shoots. Participating in any of these events affects the rating of appropriate top-model. After each photo shoot model's rating increases by a and after each fashion show decreases by b (designers do too many experiments nowadays). Moreover, sometimes top-models participates in talk shows. After participating in talk show model becomes more popular and increasing of her rating after photo shoots become c and decreasing of her rating after fashion show becomes d.
Izabella wants to participate in a talk show, but she wants to do it in such a way that her rating will never become negative. Help her to find a suitable moment for participating in the talk show.
Let's assume that model's career begins in moment 0. At that moment Izabella's rating was equal to start. If talk show happens in moment t if will affect all events in model's life in interval of time [t..t + len) (including t and not including t + len), where len is duration of influence.
Izabella wants to participate in a talk show, but she wants to do it in such a way that her rating will not become become negative before talk show or during period of influence of talk show. Help her to find a suitable moment for participating in the talk show.
Input
In first line there are 7 positive integers n, a, b, c, d, start, len (1 ≤ n ≤ 3·105, 0 ≤ start ≤ 109, 1 ≤ a, b, c, d, len ≤ 109), where n is a number of fashion shows and photo shoots, a, b, c and d are rating changes described above, start is an initial rating of model and len is a duration of influence of talk show.
In next n lines descriptions of events are given. Each of those lines contains two integers ti and qi (1 ≤ ti ≤ 109, 0 ≤ q ≤ 1) — moment, in which event happens and type of this event. Type 0 corresponds to the fashion show and type 1 — to photo shoot.
Events are given in order of increasing ti, all ti are different.
Output
Print one non-negative integer t — the moment of time in which talk show should happen to make Izabella's rating non-negative before talk show and during period of influence of talk show. If there are multiple answers print smallest of them. If there are no such moments, print - 1.
Examples
Input
5 1 1 1 4 0 5
1 1
2 1
3 1
4 0
5 0
Output
6
Input
1 1 2 1 2 1 2
1 0
Output
-1
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 10;
long long dp[MAXN << 1];
long long dp1[MAXN << 1];
int n, a, b, c, d, start, len;
struct Act {
int t, type;
bool operator<(const Act& other) const {
if (t != other.t) return t < other.t;
return type > other.type;
}
bool operator==(const Act& other) const { return t == other.t; }
};
Act acts[MAXN << 1];
int main() {
cin >> n >> a >> b >> c >> d >> start >> len;
int tot = 1;
for (int i = 0; i < n; i++) {
scanf("%d%d", &acts[tot].t, &acts[tot].type);
acts[tot].type++;
tot++;
acts[tot].t = acts[tot - 1].t + 1;
tot++;
}
sort(acts, acts + tot);
n = unique(acts, acts + tot) - acts;
long long delta = 0, bad = 0;
int ind = 0;
while (ind < n && len > acts[ind].t) {
if (acts[ind].type == 1) {
delta -= d;
} else if (acts[ind].type == 2) {
delta += c;
}
bad = min(bad, delta);
ind++;
}
dp1[0] = bad;
dp[0] = delta;
for (int i = 1; i < n; i++) {
while (ind < n && acts[i].t + len > acts[ind].t) {
if (acts[ind].type == 1) {
delta -= d;
bad = min(bad, delta);
} else if (acts[ind].type == 2) {
delta += c;
}
ind++;
}
if (acts[i - 1].type == 1) {
delta += d;
bad += d;
} else if (acts[i - 1].type == 2) {
delta -= c;
bad -= c;
}
dp[i] = delta;
dp1[i] = bad;
}
int ret = -1;
long long cur = start;
for (int i = 0; i < n; i++) {
if (cur >= 0 && cur + dp[i] >= 0 && cur + dp1[i] >= 0) {
ret = acts[i].t;
break;
}
if (acts[i].type == 1) {
cur -= b;
} else if (acts[i].type == 2) {
cur += a;
}
if (cur < 0) break;
}
cout << ret << endl;
}
|
Vasya writes his own library for building graphical user interface. Vasya called his creation VTK (VasyaToolKit). One of the interesting aspects of this library is that widgets are packed in each other.
A widget is some element of graphical interface. Each widget has width and height, and occupies some rectangle on the screen. Any widget in Vasya's library is of type Widget. For simplicity we will identify the widget and its type.
Types HBox and VBox are derivatives of type Widget, so they also are types Widget. Widgets HBox and VBox are special. They can store other widgets. Both those widgets can use the pack() method to pack directly in itself some other widget. Widgets of types HBox and VBox can store several other widgets, even several equal widgets — they will simply appear several times. As a result of using the method pack() only the link to the packed widget is saved, that is when the packed widget is changed, its image in the widget, into which it is packed, will also change.
We shall assume that the widget a is packed in the widget b if there exists a chain of widgets a = c1, c2, ..., ck = b, k ≥ 2, for which ci is packed directly to ci + 1 for any 1 ≤ i < k. In Vasya's library the situation when the widget a is packed in the widget a (that is, in itself) is not allowed. If you try to pack the widgets into each other in this manner immediately results in an error.
Also, the widgets HBox and VBox have parameters border and spacing, which are determined by the methods set_border() and set_spacing() respectively. By default both of these options equal 0.
<image>
The picture above shows how the widgets are packed into HBox and VBox. At that HBox and VBox automatically change their size depending on the size of packed widgets. As for HBox and VBox, they only differ in that in HBox the widgets are packed horizontally and in VBox — vertically. The parameter spacing sets the distance between adjacent widgets, and border — a frame around all packed widgets of the desired width. Packed widgets are placed exactly in the order in which the pack() method was called for them. If within HBox or VBox there are no packed widgets, their sizes are equal to 0 × 0, regardless of the options border and spacing.
The construction of all the widgets is performed using a scripting language VasyaScript. The description of the language can be found in the input data.
For the final verification of the code Vasya asks you to write a program that calculates the sizes of all the widgets on the source code in the language of VasyaScript.
Input
The first line contains an integer n — the number of instructions (1 ≤ n ≤ 100). Next n lines contain instructions in the language VasyaScript — one instruction per line. There is a list of possible instructions below.
* "Widget [name]([x],[y])" — create a new widget [name] of the type Widget possessing the width of [x] units and the height of [y] units.
* "HBox [name]" — create a new widget [name] of the type HBox.
* "VBox [name]" — create a new widget [name] of the type VBox.
* "[name1].pack([name2])" — pack the widget [name2] in the widget [name1]. At that, the widget [name1] must be of type HBox or VBox.
* "[name].set_border([x])" — set for a widget [name] the border parameter to [x] units. The widget [name] must be of type HBox or VBox.
* "[name].set_spacing([x])" — set for a widget [name] the spacing parameter to [x] units. The widget [name] must be of type HBox or VBox.
All instructions are written without spaces at the beginning and at the end of the string. The words inside the instruction are separated by exactly one space. There are no spaces directly before the numbers and directly after them.
The case matters, for example, "wiDget x" is not a correct instruction. The case of the letters is correct in the input data.
All names of the widgets consist of lowercase Latin letters and has the length from 1 to 10 characters inclusive. The names of all widgets are pairwise different. All numbers in the script are integers from 0 to 100 inclusive
It is guaranteed that the above-given script is correct, that is that all the operations with the widgets take place after the widgets are created and no widget is packed in itself. It is guaranteed that the script creates at least one widget.
Output
For each widget print on a single line its name, width and height, separated by spaces. The lines must be ordered lexicographically by a widget's name.
Please, do not use the %lld specificator to read or write 64-bit integers in C++. It is preferred to use cout stream (also you may use %I64d specificator)
Examples
Input
12
Widget me(50,40)
VBox grandpa
HBox father
grandpa.pack(father)
father.pack(me)
grandpa.set_border(10)
grandpa.set_spacing(20)
Widget brother(30,60)
father.pack(brother)
Widget friend(20,60)
Widget uncle(100,20)
grandpa.pack(uncle)
Output
brother 30 60
father 80 60
friend 20 60
grandpa 120 120
me 50 40
uncle 100 20
Input
15
Widget pack(10,10)
HBox dummy
HBox x
VBox y
y.pack(dummy)
y.set_border(5)
y.set_spacing(55)
dummy.set_border(10)
dummy.set_spacing(20)
x.set_border(10)
x.set_spacing(10)
x.pack(pack)
x.pack(dummy)
x.pack(pack)
x.set_border(0)
Output
dummy 0 0
pack 10 10
x 40 10
y 10 10
Note
In the first sample the widgets are arranged as follows:
<image>
|
import java.io.*;
import java.math.*;
import java.util.*;
import java.util.stream.*;
@SuppressWarnings("unchecked")
public class P90D {
abstract class AWidget {
long width, height;
public abstract void setBorder(int border);
public abstract void setSpacing(int spacing);
public abstract void pack(AWidget widget);
public abstract long width();
public abstract long height();
}
//----------------------------------------------------------------------------
class Widget extends AWidget {
public Widget(int width, int height) {
this.width = width;
this.height = height;
}
@Override public void setBorder(int border) {;}
@Override public void setSpacing(int spacing) {;}
@Override public void pack(AWidget widget) {;}
@Override public long width() {
return width;
}
@Override public long height() {
return height;
}
}
//----------------------------------------------------------------------------
abstract class ABox extends AWidget {
int border, spacing;
boolean wc = false, hc = false;
List<AWidget> pack = new ArrayList();
@Override public void setBorder(int border) {
this.border = border;
}
@Override public void setSpacing(int spacing) {
this.spacing = spacing;
}
@Override public void pack(AWidget widget) {
pack.add(widget);
}
protected long border() {
return ((pack.size() > 0) ? (border << 1) : 0);
}
protected long spacing() {
return ((pack.size() > 1) ? (spacing * (pack.size() - 1)) : 0);
}
}
//----------------------------------------------------------------------------
class HBox extends ABox {
public long width() {
if (!wc) {
width = border() + spacing();
wc = true;
for (AWidget w : pack) {
width += w.width();
}
}
return width;
}
public long height() {
if (!hc) {
height = 0;
hc = true;
for (AWidget w : pack) {
height = Math.max(height, w.height());
}
height += border();
}
return height;
}
}
//----------------------------------------------------------------------------
class VBox extends ABox {
public long width() {
if (!wc) {
width = 0;
wc = true;
for (AWidget w : pack) {
width = Math.max(width, w.width());
}
width += border();
}
return width;
}
public long height() {
if (!hc) {
height = border() + spacing();
hc = true;
for (AWidget w : pack) {
height += w.height();
}
}
return height;
}
}
//----------------------------------------------------------------------------
public void run() throws Exception {
TreeMap<String, AWidget> widgets = new TreeMap();
for (int n = nextInt(); n > 0; n--) {
String cmd = nextLine();
if (cmd.startsWith("Widget ")) {
String name = cmd.substring(7, cmd.indexOf('('));
String [] wh = cmd.substring(cmd.indexOf('(') + 1, cmd.indexOf(')')).split(",");
widgets.put(name, new Widget(Integer.valueOf(wh[0]), Integer.valueOf(wh[1])));
} else if (cmd.startsWith("HBox ")) {
String name = cmd.substring(5);
widgets.put(name, new HBox());
} else if (cmd.startsWith("VBox ")) {
String name = cmd.substring(5);
widgets.put(name, new VBox());
} else {
String name = cmd.substring(0, cmd.indexOf('.'));
cmd = cmd.substring(cmd.indexOf('.') + 1);
if (cmd.startsWith("set_border")) {
widgets.get(name).setBorder(Integer.valueOf(cmd.substring(11, cmd.indexOf(')'))));
} else if (cmd.startsWith("set_spacing")) {
widgets.get(name).setSpacing(Integer.valueOf(cmd.substring(12, cmd.indexOf(')'))));
} else {
widgets.get(name).pack(widgets.get(cmd.substring(5, cmd.indexOf(')'))));
}
}
}
for (Map.Entry<String, AWidget> me : widgets.entrySet()) {
println(me.getKey() + " " + me.getValue().width() + " " + me.getValue().height());
}
}
public static void main(String... args) throws Exception {
br = new BufferedReader(new InputStreamReader(System.in));
pw = new PrintWriter(new BufferedOutputStream(System.out));
new P90D().run();
br.close();
pw.close();
System.err.println("\n[Time : " + (System.currentTimeMillis() - startTime) + " ms]");
}
static long startTime = System.currentTimeMillis();
static BufferedReader br;
static PrintWriter pw;
StringTokenizer stok;
String nextToken() throws IOException {
while (stok == null || !stok.hasMoreTokens()) {
String s = br.readLine();
if (s == null) { return null; }
stok = new StringTokenizer(s);
}
return stok.nextToken();
}
void print(byte b) { print("" + b); }
void print(int i) { print("" + i); }
void print(long l) { print("" + l); }
void print(double d) { print("" + d); }
void print(char c) { print("" + c); }
void print(Object o) {
if (o instanceof int[]) { print(Arrays.toString((int [])o));
} else if (o instanceof long[]) { print(Arrays.toString((long [])o));
} else if (o instanceof char[]) { print(Arrays.toString((char [])o));
} else if (o instanceof byte[]) { print(Arrays.toString((byte [])o));
} else if (o instanceof short[]) { print(Arrays.toString((short [])o));
} else if (o instanceof boolean[]) { print(Arrays.toString((boolean [])o));
} else if (o instanceof float[]) { print(Arrays.toString((float [])o));
} else if (o instanceof double[]) { print(Arrays.toString((double [])o));
} else if (o instanceof Object[]) { print(Arrays.toString((Object [])o));
} else { print("" + o); }
}
void print(String s) { pw.print(s); }
void println() { println(""); }
void println(byte b) { println("" + b); }
void println(int i) { println("" + i); }
void println(long l) { println("" + l); }
void println(double d) { println("" + d); }
void println(char c) { println("" + c); }
void println(Object o) { print(o); println(); }
void println(String s) { pw.println(s); }
int nextInt() throws IOException { return Integer.parseInt(nextToken()); }
long nextLong() throws IOException { return Long.parseLong(nextToken()); }
double nextDouble() throws IOException { return Double.parseDouble(nextToken()); }
char nextChar() throws IOException { return (char) (br.read()); }
String next() throws IOException { return nextToken(); }
String nextLine() throws IOException { return br.readLine(); }
int [] readInt(int size) throws IOException {
int [] array = new int [size];
for (int i = 0; i < size; i++) { array[i] = nextInt(); }
return array;
}
long [] readLong(int size) throws IOException {
long [] array = new long [size];
for (int i = 0; i < size; i++) { array[i] = nextLong(); }
return array;
}
double [] readDouble(int size) throws IOException {
double [] array = new double [size];
for (int i = 0; i < size; i++) { array[i] = nextDouble(); }
return array;
}
String [] readLines(int size) throws IOException {
String [] array = new String [size];
for (int i = 0; i < size; i++) { array[i] = nextLine(); }
return array;
}
}
|
You are given a string A. Find a string B, where B is a palindrome and A is a subsequence of B.
A subsequence of a string is a string that can be derived from it by deleting some (not necessarily consecutive) characters without changing the order of the remaining characters. For example, "cotst" is a subsequence of "contest".
A palindrome is a string that reads the same forward or backward.
The length of string B should be at most 104. It is guaranteed that there always exists such string.
You do not need to find the shortest answer, the only restriction is that the length of string B should not exceed 104.
Input
First line contains a string A (1 ≤ |A| ≤ 103) consisting of lowercase Latin letters, where |A| is a length of A.
Output
Output single line containing B consisting of only lowercase Latin letters. You do not need to find the shortest answer, the only restriction is that the length of string B should not exceed 104. If there are many possible B, print any of them.
Examples
Input
aba
Output
aba
Input
ab
Output
aabaa
Note
In the first example, "aba" is a subsequence of "aba" which is a palindrome.
In the second example, "ab" is a subsequence of "aabaa" which is a palindrome.
|
# -*- coding: utf-8 -*-
"""
Created on Thu Feb 15 21:01:05 2018
@author: DNARNAprotein
"""
"""
CODEFORCES
http://codeforces.com/contest/932/problem/A
"""
def pikachu(a,c,n): #c is original string
prefixes=[a[0:i+1] for i in range(n+1)]
suffixes=[a[i:n+1] for i in range(n+1)]
maxi=0
for i in range(n//2):
for j in suffixes:
if prefixes[i]==j:
maxi=i+1
ans=c[maxi::][::-1]+c
l=len(ans)
return ((ans,l))
a=input()
c=a
b=a[::-1]+'#'+a
a=a+'#'+a[::-1]
n=len(c*2)
x=pikachu(a,c,n)
c=c[::-1]
y=pikachu(b,c,n)
if x[1]<y[1]:
print(x[0])
else:
print(y[0])
|
Mahmoud wants to send a message to his friend Ehab. Their language consists of n words numbered from 1 to n. Some words have the same meaning so there are k groups of words such that all the words in some group have the same meaning.
Mahmoud knows that the i-th word can be sent with cost ai. For each word in his message, Mahmoud can either replace it with another word of the same meaning or leave it as it is. Can you help Mahmoud determine the minimum cost of sending the message?
The cost of sending the message is the sum of the costs of sending every word in it.
Input
The first line of input contains integers n, k and m (1 ≤ k ≤ n ≤ 105, 1 ≤ m ≤ 105) — the number of words in their language, the number of groups of words, and the number of words in Mahmoud's message respectively.
The second line contains n strings consisting of lowercase English letters of length not exceeding 20 which represent the words. It's guaranteed that the words are distinct.
The third line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) where ai is the cost of sending the i-th word.
The next k lines describe the groups of words of same meaning. The next k lines each start with an integer x (1 ≤ x ≤ n) which means that there are x words in this group, followed by x integers which represent the indices of words in this group. It's guaranteed that each word appears in exactly one group.
The next line contains m space-separated words which represent Mahmoud's message. Each of these words appears in the list of language's words.
Output
The only line should contain the minimum cost to send the message after replacing some words (maybe none) with some words of the same meaning.
Examples
Input
5 4 4
i loser am the second
100 1 1 5 10
1 1
1 3
2 2 5
1 4
i am the second
Output
107
Input
5 4 4
i loser am the second
100 20 1 5 10
1 1
1 3
2 2 5
1 4
i am the second
Output
116
Note
In the first sample, Mahmoud should replace the word "second" with the word "loser" because it has less cost so the cost will be 100+1+5+1=107.
In the second sample, Mahmoud shouldn't do any replacement so the cost will be 100+1+5+10=116.
|
#!/usr/bin/env python
n, k, m = [int(x) for x in raw_input().split()]
s = raw_input().split()
d = {s[x]: x + 1 for x in xrange(len(s))}
c = [0] + [int(x) for x in raw_input().split()]
r = [0] * (n + 1)
p = [i for i in xrange(n + 1)]
def find(a):
temp = a
while p[temp] != temp:
temp = p[temp]
p[a] = temp
c[temp] = min(c[temp], c[a])
return temp
def merge(a, b):
ra, rb = find(a), find(b)
if ra == rb:
return
if ra > rb:
p[rb] = ra
c[ra] = min(c[ra], c[rb])
elif ra < rb:
p[ra] = rb
c[rb] = min(c[ra], c[rb])
else:
p[ra] = rb
r[rb] += 1
c[rb] = min(c[ra], c[rb])
for i in xrange(k):
g = [int(x) for x in raw_input().split()][1:]
for j in xrange(1, len(g)):
merge(g[0], g[j])
print sum([c[find(d[x])] for x in raw_input().split()])
|
There are n players numbered from 0 to n-1 with ranks. The i-th player has rank i.
Players can form teams: the team should consist of three players and no pair of players in the team should have a conflict. The rank of the team is calculated using the following algorithm: let i, j, k be the ranks of players in the team and i < j < k, then the rank of the team is equal to A ⋅ i + B ⋅ j + C ⋅ k.
You are given information about the pairs of players who have a conflict. Calculate the total sum of ranks over all possible valid teams modulo 2^{64}.
Input
The first line contains two space-separated integers n and m (3 ≤ n ≤ 2 ⋅ 10^5, 0 ≤ m ≤ 2 ⋅ 10^5) — the number of players and the number of conflicting pairs.
The second line contains three space-separated integers A, B and C (1 ≤ A, B, C ≤ 10^6) — coefficients for team rank calculation.
Each of the next m lines contains two space-separated integers u_i and v_i (0 ≤ u_i, v_i < n, u_i ≠ v_i) — pair of conflicting players.
It's guaranteed that each unordered pair of players appears in the input file no more than once.
Output
Print single integer — the total sum of ranks over all possible teams modulo 2^{64}.
Examples
Input
4 0
2 3 4
Output
64
Input
4 1
2 3 4
1 0
Output
38
Input
6 4
1 5 3
0 3
3 5
5 4
4 3
Output
164
Note
In the first example all 4 teams are valid, i.e. triples: {0, 1, 2}, {0, 1, 3}, {0, 2, 3} {1, 2, 3}.
In the second example teams are following: {0, 2, 3}, {1, 2, 3}.
In the third example teams are following: {0, 1, 2}, {0, 1, 4}, {0, 1, 5}, {0, 2, 4}, {0, 2, 5}, {1, 2, 3}, {1, 2, 4}, {1, 2, 5}.
|
#include <bits/stdc++.h>
using namespace std;
int n, m, arr[200000][2], idx[200000], nl[200000], nr[200000], prn[200000];
unsigned long long a, b, c, sl[200000], sr[200000], prm[200000], r;
vector<int> qr[200000], ql[200000];
vector<unsigned long long> qrs[200000], qls[200000];
struct TRIANGLE {
int n, *idx, *idv;
typedef void (*TRI_OP)(int i, int j, int k);
vector<int> *edges;
TRIANGLE(int n) : n(n) {
edges = new vector<int>[n];
idx = new int[n], idv = new int[n];
for (int i = 0; i < n; i++) idx[i] = i;
}
void run(typename TRIANGLE::TRI_OP op) {
sort(idx, idx + n,
[this](int i, int j) { return edges[i].size() > edges[j].size(); });
for (int i = 0; i < n; i++) idv[idx[i]] = i;
for (int i = 0; i < n; i++) sort(edges[i].begin(), edges[i].end());
for (int ii = 0; ii < n; ii++) {
int i = idx[ii];
for (auto j : edges[i])
if (ii < idv[j]) {
int ki = i, kj = j;
if (ki > kj) swap(ki, kj);
vector<int> p(min(edges[i].size(), edges[j].size()));
p.resize(set_intersection(edges[i].begin(), edges[i].end(),
edges[j].begin(), edges[j].end(),
p.begin()) -
p.begin());
for (auto ip : p)
if (idv[ip] < ii) {
if (ip < ki)
op(ip, ki, kj);
else if (ip > kj)
op(ki, kj, ip);
else
op(ki, ip, kj);
}
}
}
}
~TRIANGLE() { delete[] edges, delete[] idx, delete[] idv; }
};
void tri_op(int i, int j, int k) { r -= a * i + b * j + c * k; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
cin >> a >> b >> c;
for (int i = 0; i < m; i++) {
cin >> arr[i][0] >> arr[i][1], idx[i] = i;
if (arr[i][1] < arr[i][0]) swap(arr[i][0], arr[i][1]);
sl[arr[i][1]] += arr[i][0], nl[arr[i][1]]++;
sr[arr[i][0]] += arr[i][1], nr[arr[i][0]]++;
qr[arr[i][0]].push_back(arr[i][1]);
ql[arr[i][1]].push_back(arr[i][0]);
}
for (int i = 0; i < n; i++) {
sort(qr[i].begin(), qr[i].end()), sort(ql[i].begin(), ql[i].end());
qrs[i].reserve(qr[i].size() + 1), qrs[i].push_back(0);
qls[i].reserve(ql[i].size() + 1), qls[i].push_back(0);
for (auto &q : qr[i]) qrs[i].push_back(q + qrs[i].back());
reverse(ql[i].begin(), ql[i].end());
for (auto &q : ql[i]) qls[i].push_back(q + qls[i].back());
reverse(ql[i].begin(), ql[i].end());
}
sort(idx, idx + m, [](int i, int j) {
return arr[i][0] < arr[j][0] ||
(arr[i][0] == arr[j][0] && arr[i][1] < arr[j][1]);
});
for (int i = 1; i < n - 1; i++)
r = r + b * i * (i - nl[i]) * (n - 1 - i - nr[i]) +
a * (n - 1 - i - nr[i]) *
((unsigned long long)(i - 1) * i / 2 - sl[i]) +
c * (i - nl[i]) *
((unsigned long long)(i + n) * (n - 1 - i) / 2 - sr[i]);
unsigned long long rr = 0, g;
for (int i = 1, ix = 0, z = 0; i < n - 1; i++) {
for (; ix < m && arr[idx[ix]][0] == i - 1; ix++)
g = a * (i - 1) + c * arr[idx[ix]][1], rr += g, z++,
prm[arr[idx[ix]][1]] += g, prn[arr[idx[ix]][1]]++;
rr -= prm[i], z -= prn[i];
r = r - b * z * i - rr;
}
for (int i = 0; i < m; i++) {
int t = lower_bound(qr[arr[i][0]].begin(), qr[arr[i][0]].end(), arr[i][1]) -
qr[arr[i][0]].begin();
r += t * (a * arr[i][0] + c * arr[i][1]) + b * qrs[arr[i][0]][t];
}
for (int i = 0; i < m; i++) {
int t = ql[arr[i][1]].end() -
upper_bound(ql[arr[i][1]].begin(), ql[arr[i][1]].end(), arr[i][0]);
r += t * (a * arr[i][0] + c * arr[i][1]) + b * qls[arr[i][1]][t];
}
TRIANGLE tri(n);
for (int i = 0; i < m; i++)
tri.edges[arr[i][0]].push_back(arr[i][1]),
tri.edges[arr[i][1]].push_back(arr[i][0]);
tri.run(&tri_op);
cout << r << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.