input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
Indiana Jones found ancient Aztec catacombs containing a golden idol. The catacombs consists of n caves. Each pair of caves is connected with a two-way corridor that can be opened or closed. The entrance to the catacombs is in the cave 1, the idol and the exit are in the cave n.
When Indiana goes from a cave x to a cave y using an open corridor, all corridors connected to the cave x change their state: all open corridors become closed, all closed corridors become open. Indiana wants to go from cave 1 to cave n going through as small number of corridors as possible. Help him find the optimal path, or determine that it is impossible to get out of catacombs.
Input
The first line contains two integers n and m (2 ≤ n ≤ 3⋅ 10^5, 0 ≤ m ≤ 3 ⋅ 10^5) — the number of caves and the number of open corridors at the initial moment.
The next m lines describe the open corridors. The i-th of these lines contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i) — the caves connected by the i-th open corridor. It is guaranteed that each unordered pair of caves is presented at most once.
Output
If there is a path to exit, in the first line print a single integer k — the minimum number of corridors Indians should pass through (1 ≤ k ≤ 10^6). In the second line print k+1 integers x_0, …, x_k — the number of caves in the order Indiana should visit them. The sequence x_0, …, x_k should satisfy the following:
* x_0 = 1, x_k = n;
* for each i from 1 to k the corridor from x_{i - 1} to x_i should be open at the moment Indiana walks along this corridor.
If there is no path, print a single integer -1.
We can show that if there is a path, there is a path consisting of no more than 10^6 corridors.
Examples
Input
4 4
1 2
2 3
1 3
3 4
Output
2
1 3 4
Input
4 2
1 2
2 3
Output
4
1 2 3 1 4
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[300010], ans, rec;
set<pair<int, int>> edge;
int n, m, u, v;
int dis[300010], fa[300010], in[300010];
int cls[300010], vis[300010];
void dfs(int u) {
rec.push_back(u);
vis[u] = 1;
for (int v : g[u])
if (!vis[v]) dfs(v);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
edge.insert(make_pair(u, v));
edge.insert(make_pair(v, u));
}
for (int i = 2; i <= n; i++) dis[i] = 1e9;
queue<int> que;
que.push(1);
while (!que.empty()) {
int u = que.front();
que.pop();
in[u] = 0;
for (int v : g[u])
if (dis[v] > dis[u] + 1) {
dis[v] = dis[u] + 1;
fa[v] = u;
if (!in[v]) {
in[v] = 1;
que.push(v);
}
}
}
if (dis[n] != 1e9) {
for (int u = n; u; u = fa[u]) ans.push_back(u);
reverse(ans.begin(), ans.end());
}
if (ans.empty() || ans.size() > 4) {
for (int u : g[1]) cls[u] = 1;
cls[1] = 1;
bool ok = false;
for (int u : g[1]) {
for (int v : g[u])
if (!cls[v]) {
ans = {1, u, v, 1, n};
ok = true;
break;
}
if (ok) break;
}
}
if (ans.empty() || ans.size() > 5) {
vis[1] = 1;
bool ok = false;
for (int u : g[1]) {
if (vis[u]) continue;
rec.clear();
dfs(u);
if (g[u].size() != rec.size()) {
int cur = 1;
while (cur < rec.size() && edge.count({u, rec[cur]})) cur++;
for (int i = 1; i < cur; i++)
if (edge.count({rec[i], rec[cur]})) {
ans = {1, u, rec[i], rec[cur], u, n};
ok = true;
}
} else {
for (int i = 0; i < g[u].size(); i++) {
for (int j = i + 1; j < g[u].size(); j++)
if (g[u][i] != 1 && g[u][j] != 1 &&
!edge.count({g[u][i], g[u][j]})) {
ans = {1, g[u][i], u, g[u][j], g[u][i], n};
ok = true;
break;
}
}
if (ok) break;
}
if (ok) break;
}
}
if (ans.empty())
puts("-1");
else {
printf("%d\n", (int)ans.size() - 1);
for (int u : ans) printf("%d ", u);
puts("");
}
return 0;
}
|
Consider a system of n water taps all pouring water into the same container. The i-th water tap can be set to deliver any amount of water from 0 to ai ml per second (this amount may be a real number). The water delivered by i-th tap has temperature ti.
If for every <image> you set i-th tap to deliver exactly xi ml of water per second, then the resulting temperature of water will be <image> (if <image>, then to avoid division by zero we state that the resulting water temperature is 0).
You have to set all the water taps in such a way that the resulting temperature is exactly T. What is the maximum amount of water you may get per second if its temperature has to be T?
Input
The first line contains two integers n and T (1 ≤ n ≤ 200000, 1 ≤ T ≤ 106) — the number of water taps and the desired temperature of water, respectively.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) where ai is the maximum amount of water i-th tap can deliver per second.
The third line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 106) — the temperature of water each tap delivers.
Output
Print the maximum possible amount of water with temperature exactly T you can get per second (if it is impossible to obtain water with such temperature, then the answer is considered to be 0).
Your answer is considered correct if its absolute or relative error doesn't exceed 10 - 6.
Examples
Input
2 100
3 10
50 150
Output
6.000000000000000
Input
3 9
5 5 30
6 6 10
Output
40.000000000000000
Input
2 12
1 3
10 15
Output
1.666666666666667
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
long long n, T, t[N], x[N], sa, sb;
long double ans;
vector<pair<long long, long long> > a, b;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> T;
for (int i = 0; i < n; i++) cin >> x[i];
for (int i = 0; i < n; i++) {
cin >> t[i];
if (t[i] == T)
ans += x[i];
else {
if (t[i] < T) {
a.push_back({T - t[i], x[i]});
sa += (T - t[i]) * x[i];
}
if (t[i] > T) {
b.push_back({t[i] - T, x[i]});
sb += (t[i] - T) * x[i];
}
}
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
long long can = min(sa, sb);
for (int i = 0; i < a.size(); i++) {
if (can < a[i].first * a[i].second) {
ans += 1.0 * can / a[i].first;
break;
}
can -= a[i].first * a[i].second;
ans += a[i].second;
}
can = min(sa, sb);
for (int i = 0; i < b.size(); i++) {
if (can < b[i].first * b[i].second) {
ans += 1.0 * can / b[i].first;
break;
}
can -= b[i].first * b[i].second;
ans += b[i].second;
}
cout << fixed << setprecision(10) << ans;
return 0;
}
|
SaMer has written the greatest test case of all time for one of his problems. For a given array of integers, the problem asks to find the minimum number of groups the array can be divided into, such that the product of any pair of integers in the same group is a perfect square.
Each integer must be in exactly one group. However, integers in a group do not necessarily have to be contiguous in the array.
SaMer wishes to create more cases from the test case he already has. His test case has an array A of n integers, and he needs to find the number of contiguous subarrays of A that have an answer to the problem equal to k for each integer k between 1 and n (inclusive).
Input
The first line of input contains a single integer n (1 ≤ n ≤ 5000), the size of the array.
The second line contains n integers a_1,a_2,...,a_n (-10^8 ≤ a_i ≤ 10^8), the values of the array.
Output
Output n space-separated integers, the k-th integer should be the number of contiguous subarrays of A that have an answer to the problem equal to k.
Examples
Input
2
5 5
Output
3 0
Input
5
5 -4 2 1 8
Output
5 5 3 2 0
Input
1
0
Output
1
|
import java.util.*;
import java.io.*;
public class Main {
public static void main(String args[]) {new Main().run();}
FastReader in = new FastReader();
PrintWriter out = new PrintWriter(System.out);
void run(){
work();
out.flush();
}
long mod=1000000007;
long gcd(long a,long b) {
return b==0?a:gcd(b,a%b);
}
void work() {
int n=in.nextInt();
long[] A=new long[n];
for(int i=0;i<n;i++)A[i]=in.nextLong();
int[] ret=new int[n];
int[] id=new int[n];
for(int i=0;i<n;i++) {
for(long k=2;k*k<=Math.abs(A[i]);k++) {
while(A[i]%(k*k)==0) {
A[i]/=(k*k);
}
}
}
for(int i=0;i<n;i++) {
id[i]=i;
if(A[i]==0) continue;
for(int j=0;j<i;j++) {
if(A[j]==0)continue;
if(A[i]==A[j]) {
id[i]=j;
break;
}
}
}
for(int i=0;i<n;i++) {
boolean[] vis=new boolean[n];
int cur=0;
for(int j=i;j<n;j++) {
if(A[j]!=0&&!vis[id[j]]) {
cur++;
vis[id[j]]=true;
}
if(cur==0) {
ret[cur]++;//zero
}else {
ret[cur-1]++;
}
}
}
for(int i=0;i<n;i++) {
out.print(ret[i]+" ");
}
}
}
class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br=new BufferedReader(new InputStreamReader(System.in));
}
public String next()
{
if(st==null || !st.hasMoreElements())
{
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
public int nextInt()
{
return Integer.parseInt(next());
}
public long nextLong()
{
return Long.parseLong(next());
}
}
|
In one very old text file there was written Great Wisdom. This Wisdom was so Great that nobody could decipher it, even Phong — the oldest among the inhabitants of Mainframe. But still he managed to get some information from there. For example, he managed to learn that User launches games for pleasure — and then terrible Game Cubes fall down on the city, bringing death to those modules, who cannot win the game...
For sure, as guard Bob appeared in Mainframe many modules stopped fearing Game Cubes. Because Bob (as he is alive yet) has never been defeated by User, and he always meddles with Game Cubes, because he is programmed to this.
However, unpleasant situations can happen, when a Game Cube falls down on Lost Angles. Because there lives a nasty virus — Hexadecimal, who is... mmm... very strange. And she likes to play very much. So, willy-nilly, Bob has to play with her first, and then with User.
This time Hexadecimal invented the following entertainment: Bob has to leap over binary search trees with n nodes. We should remind you that a binary search tree is a binary tree, each node has a distinct key, for each node the following is true: the left sub-tree of a node contains only nodes with keys less than the node's key, the right sub-tree of a node contains only nodes with keys greater than the node's key. All the keys are different positive integer numbers from 1 to n. Each node of such a tree can have up to two children, or have no children at all (in the case when a node is a leaf).
In Hexadecimal's game all the trees are different, but the height of each is not lower than h. In this problem «height» stands for the maximum amount of nodes on the way from the root to the remotest leaf, the root node and the leaf itself included. When Bob leaps over a tree, it disappears. Bob gets the access to a Cube, when there are no trees left. He knows how many trees he will have to leap over in the worst case. And you?
Input
The input data contains two space-separated positive integer numbers n and h (n ≤ 35, h ≤ n).
Output
Output one number — the answer to the problem. It is guaranteed that it does not exceed 9·1018.
Examples
Input
3 2
Output
5
Input
3 3
Output
4
|
#include <bits/stdc++.h>
using namespace std;
long long f[505][505];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i <= n; i++) f[0][i] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 0; k < j; k++) {
(f[j][i] += f[k][i - 1] * f[j - k - 1][i - 1]);
}
}
}
printf("%lld", f[n][n] - f[n][k - 1]);
return 0;
}
|
bhargav has dream to study his MS is foreign country. So, He started his preparation for GRE. There are huge number of words that he has to prepare for. So, firs he wanted to group all synonyms and antonyms. As there are huge number of words that he has to group. So, he asked help to group all synonyms and antonyms of a word.
it is called antonym if the first letter of a current number is 3 steps upper than reference then it is antonym if the first letter of the reference number is same as the current first letter of a word then it is synonym. and the length should be same for the antonym and synonym
INPUT:
first line should contain a word W.
next line contains no of words N.
next N lines consists of words that are to be grouped.
OUTPUT
print no of synonyms S followed by antonyms A.
SAMPLE INPUT
hasrfk
4
heyfgs
jhajyrbf
kayufs
hetinf
SAMPLE OUTPUT
2 1
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
s=raw_input()
n=input()
a=0
sy=0
for i in range(n):
s1=raw_input()
if s1[0]==s[0] and len(s1)==len(s):
sy+=1
if chr(ord(s[0])+3)==s1[0] and len(s1)==len(s):
a+=1
print sy,a
|
Raghu wants to design a converter such that when a user inputs a binary number it gets converted to Octal number & also the correspond alphabet to it.
Example- if a user inputs- 10101101
then the output is 255 BEE
Note : for decimal places there should be a space between the alphabetic signs
Ex- for input 101101101110.111
output -5556.7 EEEF G
A stands for 1, b for 2 , if the octal digit is 0 consider it as a space
SAMPLE INPUT
10101101
SAMPLE OUTPUT
255 BEE
|
bindict = {'000':0,'001':1,'010':2,'100':4,'101':5,'110':6,'111':7,'011':3}
binary = raw_input().split('.')
for index,value in enumerate(binary):
arr = []
if(index==0):
while(len(value)%3!=0):
value='0'+value
j = 1
i = 0
while(j<=len(value)):
if(j%3==0):
arr.append(value[i:j])
i = j
j+=1
total = ''
for k in arr:
total+=str(bindict[k])
if(index==1):
total+='.'
while(len(value)%3!=0):
value=value+'0'
j = 1
i = 0
while(j<=len(value)):
if(j%3==0):
arr.append(value[i:j])
i = j
j+=1
for k in arr:
total+=str(bindict[k])
string = ''
for i in total:
if(i=='.'):
string+=' '
else:
string+=chr(64+int(i))
print total+ ' '+string
|
After decrypting the code Enigma crew came to know that there are N locations where bombs has been planted. X1, X2 …. Xn are the N locations. Among this locations, one X location is the central hub which control all the other Xn-1 location. 1 or more than 1 signal is send to N locations. The decrypted code simplified that the X location is not divisible from the range 2 to X/2.
Your job is to help the Enigma crew by finding the largest X location and how many times it is repeated. So, the Enigma crew can defuse the main hub.
Input Format
The first line contains a single integer, N, representing the number of locations.
In the second line, there are N space-separated integers X1, X2 …..Xn, representing the location of N.
Output Format
There will be two line of output.
First line contain the largest X location.
Second line contain the number of times is repeated.
Constraints
1 ≤ N ≤ 100000
1 ≤ X ≤ 1000000
SAMPLE INPUT
10
1 3 5 17 21 17 5 11 10 40
SAMPLE OUTPUT
17
2
|
def isPrime(num):
if num == 0 or num == 1:
return False
if num == 2:
return True
if num % 2 == 0:
return False
i = 3
while i <= num**0.5+1:
if num%i == 0:
return False
i = i+2
return True
t = int(raw_input())
Arr = map(int, raw_input().strip().split(' '))
mx = -1
for i in Arr:
#print i, isPrime(i)
if i > mx and isPrime(i):
mx = i
print mx
print Arr.count(mx)
|
You are given a string of lower case letters. Your task is to figure out the index of the character on whose removal it will make the string a palindrome. There will always be a valid solution.
In case the string is already a palindrome, then -1 is also a valid answer along with possible indices.
Input Format
The first line contains T, i.e. the number of test cases.
T lines follow, each containing a string.
Output Format
Print the position (0 index) of the letter by removing which the string turns into a palindrome. For a string, such as bcbc,
we can remove b at index 0 or c at index 3. Both answers are accepted.
Constraints
1≤T≤20
1≤ length of string ≤10^6
All characters are Latin lower case indexed.
SAMPLE INPUT
3
aaab
baa
aaa
SAMPLE OUTPUT
3
0
-1
Explanation
In the given input, T = 3,
For input aaab, we can see that removing b from the string makes the string a palindrome, hence the position 3.
For input baa, removing b from the string makes the string palindrome, hence the position 0.
As the string aaa is already a palindrome, you can output 0, 1 or 2 as removal of any of the characters still maintains the palindrome property. Or you can print -1 as this is already a palindrome.
|
for _ in range(input()):
strn = raw_input().strip()
le = len(strn)
if le < 3:
print "0"
continue
index = 0
f = 1
while index < le / 2:
if strn[index] == strn[-1-index]:
index+=1
else:
f = 0
break
if f == 1:
print "-1"
continue
f = 1
spl = index
while index<le/2:
if strn[index] == strn[-2-index]:
index +=1
else:
f = 0
break
if f == 1:
print le - 1 - spl
else:
print spl
|
Mattey has an assignment that he should submit tomorrow. The assignment has one question which asks to write a program to multiply two numbers without using ''* operator. As Mattey finds no interest in this subject, he never listens to classes and so do not know about shift operators.
He comes to you to learn about this topic. You can explain in any manner you wish. But for this question, given N and M, write an equation using left shift operators whose result will be equal to the product N*M.
Input :
First line has T denoting number of test cases.
Next T lines has two integers N,M.
Output :
For each test case print an equation resembling "(N<< p_1) + (N << p_2) + ... + (N << p_k)" (without quotes) where p_1 ≥ p_2 ≥ ... ≥ p_k and k is minimum.
Constraints :
1 ≤ T ≤ 5*10 ^ 4
1 ≤ N,M ≤ 10 ^ 16
SAMPLE INPUT
2
2 1
2 3
SAMPLE OUTPUT
(2<<0)
(2<<1) + (2<<0)
|
T=int(raw_input())
while T>0:
sd=list()
n=list(raw_input().split())
pro=int(n[0])*int(n[1])
c=0
x=int(n[0])
y=int(n[1])
s=x
rem=1
# c=num-1
while y!=0:
te=y%2
sd.extend(str(te))
y=y/2
c=c+1
# print sd[0]
me=0
c=c-1
while c >= 0:
if int(sd[c]) == 1:
if me != 0:
print "+ (%d<<%d)" % (x,c),
else:
print "(%d<<%d)" % (x,c),
me=me+1
c=c-1
print
T=T-1
|
There are N boxes .The i^th box contains ai candies . The frog Om Nom is sitting in box number 1 .Om Nom wants to collect as many candies as he can . However , Om Nom jumps in a peculiar fashion . Om Nom can jump from box number j to box number i only if j | i (j divides i) . Whenever Om Nom lands in a box , he collects all the candies in that box. You have to report the maximum number of Candies that Om Nom can collect for all i from 1 to N if i is the last box that Om Nom visits.See the samples for more details.
Constraints
0 ≤ ai ≤ 100000
1 ≤ N ≤ 100000
Input
The first line contains the number N.
The second line contains the array a , the i^th integer denoting the number of candies in the i^th box.
Output
Print N integers-the i^th integer should be the maximum number of candies that Om Nom can collect if the i^th box is his final box (i.e his sequence of jumps ends at i).
SAMPLE INPUT
5
2 3 1 4 6
SAMPLE OUTPUT
2 5 3 9 8
Explanation
For i=1,Om Nom stops at box number 1 itself and so he can collect only 2 candies.
For i=2,the sequence of jumps is 1 2(array indices)
For i=3,the sequence of jumps is 1 3
For i=4,the sequence of jumps is 1 2 4
For i=5,the sequence of jumps is 1 5
|
import math
n=input()
alist=map(int,raw_input().split())
track=[alist[i]+alist[0] for i in range(n)]
track[0]-=alist[0]
for i in range(2,int(n/2)+2):
x=i+i
while x<=n:
track[x-1]=max(track[x-1],track[i-1]+alist[x-1])
x+=i
for i in track:
print i,
|
Codex is about to start and Ram has not done dinner yet. So, he quickly goes to hostel mess and finds a long queue in front of food counter. But somehow he manages to take the food plate and reaches in front of the queue. The plates are divided into sections such that it has 2 rows and N columns.
Due to the crowd Ram knows that when he will get out of the queue the food will get mixed. So, he don't want to put food in two consecutive sections column wise
but he can put food in two consecutive sections row wise as spacing between the rows is good enough to take food out of the queue safely. If he doesn't like the food, he will not take food. You are given N and you have to tell the number of ways in which food can be taken without getting it mixed.
Input Format:
First line contains T which denotes number of test cases and each test case represents a single line containing the value of N.
Output Format
Output the total ways for each input.
SAMPLE INPUT
2
1
3
SAMPLE OUTPUT
4
25
Explanation
Explanation:
Case 1:
Plate has 2 rows and 1 column each. So, Ram can
Put food in upper section.
Put food in lower section.
Put food in both section.
Do Not food in either section.
Case 2:
Plate has 2 rows and 3 columns. So, possible ways for one row are PNN, PNP, NNN, NPN, NNP where P represents food taken and N represents food not taken.
Total possible ways are 25 because a way to put food in 1 row can correspond
to any of 5 ways on other row.
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
from math import factorial
def ncr(n,r):
if(n<0 or r<0):
return 0
elif(n<r):
return 0
else:
return factorial(n)/(factorial(r)*factorial(n-r))
t = input()
for i in range(0,t):
n = input()
ans = 0
p = 1
i = 1
while(p>0):
ans = ans + p
p = ncr(n,i)
n = n - 1
i = i + 1
print ans*ans
|
PROBLEM SPECIFICATION:
You are given three positive integers 'n' , 'a' and 'b' . In the given range from 1 to 'n' how many distinct numbers are completely divisible by
'a' or 'b' or both?
NOTE: The range includes both 1 and 'n'.
INPUT SPECIFICATION:
You will be given 't' test cases. Each test case will contain three integers 'n' 'a' and 'b'.
OUTPUT SPECIFICATION:
In a single line print the count of numbers that are divisible by 'a' and 'b'.
CONSTRAINTS:
0<t<100
n<10^15
0 ≤ a<10^6
0 ≤ b<10^6
NOTE: In case,if 'a' or 'b' or both of them are zero,print '-1' (without quotes).
SAMPLE INPUT
1
24 5 3
SAMPLE OUTPUT
11
Explanation
Here in the given range there are total 11 distinct numbers that are divisible by 5 or 3 or both.
|
def lcm(x, y):
if x > y:
greater = x
else:
greater = y
while(True):
if((greater % x == 0) and (greater % y == 0)):
lcm = greater
break
greater += 1
return lcm
t = int(raw_input())
for j in range(t):
c = 0
n,a,b = tuple(map(int,raw_input().split()))
if((a == 0) or ( b == 0)):
print(-1)
else:
c = (int(n/a)) + (int(n/b)) -(int(n/(lcm(a,b))))
print(c)
|
As Gudi escapes the room and moves onto to the next floor, the Wizard of UD receives her at the gate!
The wizard questions her intelligence and does not allow her to move ahead unless she answers his puzzle correctly. The wizard says :
Imagine that you are trapped in a dungeon, little girl . And the gate to the exit is guarded by a Monster. The Monster eats strings. Different strings trigger different behaviors of the monster. You know the string that can make it sleep. However, you do not posses it. All you have are N strings scattered on the floor in the dungeon. You can pick up any subset of these and rearrange the characters to form the required subset. You can't pick up a partial string or discard part of any string that you pick.
Answer me, little girl, can you use these strings to form the string that shall make the monster sleep and get you out alive?
Help Gudi answer the Wizard correctly. The strings on the floor have a maximum size K , and the strings that the monster eats have a maximum size L. Each of these strings consists of only lowercase alphabets [ 'a'-'z' ].
Input
First line contains an integer T. T testcases follow.
First line of each test case contains an integer N. N lines follow.Each of these lines contains a string.
Next line contains the string that shall make the monster sleep.
Output
For each testcase, print the answer i.e. either "YES" (without the quotes) or "NO" (without the quotes), in a new line.
Constraints
1 ≤ T ≤ 10
1 ≤ N ≤ 30
1 ≤ K ≤ 30
1 ≤ L ≤ 900
SAMPLE INPUT
2
4
hey
rain
day
wet
draaxiny
4
bump
ud
bish
chau
bichhusa
SAMPLE OUTPUT
NO
YES
Explanation
The sleep string for first case "draaxiny" can not be formed.
The sleep string for second case can be formed using the last two strings.
|
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import sys, math, random, operator
#from string import ascii_lowercase
#from string import ascii_uppercase
from fractions import Fraction, gcd
from decimal import Decimal, getcontext
from itertools import product, permutations, combinations
from Queue import Queue, PriorityQueue
from collections import deque, defaultdict, Counter
getcontext().prec = 100
MOD = 10**9 + 7
INF = float("+inf")
if sys.subversion[0] != "CPython": # PyPy?
raw_input = lambda: sys.stdin.readline().rstrip()
pr = lambda *args: sys.stdout.write(" ".join(str(x) for x in args) + "\n")
epr = lambda *args: sys.stderr.write(" ".join(str(x) for x in args) + "\n")
die = lambda *args: pr(*args) ^ exit(0)
read_str = raw_input
read_strs = lambda: raw_input().split()
read_int = lambda: int(raw_input())
read_ints = lambda: map(int, raw_input().split())
read_float = lambda: float(raw_input())
read_floats = lambda: map(float, raw_input().split())
"---------------------------------------------------------------"
ZERO = (0,) * 26
# def finalize(c):
# return tuple(sorted(c.items()))
def getpos(lst):
ans = set()
for l in xrange(0, len(lst)+1):
for ws in combinations(lst, l):
res = [0] * 26
for w in ws:
add(res, w)
ans.add(tuple(res))
return ans
def Counter(s):
res = [0] * 26
for c in s:
res[ord(c)-0x61] += 1
return tuple(res)
def add(c1, c2):
for i in xrange(len(c1)):
c1[i] += c2[i]
t = read_int()
for t in xrange(t):
n = read_int()
lst = []
for i in xrange(n):
lst.append(Counter(read_str()))
target = Counter(read_str())
if target in lst:
print "YES"
continue
if len(lst) == 1:
print "NO"
continue
h = n / 2
pos1 = getpos(lst[:h])
pos2 = getpos(lst[h:])
for cset in pos1:
good = 1
res = list(target)
for i, (a, b) in enumerate(zip(cset, target)):
if a > b:
good = 0
break
res[i] -= a
if not good:
continue
if tuple(res) in pos2:
print "YES"
break
else:
print "NO"
|
Tak performed the following action N times: rolling two dice. The result of the i-th roll is D_{i,1} and D_{i,2}.
Check if doublets occurred at least three times in a row. Specifically, check if there exists at lease one i such that D_{i,1}=D_{i,2}, D_{i+1,1}=D_{i+1,2} and D_{i+2,1}=D_{i+2,2} hold.
Constraints
* 3 \leq N \leq 100
* 1\leq D_{i,j} \leq 6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
D_{1,1} D_{1,2}
\vdots
D_{N,1} D_{N,2}
Output
Print `Yes` if doublets occurred at least three times in a row. Print `No` otherwise.
Examples
Input
5
1 2
6 6
4 4
3 3
3 2
Output
Yes
Input
5
1 1
2 2
3 4
5 5
6 6
Output
No
Input
6
1 1
2 2
3 3
4 4
5 5
6 6
Output
Yes
|
n=int(input())
ans=0
flg=0
aa="No"
for _ in range(n):
a,b=map(int,input().split())
if a==b:
ans+=1
else:
ans=0
if ans==3:
aa="Yes"
print(aa)
|
There is a cave.
The cave has N rooms and M passages. The rooms are numbered 1 to N, and the passages are numbered 1 to M. Passage i connects Room A_i and Room B_i bidirectionally. One can travel between any two rooms by traversing passages. Room 1 is a special room with an entrance from the outside.
It is dark in the cave, so we have decided to place a signpost in each room except Room 1. The signpost in each room will point to one of the rooms directly connected to that room with a passage.
Since it is dangerous in the cave, our objective is to satisfy the condition below for each room except Room 1.
* If you start in that room and repeatedly move to the room indicated by the signpost in the room you are in, you will reach Room 1 after traversing the minimum number of passages possible.
Determine whether there is a way to place signposts satisfying our objective, and print one such way if it exists.
Constraints
* All values in input are integers.
* 2 \leq N \leq 10^5
* 1 \leq M \leq 2 \times 10^5
* 1 \leq A_i, B_i \leq N\ (1 \leq i \leq M)
* A_i \neq B_i\ (1 \leq i \leq M)
* One can travel between any two rooms by traversing passages.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
If there is no way to place signposts satisfying the objective, print `No`.
Otherwise, print N lines. The first line should contain `Yes`, and the i-th line (2 \leq i \leq N) should contain the integer representing the room indicated by the signpost in Room i.
Examples
Input
4 4
1 2
2 3
3 4
4 2
Output
Yes
1
2
2
Input
6 9
3 4
6 1
2 4
5 3
4 6
1 5
6 2
4 5
5 6
Output
Yes
6
5
5
1
1
|
from collections import deque
N,M=map(int,input().split())
G=[ [] for _ in range(N) ]
for i in range(M):
A,B=map(int,input().split())
A-=1
B-=1
G[A].append(B)
G[B].append(A)
searched=[0]*N
searched[0]=1
ans=[-1]*N
d=deque()
d.append(0)
while(len(d)!=0):
tmp=d.popleft()
for g in G[tmp]:
if searched[g]==0:
searched[g]=1
d.append(g)
ans[g]=tmp
print('Yes')
for i in ans[1:]:
print(i+1)
|
Niwango created a playlist of N songs. The title and the duration of the i-th song are s_i and t_i seconds, respectively. It is guaranteed that s_1,\ldots,s_N are all distinct.
Niwango was doing some work while playing this playlist. (That is, all the songs were played once, in the order they appear in the playlist, without any pause in between.) However, he fell asleep during his work, and he woke up after all the songs were played. According to his record, it turned out that he fell asleep at the very end of the song titled X.
Find the duration of time when some song was played while Niwango was asleep.
Constraints
* 1 \leq N \leq 50
* s_i and X are strings of length between 1 and 100 (inclusive) consisting of lowercase English letters.
* s_1,\ldots,s_N are distinct.
* There exists an integer i such that s_i = X.
* 1 \leq t_i \leq 1000
* t_i is an integer.
Input
Input is given from Standard Input in the following format:
N
s_1 t_1
\vdots
s_{N} t_N
X
Output
Print the answer.
Examples
Input
3
dwango 2
sixth 5
prelims 25
dwango
Output
30
Input
1
abcde 1000
abcde
Output
0
Input
15
ypnxn 279
kgjgwx 464
qquhuwq 327
rxing 549
pmuduhznoaqu 832
dagktgdarveusju 595
wunfagppcoi 200
dhavrncwfw 720
jpcmigg 658
wrczqxycivdqn 639
mcmkkbnjfeod 992
htqvkgkbhtytsz 130
twflegsjz 467
dswxxrxuzzfhkp 989
szfwtzfpnscgue 958
pmuduhznoaqu
Output
6348
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int N = in.nextInt();
String[] S = new String[N];
int[] t = new int[N];
for (int i = 0; i < N; i++) {
S[i] = in.next();
t[i] = in.nextInt();
}
String X = in.next();
int index = -1;
for (int i = 0; i < N; i++) {
if (X.equals(S[i])) {
index = i;
break;
}
}
index++;
int ans = 0;
for (int i = index; i < N; i++) {
ans += t[i];
}
System.out.println(ans);
in.close();
}
}
|
We have a grid with N rows and M columns of squares. Each integer from 1 to NM is written in this grid once. The number written in the square at the i-th row from the top and the j-th column from the left is A_{ij}.
You need to rearrange these numbers as follows:
1. First, for each of the N rows, rearrange the numbers written in it as you like.
2. Second, for each of the M columns, rearrange the numbers written in it as you like.
3. Finally, for each of the N rows, rearrange the numbers written in it as you like.
After rearranging the numbers, you want the number written in the square at the i-th row from the top and the j-th column from the left to be M\times (i-1)+j. Construct one such way to rearrange the numbers. The constraints guarantee that it is always possible to achieve the objective.
Constraints
* 1 \leq N,M \leq 100
* 1 \leq A_{ij} \leq NM
* A_{ij} are distinct.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print one way to rearrange the numbers in the following format:
B_{11} B_{12} ... B_{1M}
:
B_{N1} B_{N2} ... B_{NM}
C_{11} C_{12} ... C_{1M}
:
C_{N1} C_{N2} ... C_{NM}
Here B_{ij} is the number written in the square at the i-th row from the top and the j-th column from the left after Step 1, and C_{ij} is the number written in that square after Step 2.
Examples
Input
3 2
2 6
4 3
1 5
Output
2 6
4 3
5 1
2 1
4 3
5 6
Input
3 4
1 4 7 10
2 5 8 11
3 6 9 12
Output
1 4 7 10
5 8 11 2
9 12 3 6
1 4 3 2
5 8 7 6
9 12 11 10
|
#include <bits/stdc++.h>
#define clr(x) memset(x,0,sizeof x)
#define For(i,a,b) for (int i=(a);i<=(b);i++)
#define Fod(i,b,a) for (int i=(b);i>=(a);i--)
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define fi first
#define se second
#define outval(x) cerr<<#x" = "<<x<<endl
#define outtag(x) cerr<<"-----------------"#x"-----------------\n"
#define outarr(a,L,R) cerr<<#a"["<<L<<".."<<R<<"] = ";\
For(_x,L,R) cerr<<a[_x]<<" ";cerr<<endl;
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair <int,int> pii;
LL read(){
LL x=0,f=0;
char ch=getchar();
while (!isdigit(ch))
f=ch=='-',ch=getchar();
while (isdigit(ch))
x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
return f?-x:x;
}
const int N=105;
int n,m;
int a[N][N],b[N];
int g[N][N];
int vis[N],Match[N];
int dfs(int x){
For(y,1,n)
if (g[x][y]&&!vis[y]){
vis[y]=1;
if (!Match[y]||dfs(Match[y])){
Match[y]=x;
return 1;
}
}
return 0;
}
int main(){
n=read(),m=read();
For(i,1,n)
For(j,1,m)
a[i][j]=read();
For(c,1,m){
clr(g);
For(i,1,n)
For(j,c,m){
int r=(a[i][j]+m-1)/m;
if (!g[i][r])
g[i][r]=j;
}
clr(Match);
For(i,1,n){
clr(vis);
assert(dfs(i));
}
For(i,1,n){
int r=Match[i];
swap(a[r][c],a[r][g[r][i]]);
}
}
For(i,1,n){
For(j,1,m)
printf("%d ",a[i][j]);
puts("");
}
For(i,1,m){
For(j,1,n)
b[j]=a[j][i];
sort(b+1,b+n+1);
For(j,1,n)
a[j][i]=b[j];
}
For(i,1,n){
For(j,1,m)
printf("%d ",a[i][j]);
puts("");
}
return 0;
}
|
You are given three integers A, B and C.
Determine if there exists an equilateral triangle whose sides have lengths A, B and C.
Constraints
* All values in input are integers.
* 1 \leq A,B,C \leq 100
Input
Input is given from Standard Input in the following format:
A B C
Output
If there exists an equilateral triangle whose sides have lengths A, B and C, print `Yes`; otherwise, print `No`.
Examples
Input
2 2 2
Output
Yes
Input
3 4 5
Output
No
|
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
int A = scanner.nextInt();
int B= scanner.nextInt();
int C = scanner.nextInt();
if(A == B && B == C){
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
|
Amidakuji is a traditional method of lottery in Japan.
To make an amidakuji, we first draw W parallel vertical lines, and then draw horizontal lines that connect them. The length of each vertical line is H+1 [cm], and the endpoints of the horizontal lines must be at 1, 2, 3, ..., or H [cm] from the top of a vertical line.
A valid amidakuji is an amidakuji that satisfies the following conditions:
* No two horizontal lines share an endpoint.
* The two endpoints of each horizontal lines must be at the same height.
* A horizontal line must connect adjacent vertical lines.
<image>
Find the number of the valid amidakuji that satisfy the following condition, modulo 1\ 000\ 000\ 007: if we trace the path from the top of the leftmost vertical line to the bottom, always following horizontal lines when we encounter them, we reach the bottom of the K-th vertical line from the left.
For example, in the following amidakuji, we will reach the bottom of the fourth vertical line from the left.
<image>
Constraints
* H is an integer between 1 and 100 (inclusive).
* W is an integer between 1 and 8 (inclusive).
* K is an integer between 1 and W (inclusive).
Input
Input is given from Standard Input in the following format:
H W K
Output
Print the number of the amidakuji that satisfy the condition, modulo 1\ 000\ 000\ 007.
Examples
Input
1 3 2
Output
1
Input
1 3 1
Output
2
Input
2 3 3
Output
1
Input
2 3 1
Output
5
Input
7 1 1
Output
1
Input
15 8 5
Output
437760187
|
H,W,K = map(int,input().split())
dp = []
for i in range(H+1):
L = [0]*W
dp.append(L)
fb = [1,1]
for i in range(W-2):
fb.append(fb[i]+fb[i+1])
dp[0][0] = 1
if W != 1:
for i in range(1,H+1):
for j in range(W):
if 1 <= j <= W-2:
dp[i][j] = dp[i-1][j-1]*fb[j-1]*fb[W-j-1]+dp[i-1][j]*fb[j]*fb[W-j-1]+dp[i-1][j+1]*fb[j]*fb[W-j-2]
elif j == 0:
dp[i][j] = dp[i-1][j]*fb[W-1]+dp[i-1][j+1]*fb[W-2]
else:
dp[i][j] = dp[i-1][j]*fb[W-1]+dp[i-1][j-1]*fb[W-2]
else:
dp[H][0] = 1
print(dp[H][K-1]%(10**9+7))
|
Akaki, a patissier, can make N kinds of doughnut using only a certain powder called "Okashi no Moto" (literally "material of pastry", simply called Moto below) as ingredient. These doughnuts are called Doughnut 1, Doughnut 2, ..., Doughnut N. In order to make one Doughnut i (1 ≤ i ≤ N), she needs to consume m_i grams of Moto. She cannot make a non-integer number of doughnuts, such as 0.5 doughnuts.
Now, she has X grams of Moto. She decides to make as many doughnuts as possible for a party tonight. However, since the tastes of the guests differ, she will obey the following condition:
* For each of the N kinds of doughnuts, make at least one doughnut of that kind.
At most how many doughnuts can be made here? She does not necessarily need to consume all of her Moto. Also, under the constraints of this problem, it is always possible to obey the condition.
Constraints
* 2 ≤ N ≤ 100
* 1 ≤ m_i ≤ 1000
* m_1 + m_2 + ... + m_N ≤ X ≤ 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N X
m_1
m_2
:
m_N
Output
Print the maximum number of doughnuts that can be made under the condition.
Examples
Input
3 1000
120
100
140
Output
9
Input
4 360
90
90
90
90
Output
4
Input
5 3000
150
130
150
130
110
Output
26
|
N,X = map(int, input().split())
M = [int(input()) for _ in range(N)]
X = X - sum(M)
print(N + X//min(M))
|
Ringo has a tree with N vertices. The i-th of the N-1 edges in this tree connects Vertex A_i and Vertex B_i and has a weight of C_i. Additionally, Vertex i has a weight of X_i.
Here, we define f(u,v) as the distance between Vertex u and Vertex v, plus X_u + X_v.
We will consider a complete graph G with N vertices. The cost of its edge that connects Vertex u and Vertex v is f(u,v). Find the minimum spanning tree of G.
Constraints
* 2 \leq N \leq 200,000
* 1 \leq X_i \leq 10^9
* 1 \leq A_i,B_i \leq N
* 1 \leq C_i \leq 10^9
* The given graph is a tree.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 X_2 ... X_N
A_1 B_1 C_1
A_2 B_2 C_2
:
A_{N-1} B_{N-1} C_{N-1}
Output
Print the cost of the minimum spanning tree of G.
Examples
Input
4
1 3 5 1
1 2 1
2 3 2
3 4 3
Output
22
Input
6
44 23 31 29 32 15
1 2 10
1 3 12
1 4 16
4 5 8
4 6 15
Output
359
Input
2
1000000000 1000000000
2 1 1000000000
Output
3000000000
|
#include<cstdio>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
typedef long long ll;
struct edge
{
ll x,y;
bool operator<(const edge&z)const
{
return x>z.x||(x==z.x&&y<z.y);
}
}h,v;
struct edge2
{
ll x,y,z;
}e[400005];
ll n,i,x,y,z,tot=0,ev[3][400005],dsu[200005],dis[400005],pre[400005],ans=0,fx,fy;
const ll inf=1e18;
priority_queue<edge>q;
vector<edge>s[400005];
ll getf(ll p){return dsu[p]==p?p:dsu[p]=getf(dsu[p]);}
bool cmp(edge2 a,edge2 b)
{
if(a.z!=b.z)return a.z<b.z;
if(a.x!=b.x)return a.x<b.x;
return a.y<b.y;
}
int main()
{
scanf("%lld",&n);
for(i=1;i<=n;i++)
{
dsu[i]=i;
q.push((edge){0,n+i});
pre[i]=i;pre[n+i]=n+i;
dis[i]=inf;dis[n+i]=0;
}
for(i=1;i<=n;i++)
{
scanf("%lld",&x);
s[i].push_back((edge){n+i,x});
s[n+i].push_back((edge){i,x});
ev[0][i]=i;ev[1][i]=n+i;ev[2][i]=x;
}
for(i=1;i<n;i++)
{
scanf("%lld%lld%lld",&x,&y,&z);
s[x].push_back((edge){y,z});
s[y].push_back((edge){x,z});
ev[0][n+i]=x;ev[1][n+i]=y;ev[2][n+i]=z;
}
while(!q.empty())
{
h=q.top();
q.pop();
if(h.x>dis[h.y])continue;
for(i=0;i<s[h.y].size();i++)
{
v=s[h.y][i];
if(dis[v.x]>dis[h.y]+v.y)
{
dis[v.x]=dis[h.y]+v.y;
pre[v.x]=pre[h.y];
q.push((edge){dis[v.x],v.x});
}
}
}
for(i=1;i<=2*n-1;i++)e[i]=(edge2){pre[ev[0][i]]-n,pre[ev[1][i]]-n,ev[2][i]+dis[ev[0][i]]+dis[ev[1][i]]};
sort(e+1,e+2*n,cmp);
for(i=1;i<=2*n-1;i++)
{
fx=getf(e[i].x);fy=getf(e[i].y);
if(fx==fy)continue;
ans+=e[i].z;
dsu[fx]=fy;
}
printf("%lld\n",ans);
return 0;
}
|
AtCoDeer has three cards, one red, one green and one blue.
An integer between 1 and 9 (inclusive) is written on each card: r on the red card, g on the green card and b on the blue card.
We will arrange the cards in the order red, green and blue from left to right, and read them as a three-digit integer.
Is this integer a multiple of 4?
Constraints
* 1 ≤ r, g, b ≤ 9
Input
Input is given from Standard Input in the following format:
r g b
Output
If the three-digit integer is a multiple of 4, print `YES` (case-sensitive); otherwise, print `NO`.
Examples
Input
4 3 2
Output
YES
Input
2 3 4
Output
NO
|
#include <iostream>
using namespace std;
int main(){
int r,g,b;
cin>>r>>g>>b;
int a=10*g+b;
if(0==a%4){
cout<<"YES";
}else{
cout<<"NO";
}
}
|
There are N people, conveniently numbered 1 through N. They were standing in a row yesterday, but now they are unsure of the order in which they were standing. However, each person remembered the following fact: the absolute difference of the number of the people who were standing to the left of that person, and the number of the people who were standing to the right of that person. According to their reports, the difference above for person i is A_i.
Based on these reports, find the number of the possible orders in which they were standing. Since it can be extremely large, print the answer modulo 10^9+7. Note that the reports may be incorrect and thus there may be no consistent order. In such a case, print 0.
Constraints
* 1≦N≦10^5
* 0≦A_i≦N-1
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the number of the possible orders in which they were standing, modulo 10^9+7.
Examples
Input
5
2 4 4 0 2
Output
4
Input
7
6 4 0 2 4 0 2
Output
0
Input
8
7 5 1 1 7 3 5 3
Output
16
|
#include<cstdio>
using namespace std;
typedef long long ll;
#define MOD 1000000007
#define rep(i, n) for(int i = 0; i < n; i++)
int n, a[100000];
int c[100000];
ll mod_pow(ll x, int n){
if(n == 0) return 1;
return x * mod_pow(x, n - 1) % MOD;
}
ll solve(){
rep(i, n){
if(!(n ^ (a[i] & 1))) return 0;
if(a[i] >= n) return 0;
}
if(c[0] > 1) return 0;
rep(i, n) if(c[i] > 2) return 0;
return mod_pow(2, n / 2);
}
int main(){
scanf("%d", &n);
rep(i, n){ scanf("%d", &a[i]); c[a[i]]++; }
printf("%lld\n", solve());
return 0;
}
|
For integers b (b \geq 2) and n (n \geq 1), let the function f(b,n) be defined as follows:
* f(b,n) = n, when n < b
* f(b,n) = f(b,\,{\rm floor}(n / b)) + (n \ {\rm mod} \ b), when n \geq b
Here, {\rm floor}(n / b) denotes the largest integer not exceeding n / b, and n \ {\rm mod} \ b denotes the remainder of n divided by b.
Less formally, f(b,n) is equal to the sum of the digits of n written in base b. For example, the following hold:
* f(10,\,87654)=8+7+6+5+4=30
* f(100,\,87654)=8+76+54=138
You are given integers n and s. Determine if there exists an integer b (b \geq 2) such that f(b,n)=s. If the answer is positive, also find the smallest such b.
Constraints
* 1 \leq n \leq 10^{11}
* 1 \leq s \leq 10^{11}
* n,\,s are integers.
Input
The input is given from Standard Input in the following format:
n
s
Output
If there exists an integer b (b \geq 2) such that f(b,n)=s, print the smallest such b. If such b does not exist, print `-1` instead.
Examples
Input
87654
30
Output
10
Input
87654
138
Output
100
Input
87654
45678
Output
-1
Input
31415926535
1
Output
31415926535
Input
1
31415926535
Output
-1
|
n=int(input())
s=int(input())
b_ans=1
if n==s:
b_ans=n+1
if b_ans==1:
for b in range(2,int(n**0.5)+1):
nn=n
st=[]
while(nn>0):
st.append(nn%b)
nn=(nn-st[-1])/b
if sum(st)==s:
b_ans=b
break
if b_ans==1:
for p in range(int(n**0.5),0,-1):
b=(n-s+p)/p
if b.is_integer() and 0<=s-p<b and b>n**0.5:
b_ans=int(b)
break
if b_ans!=1:
print(b_ans)
else:
print(-1)
|
A smelt fishing tournament was held at Lake Hibara. It seems that catch and release is recommended this time.
Create a program that reads the participant number and the number of fish caught or released in order as one event, and outputs the participant number and the number of animals that have acquired the most smelt immediately after each event. please. If there are multiple participants with the highest number of participants (or if all participants are 0), output the one with the lowest participant number.
input
The input is given in the following format.
n q
a1 v1
a2 v2
::
aq vq
n (1 ≤ n ≤ 1000000) represents the number of participants and q (1 ≤ q ≤ 100000) represents the number of events. ai (1 ≤ ai ≤ n) vi (-100 ≤ vi ≤ 100) indicates that participant ai acquired or released vi at the i-th event. For vi, a positive value indicates acquisition, a negative value indicates release, and 0 is never given.
output
For each event, the participant number and the number of participants who have acquired the most smelt at hand are output on one line separated by one blank.
Example
Input
3 5
1 4
2 5
1 3
3 6
2 7
Output
1 4
2 5
1 7
1 7
2 12
|
#include <iostream>
#include <algorithm>
#include <map>
#include <vector>
#include <queue>
using namespace std;
typedef long long lli;
typedef pair<int,int> T;
const int MAXN = 1000006;
const int INF = 1<<29;
class RMQ {
private:
int n;
T dat[4*MAXN-1];
public:
void init(int _n = MAXN, T a = T(INF,INF)) {
n = 1;
while(n < _n) n *= 2;
for(int i = 0; i < 2*n-1; ++i) dat[i] = a;
}
void update(int k, T a) {
k += n-1;
dat[k] = a;
while(k > 0) {
k = (k - 1) / 2;
dat[k] = min(dat[k*2+1], dat[k*2+2]);
}
}
T at(int k) {
return dat[k+n-1];
}
T query(int a, int b, int k = 0, int l = 0, int r = 0) {
if(k == 0) {
l = 0; r = n;
}
if(r <= a || b <= l) return T(INF,INF);
if(a <= l && r <= b) return dat[k];
else {
T v1 = query(a, b, k*2+1, l, (l+r)/2);
T v2 = query(a, b, k*2+2, (l+r)/2, r);
return min(v1, v2);
}
}
};
RMQ rmq;
int main() {
int n, q;
while(cin >> n >> q) {
rmq.init(n);
for(int i = 0; i < n; ++i) {
rmq.update(i, make_pair(0,i));
}
for(int i = 0; i < q; ++i) {
int a, v;
cin >> a >> v;
--a;
pair<int,int> p = rmq.at(a);
rmq.update(a, T(p.first-v, a));
p = rmq.query(0,n);
cout << p.second+1 << " " << -p.first << endl;
}
}
return 0;
}
|
In Aizuwakamatsu Village, which is located far north of Aizuwakamatsu City, a bridge called "Yabashi" is the only way to move to the surrounding villages. Despite the large number of passers-by, the bridge is so old that it is almost broken.
<image>
Yabashi is strong enough to withstand up to 150 [kg]. For example, 80 [kg] people and 50 [kg] people can cross at the same time, but if 90 [kg] people start crossing while 80 [kg] people are crossing, Yabashi will It will break.
If the Ya Bridge is broken, the people of Aizu Komatsu Village will lose the means to move to the surrounding villages. So, as the only programmer in the village, you decided to write a program to determine if the bridge would break based on how you crossed the bridge, in order to protect the lives of the villagers.
Number of passersby crossing the bridge n (1 ≤ n ≤ 100), weight of each passer mi (1 ≤ mi ≤ 100), time to start crossing the bridge ai, time to finish crossing bi (0 ≤ ai, bi <231) If the bridge does not break, output "OK", and if it breaks, output "NG". If the total weight of passers-by on the bridge exceeds 150 [kg], the bridge will be destroyed. Also, at the time of ai, the passersby are on the bridge, but at the time of bi, they are not on the bridge.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
m1 a1 b1
m2 a2 b2
::
mn an bn
The number of datasets does not exceed 1200.
Output
For each input dataset, prints on one line whether the bridge will break or not.
Example
Input
3
80 0 30
50 5 25
90 27 50
3
80 0 30
70 5 25
71 30 50
0
Output
NG
OK
|
#include<bits/stdc++.h>
#define rep(i,n)for(ll i=0;i<n;i++)
using namespace std;
typedef long long ll;
ll m[100], a[100], b[100];
int main() {
ll n;
while (scanf("%lld", &n), n) {
vector<ll>v;
rep(i, n) {
scanf("%lld%lld%lld", &m[i], &a[i], &b[i]);
v.push_back(a[i]);
}
for (ll i : v) {
ll cnt = 0;
rep(j, n) {
if (a[j] <= i&&i < b[j])cnt += m[j];
}
if (cnt > 150) {
puts("NG");
goto p;
}
}
puts("OK");
p:;
}
}
|
Alice is spending his time on an independent study to apply to the Nationwide Mathematics Contest. This year’s theme is "Beautiful Sequence." As Alice is interested in the working of computers, she wants to create a beautiful sequence using only 0 and 1. She defines a "Beautiful" sequence of length $N$ that consists only of 0 and 1 if it includes $M$ successive array of 1s as its sub-sequence.
Using his skills in programming, Alice decided to calculate how many "Beautiful sequences" she can generate and compile a report on it.
Make a program to evaluate the possible number of "Beautiful sequences" given the sequence length $N$ and sub-sequence length $M$ that consists solely of 1. As the answer can be extremely large, divide it by $1,000,000,007 (= 10^9 + 7)$ and output the remainder.
Input
The input is given in the following format.
$N$ $M$
The input line provides the length of sequence $N$ ($1 \leq N \leq 10^5$) and the length $M$ ($1 \leq M \leq N$) of the array that solely consists of 1s.
Output
Output the number of Beautiful sequences in a line.
Examples
Input
4 3
Output
3
Input
4 2
Output
8
|
#include <iostream>
#include <vector>
#include <iostream>
using namespace std;
using int64 = long long int;
const int64 MOD = 1000000007;
int64 mod_pow(int64 A, int64 k) {
int64 res = 1;
for(; k>0; k>>=1) {
if(k & 1) (res *= A) %= MOD;
(A *= A) %= MOD;
}
return res;
}
int64 dp[100010];
int main() {
int N, M; cin >> N >> M;
dp[0] = 1;
for(int i=0; i<N; i++) {
dp[i+1] = dp[i] - (i-M < 0 ? 0 : dp[i-M]);
(dp[i+1] += MOD) %= MOD;
// fprintf(stderr, "dp[%d] = %lld\n", i+1, dp[i+1]);
(dp[i+1] += dp[i]) %= MOD;
}
int64 ans = mod_pow(2, N);
int64 sub = (dp[N] - dp[N-M] + MOD) % MOD;
(ans += MOD - sub) %= MOD;
cout << ans << endl;
return 0;
}
|
In 2215 A.D., a war between two planets, ACM and ICPC, is being more and more intense.
ACM introduced new combat planes. These planes have a special system that is called Graze, and fighting power of a plane increases when it is close to energy bullets that ICPC combat planes shoot.
Both combat planes and energy bullets have a shape of a sphere with a radius of R. Precisely, fighting power of a plane is equivalent to the number of energy bullet where distance from the plane is less than or equals to 2R.
You, helper of captain of intelligence units, are asked to analyze a war situation. The information given to you is coordinates of AN combat planes and BN energy bullets. Additionally, you know following things:
* All combat planes and energy bullet has same z-coordinates. In other word, z-coordinate can be ignored.
* No two combat planes, no two energy bullets, and no pair of combat plane and energy bullet collide (i.e. have positive common volume) each other.
Your task is to write a program that outputs total fighting power of all combat planes.
Constraints
* Jude data includes at most 20 data sets.
* 1 ≤ AN, BN ≤ 100000
* 0 < R ≤ 10
* 0 ≤ (coordinate values) < 10000
Input
Input file consists of a number of data sets. One data set is given in following format:
AN BN R
XA1 YA1
XA2 YA2
:
XAAN YAAN
XB1 YB1
XB2 YB2
:
XBBN YBBN
AN, BN, R are integers that describe the number of combat planes, energy bullets, and their radius respectively.
Following AN lines indicate coordinates of the center of combat planes. Each line has two integers that describe x-coordinate and y-coordinate.
Following BN lines indicate coordinates of the center of energy bullets, in the same format as that of combat planes.
Input ends when AN = BN = 0. You should output nothing for this case.
Output
For each data set, output the total fighting power.
Example
Input
2 2 1
0 0
0 4
2 2
2 8
0 0 0
Output
2
|
//32
#include<iostream>
#include<vector>
#include<utility>
using namespace std;
typedef pair<int,int> pii;
#define S(X) ((X)*(X))
int main(){
for(int a,b,r;cin>>a>>b>>r,a|b|r;){
int x[100000],y[100000];
for(int i=0;i<a;i++){
cin>>x[i]>>y[i];
}
vector<pii> v[250][250];
for(int i=0;i<b;i++){
int xb,yb;
cin>>xb>>yb;
v[yb/40][xb/40].push_back(pii(yb,xb));
}
int s=0;
for(int i=0;i<a;i++){
int yy=y[i]/40,xx=x[i]/40;
for(int j=-1;j<=1;j++){
for(int k=-1;k<=1;k++){
int yt=yy+j,xt=xx+k;
if(0<=yt&&yt<250&&0<=xt&&xt<250){
for(int l=0;l<v[yt][xt].size();l++){
s+=S(y[i]-v[yt][xt][l].first)+S(x[i]-v[yt][xt][l].second)<=S(4*r);
}
}
}
}
}
cout<<s<<endl;
}
return 0;
}
|
Pablo Squarson is a well-known cubism artist. This year's theme for Pablo Squarson is "Squares". Today we are visiting his studio to see how his masterpieces are given birth.
At the center of his studio, there is a huuuuuge table and beside it are many, many squares of the same size. Pablo Squarson puts one of the squares on the table. Then he places some other squares on the table in sequence. It seems his methodical nature forces him to place each square side by side to the one that he already placed on, with machine-like precision.
Oh! The first piece of artwork is done. Pablo Squarson seems satisfied with it. Look at his happy face.
Oh, what's wrong with Pablo? He is tearing his hair! Oh, I see. He wants to find a box that fits the new piece of work but he has trouble figuring out its size. Let's help him!
Your mission is to write a program that takes instructions that record how Pablo made a piece of his artwork and computes its width and height. It is known that the size of each square is 1. You may assume that Pablo does not put a square on another.
I hear someone murmured "A smaller box will do". No, poor Pablo, shaking his head, is grumbling "My square style does not seem to be understood by illiterates".
<image>
Input
The input consists of a number of datasets. Each dataset represents the way Pablo made a piece of his artwork. The format of a dataset is as follows.
> N
n1 d1
n2 d2
...
nN-1 dN-1
The first line contains the number of squares (= N) used to make the piece of artwork. The number is a positive integer and is smaller than 200.
The remaining (N-1) lines in the dataset are square placement instructions. The line "ni di" indicates placement of the square numbered i (≤ N-1). The rules of numbering squares are as follows. The first square is numbered "zero". Subsequently placed squares are numbered 1, 2, ..., (N-1). Note that the input does not give any placement instruction to the first square, which is numbered zero.
A square placement instruction for the square numbered i, namely "ni di", directs it to be placed next to the one that is numbered ni, towards the direction given by di, which denotes leftward (= 0), downward (= 1), rightward (= 2), and upward (= 3).
For example, pieces of artwork corresponding to the four datasets shown in Sample Input are depicted below. Squares are labeled by their numbers.
<image>
The end of the input is indicated by a line that contains a single zero.
Output
For each dataset, output a line that contains the width and the height of the piece of artwork as decimal numbers, separated by a space. Each line should not contain any other characters.
Sample Input
1
5
0 0
0 1
0 2
0 3
12
0 0
1 0
2 0
3 1
4 1
5 1
6 2
7 2
8 2
9 3
10 3
10
0 2
1 2
2 2
3 2
2 1
5 1
6 1
7 1
8 1
0
Output for the Sample Input
1 1
3 3
4 4
5 6
Example
Input
1
5
0 0
0 1
0 2
0 3
12
0 0
1 0
2 0
3 1
4 1
5 1
6 2
7 2
8 2
9 3
10 3
10
0 2
1 2
2 2
3 2
2 1
5 1
6 1
7 1
8 1
0
Output
1 1
3 3
4 4
5 6
|
import sys
import collections
while True:
N = int(sys.stdin.readline())
if N == 0:
break
pos = {0:(0, 0)}
for i in xrange(N - 1):
n, d = map(int, sys.stdin.readline().split())
if d == 0:
pos[i + 1] = (pos[n][0] - 1, pos[n][1])
elif d == 1:
pos[i + 1] = (pos[n][0], pos[n][1] - 1)
elif d == 2:
pos[i + 1] = (pos[n][0] + 1, pos[n][1])
elif d == 3:
pos[i + 1] = (pos[n][0], pos[n][1] + 1)
max_x = min_x = max_y = min_y = 0
for x, y in pos.values():
max_x = max(x, max_x)
min_x = min(x, min_x)
max_y = max(y, max_y)
min_y = min(y, min_y)
print max_x - min_x + 1, max_y - min_y + 1
|
"Balloons should be captured efficiently", the game designer says. He is designing an oldfashioned game with two dimensional graphics. In the game, balloons fall onto the ground one after another, and the player manipulates a robot vehicle on the ground to capture the balloons. The player can control the vehicle to move left or right, or simply stay. When one of the balloons reaches the ground, the vehicle and the balloon must reside at the same position, otherwise the balloon will burst and the game ends.
<image>
Figure B.1: Robot vehicle and falling balloons
The goal of the game is to store all the balloons into the house at the left end on the game field. The vehicle can carry at most three balloons at a time, but its speed changes according to the number of the carrying balloons. When the vehicle carries k balloons (k = 0, 1, 2, 3), it takes k+1 units of time to move one unit distance. The player will get higher score when the total moving distance of the vehicle is shorter.
Your mission is to help the game designer check game data consisting of a set of balloons. Given a landing position (as the distance from the house) and a landing time of each balloon, you must judge whether a player can capture all the balloons, and answer the minimum moving distance needed to capture and store all the balloons. The vehicle starts from the house. If the player cannot capture all the balloons, you must identify the first balloon that the player cannot capture.
Input
The input is a sequence of datasets. Each dataset is formatted as follows.
n
p1 t1
.
.
.
pn tn
The first line contains an integer n, which represents the number of balloons (0 < n ≤ 40). Each of the following n lines contains two integers pi and ti (1 ≤ i ≤ n) separated by a space. pi and ti represent the position and the time when the i-th balloon reaches the ground (0 < pi ≤ 100, 0 < ti ≤ 50000). You can assume ti < tj for i < j. The position of the house is 0, and the game starts from the time 0.
The sizes of the vehicle, the house, and the balloons are small enough, and should be ignored. The vehicle needs 0 time for catching the balloons or storing them into the house. The vehicle can start moving immediately after these operations.
The end of the input is indicated by a line containing a zero.
Output
For each dataset, output one word and one integer in a line separated by a space. No extra characters should occur in the output.
* If the player can capture all the balloons, output "OK" and an integer that represents the minimum moving distance of the vehicle to capture and store all the balloons.
* If it is impossible for the player to capture all the balloons, output "NG" and an integer k such that the k-th balloon in the dataset is the first balloon that the player cannot capture.
Example
Input
2
10 100
100 270
2
10 100
100 280
3
100 150
10 360
40 450
3
100 150
10 360
40 440
2
100 10
50 200
2
100 100
50 110
1
15 10
4
1 10
2 20
3 100
90 200
0
Output
OK 220
OK 200
OK 260
OK 280
NG 1
NG 2
NG 1
OK 188
|
#include <bits/stdc++.h>
using namespace std;
// よこ, たて
vector<pair<int, int>> v;
int ok=100000000;
int ng=-1;
void msearch(int i, int p, int bn, int t, int x, int move){
if(move<ok){
if(i==v.size()){
if(ok>move+x){
ok=move+x;
}
}else if(x==0){
if(t+v[i].first>v[i].second){
if(ng<p){
ng=p;
}
}else{
t=v[i].second;
x=v[i].first;
move+=v[i].first;
msearch(i+1, p+1, bn+1, t, x, move);
}
}else{
//cout<<"x: "<<x<<" bn: "<<bn<<" vfront: "<<v[i].first<<" "<<v[i].second<<" t: "<<t<<endl;
if(abs(x-v[i].first)*(bn+1)+t<=v[i].second && bn<3){
msearch(i+1, p+1, bn+1, v[i].second, v[i].first, move+abs(x-v[i].first));
}
if(t+x*(bn+1)+v[i].first>v[i].second){
if(ng<p){
ng=p;
}
}else{
msearch(i+1, p+1, 1, v[i].second, v[i].first, move+x+v[i].first);
}
}
}
}
int main(void){
// Your code here!
int n;
while(cin>>n,n){
v.resize(n);
for(auto& a:v){
cin>>a.first>>a.second;
}
msearch(0, 1, 0, 0, 0, (unsigned long long)0);
if(ok==100000000){
cout<<"NG "<<ng<<endl;
}else{
cout<<"OK "<<ok<<endl;
}
v.clear();
ok=100000000;
ng=-1;
}
}
|
Taro had his own personal computer and set a password for login. However, Taro inadvertently forgot the password. Then, remembering that there was a piece of paper with the password written down, Taro found the paper and was surprised to see it. The paper was cut and there were only fragments, and there were some stains that made it unreadable. Taro decided to guess the password by referring to the memo.
Constraints
* The length of the character strings A and B is 1 to 1000 characters.
* The length of the B string does not exceed the length of the A string.
Input
String A
String B
Output
Output "Yes" or "No" on one line.
Examples
Input
ABCDE
ABC
Output
Yes
Input
KUSATSU
KSATSU
Output
No
Input
ABCABC
ACBA_B
Output
No
Input
RUPCUAPC
__PC
Output
Yes
Input
AIZU
_A
Output
No
|
#include<bits/stdc++.h>
using namespace std;
#define lint long long
#define P pair<int, int>
#define LLP pair<long long, long long>
#define REP(i, x, n) for(int i = (x), i##_len = (int)(n) ; i < i##_len ; ++i)
#define rep(i, n) for(int i = 0, i##_len = (int)(n) ; i < i##_len ; ++i)
#define repr(i, n) for(int i = (int)(n) - 1 ; i >= 0 ; --i)
#define SORT(x) sort((x).begin(), (x).end())
#define SORT_INV(x) sort((x).rbegin(), (x).rend())
const int IINF = 1e9 + 100;
const long long LLINF = 2e18 + 129;
const long long MOD = 1e9 + 7;
const int dx4[] = {1, 0, -1, 0}, dy4[] = {0, 1, 0, -1};
const int dx8[] = {1, 1, 0, -1, -1, -1, 0, 1}, dy8[] = {0, -1, -1, -1, 0, 1, 1, 1};
const double EPS = 1e-8;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
string a, b;
cin >> a >> b;
int n = (int)a.size() - (int)b.size() + 1;
bool ans = false;
rep(i, n){
bool flag = true;
rep(j, b.size()){
flag &= (a[i + j] == b[j] || b[j] == '_');
}
ans |= flag;
}
if(ans){
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
return 0;
}
|
Brian Jones is an undergraduate student at Advanced College of Metropolitan. Recently he was given an assignment in his class of Computer Science to write a program that plays a dealer of blackjack.
Blackjack is a game played with one or more decks of playing cards. The objective of each player is to have the score of the hand close to 21 without going over 21. The score is the total points of the cards in the hand. Cards from 2 to 10 are worth their face value. Face cards (jack, queen and king) are worth 10 points. An ace counts as 11 or 1 such a way the score gets closer to but does not exceed 21. A hand of more than 21 points is called bust, which makes a player automatically lose. A hand of 21 points with exactly two cards, that is, a pair of an ace and a ten-point card (a face card or a ten) is called a blackjack and treated as a special hand.
The game is played as follows. The dealer first deals two cards each to all players and the dealer himself. In case the dealer gets a blackjack, the dealer wins and the game ends immediately. In other cases, players that have blackjacks win automatically. The remaining players make their turns one by one. Each player decides to take another card (hit) or to stop taking (stand) in his turn. He may repeatedly hit until he chooses to stand or he busts, in which case his turn is over and the next player begins his play. After all players finish their plays, the dealer plays according to the following rules:
* Hits if the score of the hand is 16 or less.
* Also hits if the score of the hand is 17 and one of aces is counted as 11.
* Stands otherwise.
Players that have unbusted hands of higher points than that of the dealer win. All players that do not bust win in case the dealer busts. It does not matter, however, whether players win or lose, since the subject of the assignment is just to simulate a dealer.
By the way, Brian is not good at programming, thus the assignment is a very hard task for him.
So he calls you for help, as you are a good programmer. Your task is to write a program that counts the score of the dealer’s hand after his play for each given sequence of cards.
Input
The first line of the input contains a single positive integer N , which represents the number of test cases. Then N test cases follow.
Each case consists of two lines. The first line contains two characters, which indicate the cards in the dealer’s initial hand. The second line contains eight characters, which indicate the top eight cards in the pile after all players finish their plays.
A character that represents a card is one of A, 2, 3, 4, 5, 6, 7, 8, 9, T, J, Q and K, where A is an ace, T a ten, J a jack, Q a queen and K a king.
Characters in a line are delimited by a single space.
The same cards may appear up to four times in one test case. Note that, under this condition, the dealer never needs to hit more than eight times as long as he or she plays according to the rule described above.
Output
For each case, print on a line “blackjack” if the dealer has a blackjack; “bust” if the dealer busts; the score of the dealer’s hand otherwise.
Example
Input
4
5 4
9 2 8 3 7 4 6 5
A J
K Q J T 9 8 7 6
T 4
7 J A 6 Q T K 7
2 2
2 3 4 K 2 3 4 K
Output
18
blackjack
21
bust
|
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws Exception {
// BufferedReader stdIn = new BufferedReader(new FileReader(new
// File("c:\\2024-input.txt")));
BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
String s;
while ((s = stdIn.readLine()) != null) {
int setc = Integer.valueOf(s);
for (int i = 0; i < setc; i++) {
// read initial cards and deal cards
String ini = stdIn.readLine();
String deal = stdIn.readLine();
String[] inis = ini.split(" ");
String[] deals = deal.split(" ");
// process dealers action
Dealer d = new Dealer(inis);
d.action(deals);
}
}
System.exit(0);
}
}
class Dealer {
private int score = 0;
private int ace11 = 0;
private int piece = 0;
// first 2 cards
Dealer(String[] inis) {
this.addcard(inis[0]);
this.addcard(inis[1]);
}
// hits card until stand, and output result. otherwise
public void action(String[] deals) {
for (int i = 0; this.isHit(); i++)
this.addcard(deals[i]);
;
if (score == 21 && piece == 2)
System.out.println("blackjack");
else if (score > 21)
System.out.println("bust");
else
System.out.println(score);
}
// judge hits or stand
private boolean isHit() {
if (score > 21 && ace11 > 0) {
score -= 10;
--ace11;
return (isHit());
}
if (score == 17 && ace11 > 0)
return true;
if (score > 16)
return false;
else
return true;
}
// hits one card
private void addcard(String s) {
switch (s) {
case ("A"):
score += 11;
ace11 += 1;
break;
case ("T"):
case ("J"):
case ("Q"):
case ("K"):
score += 10;
break;
default:
score += Integer.valueOf(s);
break;
}
piece += 1;
}
}
|
You are given a tree T that consists of N nodes. Each node is numbered from 1 to N, and node 1 is always the root node of T. Consider the following two operations on T:
* M v: (Mark) Mark node v.
* Q v: (Query) Print the index of the nearest marked ancestor of node v which is nearest to it. Initially, only the root node is marked. Note that a node is an ancestor of itself.
Your job is to write a program that performs a sequence of these operations on a given tree and calculates the value that each Q operation will print. To avoid too large output file, your program is requested to print the sum of the outputs of all query operations. Note that the judges confirmed that it is possible to calculate every output of query operations in a given sequence.
Input
The input consists of multiple datasets. Each dataset has the following format:
The first line of the input contains two integers N and Q, which denotes the number of nodes in the tree T and the number of operations, respectively. These numbers meet the following conditions: 1 ≤ N ≤ 100000 and 1 ≤ Q ≤ 100000.
The following N - 1 lines describe the configuration of the tree T. Each line contains a single integer pi (i = 2, ... , N), which represents the index of the parent of i-th node.
The next Q lines contain operations in order. Each operation is formatted as "M v" or "Q v", where v is the index of a node.
The last dataset is followed by a line containing two zeros. This line is not a part of any dataset and should not be processed.
Output
For each dataset, print the sum of the outputs of all query operations in one line.
Example
Input
6 3
1
1
2
3
3
Q 5
M 3
Q 5
0 0
Output
4
|
def root(x):
while P[x] != x:
x = P[x]
return x
def mark(x):
P[x-1] = x-1
def query(x):
v = root(x-1) +1
return v
while True:
N,Q = map(int,input().strip().split(" "))
if N == Q == 0:
break
P = []
P.append(0)
for i in range(N-1):
p_i = int(input().strip()) -1
P.append(p_i)
s = 0
for j in range(Q):
op = input().strip().split(" ")
if op[0] == "M":
mark(int(op[1]))
else:
s += query(int(op[1]))
print(s)
|
International Carpenters Professionals Company (ICPC) is a top construction company with a lot of expert carpenters. What makes ICPC a top company is their original language.
The syntax of the language is simply given in CFG as follows:
S -> SS | (S) | )S( | ε
In other words, a right parenthesis can be closed by a left parenthesis and a left parenthesis can be closed by a right parenthesis in this language.
Alex, a grad student mastering linguistics, decided to study ICPC's language. As a first step of the study, he needs to judge whether a text is well-formed in the language or not. Then, he asked you, a great programmer, to write a program for the judgement.
Alex's request is as follows: You have an empty string S in the beginning, and construct longer string by inserting a sequence of '(' or ')' into the string. You will receive q queries, each of which consists of three elements (p, c, n), where p is the position to insert, n is the number of characters to insert and c is either '(' or ')', the character to insert. For each query, your program should insert c repeated by n times into the p-th position of S from the beginning. Also it should output, after performing each insert operation, "Yes" if S is in the language and "No" if S is not in the language.
Please help Alex to support his study, otherwise he will fail to graduate the college.
Input
The first line contains one integer q (1 \leq q \leq 10^5) indicating the number of queries, follows q lines of three elements, p_i, c_i, n_i, separated by a single space (1 \leq i \leq q, c_i = '(' or ')', 0 \leq p_i \leq length of S before i-th query, 1 \leq n \leq 2^{20}). It is guaranteed that all the queries in the input are valid.
Output
For each query, output "Yes" if S is in the language and "No" if S is not in the language.
Examples
Input
3
0 ( 10
10 ) 5
10 ) 5
Output
No
No
Yes
Input
3
0 ) 10
10 ( 5
10 ( 5
Output
No
No
Yes
Input
3
0 ( 10
10 ) 20
0 ( 10
Output
No
No
Yes
|
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <cassert>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
#include <list>
using namespace std;
#ifdef _MSC_VER
#define __typeof__ decltype
template <class T> int __builtin_popcount(T n) { return n ? 1 + __builtin_popcount(n & (n - 1)) : 0; }
#endif
#define foreach(it, c) for (__typeof__((c).begin()) it=(c).begin(); it != (c).end(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define CLEAR(arr, val) memset(arr, val, sizeof(arr))
#define rep(i, n) for (int i = 0; i < n; ++i)
template <class T> void max_swap(T& a, const T& b) { a = max(a, b); }
template <class T> void min_swap(T& a, const T& b) { a = min(a, b); }
typedef long long ll;
typedef pair<int, int> pint;
const double EPS = 1e-8;
const double PI = acos(-1.0);
const int dx[] = { 0, 1, 0, -1 };
const int dy[] = { 1, 0, -1, 0 };
int main()
{
int q;
scanf("%d", &q);
ll par = 0;
while (q--)
{
int p, n;
char c;
scanf("%d %c %d", &p, &c, &n);
if (c == '(')
par += n;
else
par -= n;
if (par == 0)
puts("Yes");
else
puts("No");
}
}
|
1
Problem Statement
There is a bit string of length n.
When the i-th bit from the left is 1, the score is a_i points.
The number of 1s within the distance w around the i-th bit from the left (= | \\ {j \ in \\ {1, ..., n \\} ∩ \\ {iw, ..., i + w \\} | When the jth bit from the left is 1 \\} |) is odd, the score is b_i.
Find the bit string that gives the most scores.
Constraints
* 1 ≤ n ≤ 1,000
* 1 ≤ w ≤ 1,000
* 0 ≤ a_i ≤ 10 ^ 5
* 0 ≤ b_i ≤ 10 ^ 5
Input
Input follows the following format. All given numbers are integers.
n w
a_1 ... a_n
b_1 ... b_n
Output
Output the bit string that gives the most scores on one line.
If there are multiple such solutions, any of them may be output.
Examples
Input
4 1
3 1 2 7
13 8 25 9
Output
1001
Input
2 1
1 1
3 3
Output
10
|
#include <cstdio>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <climits>
#include <ctime>
#include <queue>
#include <stack>
#include <algorithm>
#include <list>
#include <vector>
#include <set>
#include <map>
#include <iostream>
#include <deque>
#include <complex>
#include <string>
#include <iomanip>
#include <sstream>
#include <bitset>
#include <numeric>
#include <iterator>
using namespace std;
typedef long long int ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
#define REP(i,x) for(int i=0;i<(int)(x);i++)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();i++)
#define RREP(i,x) for(int i=((int)(x)-1);i>=0;i--)
#define RFOR(i,c) for(__typeof((c).rbegin())i=(c).rbegin();i!=(c).rend();i++)
#define ALL(container) container.begin(), container.end()
#define RALL(container) container.rbegin(), container.rend()
#define SZ(container) ((int)container.size())
#define mp(a,b) make_pair(a, b)
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
template<class T> ostream& operator<<(ostream &os, const vector<T> &t) {
os<<"["; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"]"; return os;
}
template<class T> ostream& operator<<(ostream &os, const set<T> &t) {
os<<"{"; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"}"; return os;
}
template<class S, class T> ostream& operator<<(ostream &os, const pair<S,T> &t) { return os<<"("<<t.first<<","<<t.second<<")";}
const double EPS = 1e-8;
const int MOD = 1000000007;
typedef int Weight;
const Weight INF=999999999;
struct Edge{
int src,dst;
Weight weight;
int rev, f;
Edge(int f, int t, Weight c,int rev=0, int ff=0):src(f),dst(t),weight(c),rev(rev),f(ff){}
};
typedef vector< vector<Edge> > Graph;
void add_edge(Graph &G,int s,int t,Weight cap, int f=0){
// printf("%d->%d(%d)\n", s, t, cap);
G[s].push_back(Edge(s,t,cap,G[t].size(), f));
G[t].push_back(Edge(t,s,cap,G[s].size()-1, f));
}
void bfs(const Graph &G,vector<int> &level,int s){
level[s]=0;
queue<int> que;
que.push(s);
while(!que.empty()){
int v=que.front();que.pop();
REP(i,G[v].size()){
const Edge &e=G[v][i];
if(e.weight>0 && level[e.dst] < 0){
level[e.dst] = level[v] +1;
que.push(e.dst);
}
}
}
}
Weight dfs(Graph &G,vector<int> &level,vector<int> &iter,int v,int t,Weight flow){
if(v==t)return flow;
for(int &i=iter[v];i<(int)G[v].size();i++){
Edge &e=G[v][i];
if(e.weight>0&&level[v]<level[e.dst]){
Weight d=dfs(G,level,iter,e.dst,t,min(flow,e.weight));
if(d>0){
e.weight-=d;
G[e.dst][e.rev].weight+=d;
return d;
}
}
}
return 0;
}
// Dinic
// O(EV^2)
Weight max_flow(Graph &G,int s,int t){
Weight flow = 0;
while(true){
vector<int> level(G.size(),-1);
vector<int> iter(G.size(),0);
bfs(G,level,s);
if(level[t]<0)break; // もう流せない
Weight f=0;
while((f=dfs(G,level,iter,s,t,INF))>0){
flow+=f;
}
}
return flow;
}
int n, w;
int main(){
ios::sync_with_stdio(false);
cin >> n >> w;
vi a(n), b(n);
REP(i, n) cin >> a[i];
REP(i, n) cin >> b[i];
int sum = accumulate(ALL(a), 0) + accumulate(ALL(b), 0);
pair<int, string> res(-1, "");
REP(k, 2){
Graph g(n+2*w+3);
const int s = n+2*w+1;
const int t = n+2*w+2;
REP(i, n){
add_edge(g, w+i, w+i+1, a[i], 1);
add_edge(g, i, 2*w+i+1, b[i]);
}
REP(i, w+1){
if(i&1) add_edge(g, s, i, INF);
else add_edge(g, i, t, INF);
if(((w+n+i)&1)^k) add_edge(g, s, w+n+i, INF);
else add_edge(g, w+n+i, t, INF);
}
int score = sum - max_flow(g, s, t);
string ans(n, '1');
queue<int> q;
vi att(g.size(), 0);
att[s] = 1;
q.push(s);
while(!q.empty()){
int u = q.front();q.pop();
FOR(e, g[u])if(e->weight != 0){
if(!att[e->dst]){
att[e->dst] = 1;
q.push(e->dst);
}
}
}
// cout << att << endl;
REP(i, n+1) ans[i] = '0' + (att[i+w] == att[i+w+1]);
// cout << ans << ": " << score << endl;
res = max(res, make_pair(score, ans));
}
cout << res.second << endl;
return 0;
}
|
Problem statement
N-winged rabbit is on a balance beam of length L-1. The initial position of the i-th rabbit is the integer x_i, which satisfies 0 ≤ x_ {i} \ lt x_ {i + 1} ≤ L−1. The coordinates increase as you move to the right. Any i-th rabbit can jump to the right (ie, move from x_i to x_i + a_i) any number of times, just a distance a_i. However, you cannot jump over another rabbit or enter a position below -1 or above L. Also, at most one rabbit can jump at the same time, and at most one rabbit can exist at a certain coordinate.
How many possible states of x_ {0},…, x_ {N−1} after starting from the initial state and repeating the jump any number of times? Find by the remainder divided by 1 \, 000 \, 000 \, 007.
input
The input is given in the following format.
N L
x_ {0}… x_ {N−1}
a_ {0}… a_ {N−1}
Constraint
* All inputs are integers
* 1 \ ≤ N \ ≤ 5 \,000
* N \ ≤ L \ ≤ 5 \,000
* 0 \ ≤ x_ {i} \ lt x_ {i + 1} \ ≤ L−1
* 0 \ ≤ a_ {i} \ ≤ L−1
output
Print the answer in one line.
sample
Sample input 1
13
0
1
Sample output 1
3
If 1/0 is used to express the presence / absence of a rabbit, there are three ways: 100, 010, and 001.
Sample input 2
twenty four
0 1
1 2
Sample output 2
Four
There are four ways: 1100, 1001, 0101, 0011.
Sample input 3
10 50
0 1 2 3 4 5 6 7 8 9
1 1 1 1 1 1 1 1 1 1
Sample output 3
272278100
The binomial coefficient C (50,10) = 10 \, 272 \, 278 \, 170, and the remainder obtained by dividing it by 1 \, 000 \, 000 \, 007 is 272 \, 278 \, 100.
Example
Input
1 3
0
1
Output
3
|
#define _USE_MATH_DEFINES
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<climits>
#include<string>
#include<vector>
#include<list>
#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<cstring>
#include<stack>
#include<functional>
using namespace std;
typedef long long ll;
const ll MOD = 1e9+7;
ll dp[2][5000];
int main(){
int N,L,X[5000],A[5000];
cin>>N>>L;
for(int i=0;i<N;i++) cin>>X[i];
for(int i=0;i<N;i++){
cin>>A[i];
}
for(int i=0;i<N;i++){
for(int j=0;X[i]+A[i]*j<L;j++){
dp[i&1][X[i]+A[i]*j] = 1;
if(A[i]==0) break;
}
if(i==0) continue;
ll sum = 0;
for(int j=0;j<L;j++){
dp[i&1][j] = (dp[i&1][j]*sum)%MOD;
sum += dp[(i-1)&1][j]%MOD;
dp[(i-1)&1][j] = 0;
}
}
ll ans = 0;
for(int i=0;i<L;i++) ans += dp[(N-1)&1][i]%MOD;
printf("%lld\n",ans%MOD);
return 0;
}
|
F: Bath overflows --Overflow of Furo -
story
The hot spring inn Paro is passionate about the hot springs that it is proud of, and is attracting professional bathers. Bath professionals mainly manage the plumbing of hot springs, and manage and coordinate the complicated and intricate plumbing network that connects multiple sources to one large communal bath.
The management and adjustment work of the piping network is also quite difficult, but the bath professionals sewn in between and made efforts every day to supply more hot water to the bathtub. As a result, bath professionals have mastered the trick of "only one pipe can be overflowed." In other words, it became possible to freely choose one pipe and remove the limitation on the amount of hot water in that pipe.
Bath professionals who have previously relied on your program to set up a plumbing network to achieve maximum hot water can reprogram to you how to use this technology to further increase the amount of hot water supplied to the bathtub. I asked you to write.
problem
There is a plumbing network with one bathtub, K sources and N junctions. The piping network consists of M pipes, and each pipe has a limit on the amount of hot water that can be flowed. Since the direction in which hot water flows is not determined for each pipe, you can freely decide and use it. At the N coupling points, the hot water flowing from some pipes can be freely distributed to some other pipes. All sources and bathtubs are at the end points of some pipes, and hot water is supplied from the source to the bathtub by adjusting the amount of hot water from the source and the amount of hot water at the joint point.
What is the maximum amount of hot water that can be supplied to the bathtub by overflowing only one of the M pipes, that is, increasing the amount of hot water that can be flowed infinitely? However, it is possible that the maximum amount of hot water supplied can be increased infinitely, but in that case the bath will overflow, so output "overfuro".
Input format
The input is given in the following format.
K N M
a_1 b_1 c_1
...
a_M b_M c_M
All inputs consist of integers. The first row gives the number of sources K, the number of coupling points N, and the number of pipes M. In the i-th line of the following M lines, three integers a_i, b_i, and c_i representing the information of the i-th pipe are given. This indicates that the points at both ends of the i-th pipe are a_i and b_i, respectively, and the limit on the amount of hot water is c_i. Here, when the end point x of the pipe is 0, it means that it is a large communal bath, when it is from 1 to K, it means that it is the xth source, and when it is from K + 1 to K + N, it means that it is the x − Kth connection point. ..
Constraint
* 1 ≤ K
* 0 ≤ N
* N + K ≤ 100
* 1 ≤ M ≤ (N + K + 1) (N + K) / 2
* 0 ≤ a_i, b_i ≤ K + N
* a_i ≠ b_i
* 1 ≤ c_i ≤ 5 {,} 000
* It is guaranteed that no more than one pipe has the same two endpoints.
* The given plumbing network is guaranteed to be able to supply at least one hot water from the source to the bathtub without overflowing the plumbing.
Output format
Output the maximum amount of hot water supplied from the source to the bathtub in one line when only one pipe overflows and the amount of hot water supplied from the source to the bathtub is maximized. However, if you can increase the maximum amount of hot water infinitely, output "overfuro" on one line.
Input example 1
2 2 4
1 3 4
2 4 2
0 3 3
4 0 5
Output example 1
8
Input example 2
2 3 7
1 0 8
2 0 9
3 0 3
0 4 5
5 0 2
1 3 2
2 4 9
Output example 2
overfuro
Input example 3
1 1 2
0 2 1
1 2 1
Output example 3
1
Input example 4
5 0 5
0 1 1
0 2 1
0 3 1
0 4 1
0 5 1
Output example 4
overfuro
Example
Input
2 2 4
1 3 4
2 4 2
0 3 3
4 0 5
Output
8
|
#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <functional>
#include <bitset>
using namespace std;
using lint = long long int;
long long int INF = 1001001001001001LL;
int inf = 1000000007;
long long int MOD = 1000000007LL;
double PI = 3.1415926535897932;
template<typename T1,typename T2>inline void chmin(T1 &a,const T2 &b){if(a>b) a=b;}
template<typename T1,typename T2>inline void chmax(T1 &a,const T2 &b){if(a<b) a=b;}
#define ALL(a) a.begin(),a.end()
#define RALL(a) a.rbegin(),a.rend()
/* do your best */
// verified : http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_6_A
// O(E V^2)
// [使い方]
// add_edge(from, to, cap) : from から to へ 容量 cap の辺を貼る
// max_flow(s, t) : s から t への最大フローを返す
template< typename T >
struct Dinic{
const T inf;
struct edge{
int to;
T cap;
int rev;
bool isrev;
};
vector<vector<edge>> g;
vector<int> min_cost, iter;
Dinic(int V) : inf(numeric_limits<T>::max()), g(V){}
// 0-indexed
void add_edge(int from, int to, T cap){
g[from].emplace_back((edge){to, cap, (int)g[to].size(), false});
g[to].emplace_back((edge){from, 0, (int)g[from].size() - 1, true});
}
bool bfs(int s, int t) {
min_cost.assign(g.size(), -1);
queue<int> que;
min_cost[s] = 0;
que.push(s);
while(!que.empty() && min_cost[t] == -1){
int p = que.front();
que.pop();
for(auto &e : g[p]) {
if(e.cap > 0 && min_cost[e.to] == -1){
min_cost[e.to] = min_cost[p] + 1;
que.push(e.to);
}
}
}
return min_cost[t] != -1;
}
T dfs(int idx, const int t, T flow){
if(idx == t) return flow;
for(int &i = iter[idx]; i < g[idx].size(); i++){
edge &e = g[idx][i];
if(e.cap > 0 && min_cost[idx] < min_cost[e.to]){
T d = dfs(e.to, t, min(flow, e.cap));
if(d > 0){
e.cap -= d;
g[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
// 0-indexed
T max_flow(int s, int t){
T flow = 0;
while(bfs(s, t)){
iter.assign(g.size(), 0);
T f = 0;
while((f = dfs(s, t, inf)) > 0) flow += f;
}
return flow;
}
void output() {
for(int i = 0; i < g.size(); i++) {
for(auto &e : g[i]) {
if(e.isrev) continue;
auto &rev_e = g[e.to][e.rev];
cout << i << "->" << e.to << " (flow: " << rev_e.cap << "/" << e.cap + rev_e.cap << ")" << endl;
}
}
}
};
int main() {
int k, n, m; cin >> k >> n >> m;
int source = n + k + 1;
int sink = 0;
// 0 と (1 ~ k) が直接繋がっていたら，overfuro
Dinic<lint> dc(n + k + 2);
bool overfuro = false;
for (int i = 0; i < m; i++) {
lint a, b, c; cin >> a >> b >> c;
if (a > b) swap(a, b);
if (a == sink and 1 <= b and b <= k) {
overfuro = true;
}
dc.add_edge(a, b, c);
dc.add_edge(b, a, c);
}
if (overfuro) {
cout << "overfuro" << endl;
return 0;
}
for (int i = 1; i <= k; i++) {
dc.add_edge(source, i, INF);
}
lint ans = dc.max_flow(source, sink);
lint add = 0;
for(int i = 0; i < dc.g.size(); i++) {
for(auto &e : dc.g[i]) {
if(e.isrev) continue;
auto &rev_e = dc.g[e.to][e.rev];
if (rev_e.cap == e.cap + rev_e.cap) {
auto extra = dc;
extra.add_edge(i, e.to, INF);
lint tmp = extra.max_flow(source, sink);
add = max(add, tmp);
}
// cout << i << "->" << e.to << " (flow: " << rev_e.cap << "/" << e.cap + rev_e.cap << ")" << endl;
}
}
cout << ans + add << endl;
return 0;
}
|
problem
Given the sequence $ A $ of length $ N $. Find the maximum value of $ \ sum B_i $, where $ B $ is one of the longest increasing subsequences of the sequence $ A $.
The longest increasing subsequence of the sequence $ A $ is the longest subsequence that satisfies $ A_i <A_j $ with all $ i <j $.
output
Output the maximum value of $ \ sum B_i $, where $ B $ is one of the longest increasing subsequences of the sequence $ A $. Also, output a line break at the end.
Example
Input
4
6 4 7 8
Output
21
|
#include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
#define int long long
#define inf 1000000007
#define pa pair<int,int>
#define ll long long
#define pal pair<double,double>
#define ppap pair<pa,int>
#define PI 3.14159265358979323846
#define paa pair<int,char>
#define mp make_pair
#define pb push_back
#define EPS (1e-10)
// int dx[8]={0,1,0,-1,1,1,-1,-1};
// int dy[8]={1,0,-1,0,-1,1,1,-1};
using namespace std;
class pa3{
public:
int x;
int y,z;
pa3(int x=0,int y=0,int z=0):x(x),y(y),z(z) {}
bool operator < (const pa3 &p) const{
if(x!=p.x) return x<p.x;
if(y!=p.y) return y<p.y;
return z<p.z;
//return x != p.x ? x<p.x: y<p.y;
}
bool operator > (const pa3 &p) const{
if(x!=p.x) return x>p.x;
if(y!=p.y) return y>p.y;
return z>p.z;
//return x != p.x ? x<p.x: y<p.y;
}
bool operator == (const pa3 &p) const{
return x==p.x && y==p.y && z==p.z;
}
bool operator != (const pa3 &p) const{
return !( x==p.x && y==p.y && z==p.z);
}
};
class pa4{
public:
int x;
int y,z,w;
pa4(int x=0,int y=0,int z=0,int w=0):x(x),y(y),z(z),w(w) {}
bool operator < (const pa4 &p) const{
if(x!=p.x) return x<p.x;
if(y!=p.y) return y<p.y;
if(z!=p.z)return z<p.z;
return w<p.w;
//return x != p.x ? x<p.x: y<p.y;
}
bool operator > (const pa4 &p) const{
if(x!=p.x) return x>p.x;
if(y!=p.y) return y>p.y;
if(z!=p.z)return z>p.z;
return w>p.w;
//return x != p.x ? x<p.x: y<p.y;
}
bool operator == (const pa4 &p) const{
return x==p.x && y==p.y && z==p.z &&w==p.w;
}
};
class pa2{
public:
int x,y;
pa2(int x=0,int y=0):x(x),y(y) {}
pa2 operator + (pa2 p) {return pa2(x+p.x,y+p.y);}
pa2 operator - (pa2 p) {return pa2(x-p.x,y-p.y);}
bool operator < (const pa2 &p) const{
return y != p.y ? y<p.y: x<p.x;
}
bool operator > (const pa2 &p) const{
return x != p.x ? x<p.x: y<p.y;
}
bool operator == (const pa2 &p) const{
return abs(x-p.x)==0 && abs(y-p.y)==0;
}
bool operator != (const pa2 &p) const{
return !(abs(x-p.x)==0 && abs(y-p.y)==0);
}
};
class Point{
public:
double x,y;
Point(double x=0,double y=0):x(x),y(y) {}
Point operator + (Point p) {return Point(x+p.x,y+p.y);}
Point operator - (Point p) {return Point(x-p.x,y-p.y);}
Point operator * (double a) {return Point(x*a,y*a);}
Point operator / (double a) {return Point(x/a,y/a);}
double absv() {return sqrt(norm());}
double norm() {return x*x+y*y;}
bool operator < (const Point &p) const{
return x != p.x ? x<p.x: y<p.y;
}
bool operator == (const Point &p) const{
return fabs(x-p.x)<EPS && fabs(y-p.y)<EPS;
}
};
typedef Point Vector;
#define pl pair<int,pas>
struct Segment{
Point p1,p2;
};
double dot(Vector a,Vector b){
return a.x*b.x+a.y*b.y;
}
double cross(Vector a,Vector b){
return a.x*b.y-a.y*b.x;
}
bool parareru(Point a,Point b,Point c,Point d){
// if(abs(cross(a-b,d-c))<EPS)cout<<"dd "<<cross(a-b,d-c)<<endl;
return abs(cross(a-b,d-c))<EPS;
}
double distance_ls_p(Point a, Point b, Point c) {
if ( dot(b-a, c-a) < EPS ) return (c-a).absv();
if ( dot(a-b, c-b) < EPS ) return (c-b).absv();
return abs(cross(b-a, c-a)) / (b-a).absv();
}
bool is_intersected_ls(Segment a,Segment b) {
if(a.p1==b.p1||a.p2==b.p1||a.p1==b.p2||a.p2==b.p2) return false;
if(parareru((a.p2),(a.p1),(a.p1),(b.p2))&¶reru((a.p2),(a.p1),(a.p1),(b.p1))){
// cout<<"sss"<<endl;
if(dot(a.p1-b.p1,a.p1-b.p2)<EPS) return true;
if(dot(a.p2-b.p1,a.p2-b.p2)<EPS) return true;
if(dot(a.p1-b.p1,a.p2-b.p1)<EPS) return true;
if(dot(a.p1-b.p2,a.p2-b.p2)<EPS) return true;
return false;
}
else return ( cross(a.p2-a.p1, b.p1-a.p1) * cross(a.p2-a.p1, b.p2-a.p1) < EPS ) && ( cross(b.p2-b.p1, a.p1-b.p1) * cross(b.p2-b.p1, a.p2-b.p1) < EPS );
}
double segment_dis(Segment a,Segment b){
if(is_intersected_ls(a,b))return 0;
double r=distance_ls_p(a.p1, a.p2, b.p1);
r=min(r,distance_ls_p(a.p1, a.p2, b.p2));
r=min(r,distance_ls_p(b.p1, b.p2, a.p2));
r=min(r,distance_ls_p(b.p1, b.p2, a.p1));
return r;
}
Point intersection_ls(Segment a, Segment b) {
Point ba = b.p2-b.p1;
double d1 = abs(cross(ba, a.p1-b.p1));
double d2 = abs(cross(ba, a.p2-b.p1));
double t = d1 / (d1 + d2);
return a.p1 + (a.p2-a.p1) * t;
}
string itos( int i ) {
ostringstream s ;
s << i ;
return s.str() ;
}
int gcd(int v,int b){
if(v>b) return gcd(b,v);
if(v==b) return b;
if(b%v==0) return v;
return gcd(v,b%v);
}
double distans(double x1,double y1,double x2,double y2){
double rr=(x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
return sqrt(rr);
}
int mod;
ll extgcd(ll a, ll b, ll &x, ll &y) {
if (b == 0ll) {
x = 1ll;
y = 0ll;
return a;
}
ll d = extgcd(b, a%b, y, x);
y -= a/b * x;
return d;
}
pa operator+(const pa & l,const pa & r) {
return {l.first+r.first,l.second+r.second};
}
pa operator-(const pa & l,const pa & r) {
return {l.first-r.first,l.second-r.second};
}
int pr[200010];
int inv[200010];
int beki(int wa,int rr,int warukazu){
if(rr==0) return 1%warukazu;
if(rr==1) return wa%warukazu;
wa%=warukazu;
if(rr%2==1) return ((ll)beki(wa,rr-1,warukazu)*(ll)wa)%warukazu;
ll zx=beki(wa,rr/2,warukazu);
return (zx*zx)%warukazu;
}
double bekid(double w,int r){
if(r==0) return 1.0;
if(r==1) return w;
if(r%2) return bekid(w,r-1)*w;
double f=bekid(w,r/2);
return f*f;
}
int comb(int nn,int rr){
int r=pr[nn]*inv[rr];
r%=mod;
r*=inv[nn-rr];
r%=mod;
return r;
}
void gya(int ert){
pr[0]=1;
for(int i=1;i<=ert;i++){
pr[i]=(pr[i-1]*i)%mod;
}
inv[ert]=beki(pr[ert],mod-2,mod);
for(int i=ert-1;i>=0;i--) inv[i]=inv[i+1]*(i+1)%mod;
}
// cin.tie(0);
// ios::sync_with_stdio(false);
//priority_queue<pa3,vector<pa3>,greater<pa3>> pq;
//sort(ve.begin(),ve.end(),greater<int>());
//mt19937(clock_per_sec);
// mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count()) ;
//----------------kokomade tenpure------------
struct Segmax{
// 1
// 2 3
// 4 5 6 7
private:
public:
// (1<<15)=32768
// 1<<16 = 65536
// 1<<17 = 131072
// 1<<18 = 262144
int cor=(1<<17);
vector<pa> vec;
void shoki1(){
vec.resize(2*cor+3, mp(-1,0));
// for(int i=cor;i<2*cor;i++)vec[i].second=i-cor;
}
void shoki2(){
for(int i=cor-1;i>0;i--) {
vec[i]=max(vec[2*i],vec[2*i+1]);
}
}
void updchan(int x,pa w){
//x項目をwに変更
x+=cor;
vec[x]=w;
while(1){
x/=2;
if(x==0) break;
vec[x]=max(vec[2*x+1],vec[2*x]);
}
}
// [a,b)
// k-th node
// k no kukanha [l,r)
pa segmax(int a,int b,int k=1,int l=0,int r=-10){
if(r<0)r=cor;
// cout<<a<<" "<<b<<" "<<k<<" "<<l<<" "<<r<<endl;
if(a<=l && r<=b){
return vec[k];
}
if(r<=a || b<=l){
return mp(-1,-1);
}
pa v1=segmax(a,b,k*2,l,(l+r)/2),v2=segmax(a,b,k*2+1,(l+r)/2,r);
return max(v1,v2);
}
};
Segmax ss;
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin>>n;
ss.shoki1();
ss.shoki2();
for(int i=0;i<n;i++){
int y;
cin>>y;
pa z=ss.segmax(0,y);
pa r;
if(z.first<0){
r={1,y};
}
else{
r=z;
r.first++;
r.second+=y;
}
if(ss.vec[ss.cor+y]<r){
ss.updchan(y,r);
}
}
pa ans=ss.segmax(0,ss.cor);
cout<<ans.second<<endl;
return 0;
}
|
C: Canisal cryptography
problem
Ebi-chan was given the string C obtained by encrypting a non-negative integer D with "canisal cipher". This cipher replaces each number in decimal notation with a fixed number (not necessarily different from the original). Different numbers will not be replaced with the same number, and the same number will not be rewritten to a different number depending on the position of appearance.
For example, this encryption method can result in 2646 being 0545, but not 3456 being 1333 or 1333 being 3456.
Now, Ebi-chan has been told that the remainder of dividing D by 10 ^ 9 + 7 is M. At this time, output one that can be considered as D. If you can think of more than one, you can output any of them. However, it is assumed that there is no extra `0` at the beginning of D.
Input format
M
C
Constraint
* 0 \ leq M <10 ^ 9 + 7
* 1 \ leq | C | \ leq 10 ^ 5
Output format
Print a non-negative integer that can be considered as D on one line. If it does not exist, output `-1`.
Input example 1
2
1000000007
Output example 1
1000000009
The encryption method this time was to replace 0 with 0, 1 with 1, and 9 with 7.
Input example 2
3
1000000007
Output example 2
-1
Input example 3
1
01 01
Output example 3
-1
There is no extra `0` at the beginning of the D.
Input example 4
45
1000000023
Output example 4
6000000087
Since `1000000052` and` 2000000059` also satisfy the conditions, you can output them.
Input example 5
0
940578326285963740
Output example 5
123456789864197523
Example
Input
2
1000000007
Output
1000000009
|
#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <cstring>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <list>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <unordered_set>
#include <unordered_map>
#include <array>
#include <cassert>
#include <bitset>
#include <cstdint>
using namespace std;
using LL = long long;
LL M;
string C;
const LL MOD = 1000000007;
int main() {
cin >> M;
cin >> C;
int N = C.size();
if (N == 1 && M == 0) {
cout << 0 << endl;
return 0;
}
LL ten = 1;
LL arr[10] = {};
for (int i = N - 1; i >= 0; --i) {
arr[C[i] - '0'] += ten;
arr[C[i] - '0'] %= MOD;
ten *= 10;
ten %= MOD;
}
vector<int>per;
for (int i = 0; i < 10; ++i)per.push_back(i);
int sent = C[0] - '0';
do {
if (per[sent] != 0) {
LL tmp = 0;
for (int i = 0; i < 10; ++i) {
tmp += (arr[i] * per[i]) % MOD;
tmp %= MOD;
}
if (tmp == M) {
for (char c : C) {
cout << per[c - '0'];
}
cout << endl;
return 0;
}
}
} while (next_permutation(per.begin(), per.end()));
cout << -1 << endl;
return 0;
}
|
Given a matrix (H × W) which contains only 1 and 0, find the area of the largest square matrix which only contains 0s.
Constraints
* 1 ≤ H, W ≤ 1,400
Input
H W
c1,1 c1,2 ... c1,W
c2,1 c2,2 ... c2,W
:
cH,1 cH,2 ... cH,W
In the first line, two integers H and W separated by a space character are given. In the following H lines, ci,j, elements of the H × W matrix, are given.
Output
Print the area (the number of 0s) of the largest square.
Example
Input
4 5
0 0 1 0 0
1 0 0 0 0
0 0 0 1 0
0 0 0 1 0
Output
4
|
#include<bits/stdc++.h>
using namespace std;
const int maxn=1400;
int dp[maxn][maxn],g[maxn][maxn];
int getlargestsquare(int h,int w)
{
int maxwidth=0;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
dp[i][j]=(g[i][j]+1)%2;
maxwidth|=dp[i][j];
}
}
for(int i=1;i<h;i++){
for(int j=1;j<w;j++){
if(g[i][j]){
dp[i][j]=0;
}else{
dp[i][j]=min(dp[i-1][j-1],min(dp[i-1][j],dp[i][j-1]))+1;
maxwidth=max(maxwidth,dp[i][j]);
}
}
}
return maxwidth*maxwidth;
}
int main()
{
int h,w;
cin>>h>>w;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
cin>>g[i][j];
}
}
printf("%d\n",getlargestsquare(h,w));
return 0;
}
|
Extended Euclid Algorithm
Given positive integers a and b, find the integer solution (x, y) to ax + by = gcd(a, b), where gcd(a, b) is the greatest common divisor of a and b.
Constraints
* 1 ≤ a, b ≤ 109
Input
a b
Two positive integers a and b are given separated by a space in a line.
Output
Print two integers x and y separated by a space. If there are several pairs of such x and y, print that pair for which |x| + |y| is the minimal (primarily) and x ≤ y (secondarily).
Examples
Input
4 12
Output
1 0
Input
3 8
Output
3 -1
|
#define _USE_MATH_DEFINES
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <functional>
using namespace std;
typedef pair<long long int, long long int> P;
typedef tuple<int, int, int> T;
long long int INF = 1e18;
long long int MOD = 1e9 + 7;
long long int extGCD(long long int a, long long int b, long long int &x, long long int &y){
long long int d = a;
if(b == 0){
x = 1;
y = 0;
}else{
d = extGCD(b, a % b, y, x);
y -= a / b * x;
}
return d;
}
int main(){
long long int a, b, x, y, G;
cin >> a >> b;
G = extGCD(a, b, x, y);
cout << x << " " << y << endl;
return 0;
}
|
For Turbo C++ Users : Read the following document before attempting the question :
Problem Description
Hank Pym is an aspiring student at IIITD. He has almost completed his work on Ultron, the ultimate artificial intelligence. However, one thing remains. He feels that Ultron should have a fail-safe code which can be used to switch him off (just in case Ultron decides to wipe out our race). So, he encodes the number and feeds it into Ultron. Hank shares the number with the rest of the Avengers and the way to decrypt it:
Divide the encrypted number ‘N’ by its biggest prime divisor. Now, divide the resultant number by its biggest prime divisor and continue the process (i.e., recursively) until the resultant number doesn’t have any prime divisors. The decrypted code is the number of times you have to do this process.
Hank wants you to decrypt the number for him, so that he may store it somewhere safe (maybe inside one of the books at the IIITD library).Can you help Hank?
Input
First line contains ‘T’, the number of test cases.
Each test case is given on a new line, which consists of a number the encrypted number 'N'.
Output
For each test case, print the decrypted number.
Constraints
Should contain all the constraints on the input data that you may have. Format it like:
1 ≤ T ≤ 100
1 ≤ N ≤ 10^9
Example
Input:
4
2
9
100
17
Output:
1
2
4
1
Explanation
For the first test case, 2 has no prime divisors apart from itself. So, the answer is 1.
For the second test case, 9 has 3 as the only prime divisor. Dividing it by 3, we get 3.Dividing 3 by itself, we get 1, which has no prime divisors. So, the answer is 2.
For the third test case, the largest prime divisor is 5. Dividing, we get 20.The largest prime factor of 20 is 5. So, dividing by 5, we get 4. The largest prime factor of 4 is 2. Dividing, we get 2. Again dividing 2 by 2, we stop at 1.So, we did the division 4 times. Hence, the answer is 4.
The fourth test case is similar to the first test case.
|
max = 10**5
a = [True]*max
prime = []
for i in range(2,max):
if a[i]:
prime.append(i)
j = 2*i
while j < max:
a[j] = False
j += i
n = input()
for z in range(n):
k = input()
count = 0
track = 0
while track < len(prime) and k!=1:
while k%prime[track] == 0:
count += 1
k /= prime[track]
track += 1
if k != 1:
count += 1
print count
|
In Ciel's restaurant, a waiter is training.
Since the waiter isn't good at arithmetic, sometimes he gives guests wrong change.
Ciel gives him a simple problem.
What is A-B (A minus B) ?
Surprisingly, his answer is wrong.
To be more precise, his answer has exactly one wrong digit.
Can you imagine this?
Can you make the same mistake in this problem?
Input
An input contains 2 integers A and B.
Output
Print a wrong answer of A-B.
Your answer must be a positive integer containing the same number of digits as the correct answer, and exactly one digit must differ from the correct answer.
Leading zeros are not allowed.
If there are multiple answers satisfying the above conditions, anyone will do.
Constraints
1 ≤ B < A ≤ 10000
Sample Input
5858 1234
Sample Output
1624
Output details
The correct answer of 5858-1234 is 4624.
So, for instance, 2624, 4324, 4623, 4604 and 4629 will be accepted, but 0624, 624, 5858, 4624 and 04624 will be rejected.
Notes
The problem setter is also not good at arithmetic.
|
test = map(int,raw_input().split())
count = str(abs(test[0] - test[1]))
l = ['1','2','3','4','5','6','7','8','9']
l.remove(count[0])
string = ''
string += l[0]
string += count[1:len(count)+1]
print int(string)
|
Common Integer
Andy wants to prove his practical programming knowledge to his old pal.
He will get two numbers both in the range 10 to 99.
if there exists a comon integer in both the numbers, he has to write TRUE or else FALSE.
For Example: if input numbers are 12 and 24, the output must be TRUE since the common integer is 2 in both numbers.
Help Andy by developing a code that does his job.
Input
First line is two numbers separated by a space. The numbers must be in between 10 and 99.
Output
Next line is the output TRUE or FALSE depending on the input.
Example
Input:
12 24
Output:
TRUE
Input:
11 34
Output:
FALSE
|
x=raw_input()
a,b=x.split()
d=0
for i in a:
if i in b:
print "TRUE"
d=1
break
if d==0:
print "FALSE"
|
Mrs. Verma has decided to sell his car. N people have offered to buy the car. Instead of selling to the highest bidder, Mrs. Verma decides to sell his company to the Kth lowest bidder. How much money will Mrs. Verma get?
Input
The first line of the input contains 2 space-separated integers, N and K. The next line contains N space separated integers A1, A2, ..., AN, denoting the money each of the N people are willing to pay.
Output
Print a single integer, denoting the money Mrs/ Verma will sell his company for.
Constraints
1 ≤ K ≤ N ≤ 1000
1 ≤ Ai ≤ 10000
Example
Input:
5 4
1 2 1 3 3
Output:
3
Explanation
Out of the 5 bids, the 4th lowest amount is 3.
|
n, k = map(int, raw_input().split()); a = [int(i) for i in raw_input().split()];
a.sort(); print a[k - 1];
|
Phillip has become fascinated with sequences lately. He looks for sequences all the time. His favorite sequence is the Fibonacci sequence, where any element is equal to the sum of the two previous elements. However, he isn't able to figure out the correct number for positions beyond 8 without writing it on paper. Create a program that will take in the first two number of a Fibonacci sequence and a number of places to calculate, and print out the number that is at that place.
Input
The first two numbers of a Fibonacci sequence, and the to print out. Note: you only need to handle 1 sequence per run.
Output
The number at the position specified.
Example 1
Input:
1 1 5
Output:
5
Example 2
Input
1 5 7
Output
45
|
fib=[]
i1,i2,i3=map(int, raw_input().split())
y=i3
p=i1
fib.append(p)
r=i2
fib.append(r)
while(y):
n=p+r
fib.append(n)
p=r
r=n
y-=1
print fib.pop((i3-1))
|
Problem Statement
Write a program that accepts a number and outputs the same.
Sample Input
123
Sample Output
123
|
num=int(raw_input())
print num
|
Vitya has just started learning Berlanese language. It is known that Berlanese uses the Latin alphabet. Vowel letters are "a", "o", "u", "i", and "e". Other letters are consonant.
In Berlanese, there has to be a vowel after every consonant, but there can be any letter after any vowel. The only exception is a consonant "n"; after this letter, there can be any letter (not only a vowel) or there can be no letter at all. For example, the words "harakiri", "yupie", "man", and "nbo" are Berlanese while the words "horse", "king", "my", and "nz" are not.
Help Vitya find out if a word s is Berlanese.
Input
The first line of the input contains the string s consisting of |s| (1≤ |s|≤ 100) lowercase Latin letters.
Output
Print "YES" (without quotes) if there is a vowel after every consonant except "n", otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
sumimasen
Output
YES
Input
ninja
Output
YES
Input
codeforces
Output
NO
Note
In the first and second samples, a vowel goes after each consonant except "n", so the word is Berlanese.
In the third sample, the consonant "c" goes after the consonant "r", and the consonant "s" stands on the end, so the word is not Berlanese.
|
s=input()
a=['a','e','i','o','u']
c=0
for i in range(len(s)):
if(i==len(s)-1):
if s[i] in a or s[i]=='n':
c+=1
continue
elif s[i] in a:
c+=1
continue
elif(s[i]=='n'):
c+=1
continue
else:
if s[i+1] in a:
c+=1
continue
if(c==len(s)):
print("YES")
else:
print("NO")
|
There is an infinite line consisting of cells. There are n boxes in some cells of this line. The i-th box stands in the cell a_i and has weight w_i. All a_i are distinct, moreover, a_{i - 1} < a_i holds for all valid i.
You would like to put together some boxes. Putting together boxes with indices in the segment [l, r] means that you will move some of them in such a way that their positions will form some segment [x, x + (r - l)].
In one step you can move any box to a neighboring cell if it isn't occupied by another box (i.e. you can choose i and change a_i by 1, all positions should remain distinct). You spend w_i units of energy moving the box i by one cell. You can move any box any number of times, in arbitrary order.
Sometimes weights of some boxes change, so you have queries of two types:
1. id nw — weight w_{id} of the box id becomes nw.
2. l r — you should compute the minimum total energy needed to put together boxes with indices in [l, r]. Since the answer can be rather big, print the remainder it gives when divided by 1000 000 007 = 10^9 + 7. Note that the boxes are not moved during the query, you only should compute the answer.
Note that you should minimize the answer, not its remainder modulo 10^9 + 7. So if you have two possible answers 2 ⋅ 10^9 + 13 and 2 ⋅ 10^9 + 14, you should choose the first one and print 10^9 + 6, even though the remainder of the second answer is 0.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 2 ⋅ 10^5) — the number of boxes and the number of queries.
The second line contains n integers a_1, a_2, ... a_n (1 ≤ a_i ≤ 10^9) — the positions of the boxes. All a_i are distinct, a_{i - 1} < a_i holds for all valid i.
The third line contains n integers w_1, w_2, ... w_n (1 ≤ w_i ≤ 10^9) — the initial weights of the boxes.
Next q lines describe queries, one query per line.
Each query is described in a single line, containing two integers x and y. If x < 0, then this query is of the first type, where id = -x, nw = y (1 ≤ id ≤ n, 1 ≤ nw ≤ 10^9). If x > 0, then the query is of the second type, where l = x and r = y (1 ≤ l_j ≤ r_j ≤ n). x can not be equal to 0.
Output
For each query of the second type print the answer on a separate line. Since answer can be large, print the remainder it gives when divided by 1000 000 007 = 10^9 + 7.
Example
Input
5 8
1 2 6 7 10
1 1 1 1 2
1 1
1 5
1 3
3 5
-3 5
-1 10
1 4
2 5
Output
0
10
3
4
18
7
Note
Let's go through queries of the example:
1. 1\ 1 — there is only one box so we don't need to move anything.
2. 1\ 5 — we can move boxes to segment [4, 8]: 1 ⋅ |1 - 4| + 1 ⋅ |2 - 5| + 1 ⋅ |6 - 6| + 1 ⋅ |7 - 7| + 2 ⋅ |10 - 8| = 10.
3. 1\ 3 — we can move boxes to segment [1, 3].
4. 3\ 5 — we can move boxes to segment [7, 9].
5. -3\ 5 — w_3 is changed from 1 to 5.
6. -1\ 10 — w_1 is changed from 1 to 10. The weights are now equal to w = [10, 1, 5, 1, 2].
7. 1\ 4 — we can move boxes to segment [1, 4].
8. 2\ 5 — we can move boxes to segment [5, 8].
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
int fu = 1;
char c = getchar();
while (c > 57 || c < 48) {
if (c == 45) fu = -1;
c = getchar();
}
while (c <= 57 && c >= 48) {
x = (x << 3) + (x << 1) + c - 48;
c = getchar();
}
x *= fu;
}
template <typename T>
inline void fprint(T x) {
if (x < 0) putchar(45), x = -x;
if (x > 9) fprint(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
inline void fprint(T x, char ch) {
fprint(x);
putchar(ch);
}
inline char next_char() {
char ch = getchar();
while (ch == 9 || ch == 10 || ch == 32) ch = getchar();
return ch;
}
const long long MOD = 1000000007;
int n, m;
long long a[200005], w[200005];
long long c1[200005], c2[200005];
inline int lowbit(int x) { return x & -x; }
inline long long query(long long c[], int x, bool type) {
long long ret = 0;
for (; x; x -= lowbit(x)) ret += c[x], (type) && (ret = (ret + MOD) % MOD);
return ret;
}
inline void modify(long long c[], int x, long long y, bool type) {
for (; x <= n; x += lowbit(x))
c[x] += y, (type) && (c[x] = (c[x] + MOD) % MOD);
}
int main() {
read(n);
read(m);
for (register int i = 1; i <= n; i++) read(a[i]);
for (register int i = 1; i <= n; i++)
read(w[i]), modify(c1, i, w[i], 0),
modify(c2, i, (a[i] - i) * w[i] % MOD, 1);
while (m--) {
int l, r;
read(l);
read(r);
if (l < 0) {
l = -l;
modify(c1, l, -w[l], 0);
modify(c2, l, ((r - w[l]) * (a[l] - l) % MOD + MOD) % MOD, 1);
w[l] = r;
modify(c1, l, r, 0);
} else {
int L = l, R = r, pos = l;
long long ll = query(c1, l - 1, 0), rr = query(c1, r, 0);
long long tot = rr - ll;
tot = (tot >> 1) + 1;
while (L <= R) {
int mid = (L + R) >> 1;
if (query(c1, mid, 0) - ll >= tot)
pos = mid, R = mid - 1;
else
L = mid + 1;
}
long long res1 = query(c1, pos, 0), res2 = query(c1, pos - 1, 0);
rr %= MOD, ll %= MOD, res1 %= MOD, res2 %= MOD;
long long num = (a[pos] - (pos - l + 1) + MOD) % MOD;
long long ans = num * (res2 - ll) % MOD;
ans =
((ans + 1ll * (l - 1) * (rr - res1 - (res2 - ll))) % MOD + MOD) % MOD;
ans = ((ans - query(c2, pos - 1, 1) + query(c2, l - 1, 1)) % MOD + MOD) %
MOD;
ans = (ans + query(c2, r, 1) - query(c2, pos, 1) + MOD) % MOD;
ans = (ans - ((rr - res1) * num % MOD) + MOD) % MOD;
fprint(ans, 10);
}
}
}
|
You are given a tuple generator f^{(k)} = (f_1^{(k)}, f_2^{(k)}, ..., f_n^{(k)}), where f_i^{(k)} = (a_i ⋅ f_i^{(k - 1)} + b_i) mod p_i and f^{(0)} = (x_1, x_2, ..., x_n). Here x mod y denotes the remainder of x when divided by y. All p_i are primes.
One can see that with fixed sequences x_i, y_i, a_i the tuples f^{(k)} starting from some index will repeat tuples with smaller indices. Calculate the maximum number of different tuples (from all f^{(k)} for k ≥ 0) that can be produced by this generator, if x_i, a_i, b_i are integers in the range [0, p_i - 1] and can be chosen arbitrary. The answer can be large, so print the remainder it gives when divided by 10^9 + 7
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the tuple.
The second line contains n space separated prime numbers — the modules p_1, p_2, …, p_n (2 ≤ p_i ≤ 2 ⋅ 10^6).
Output
Print one integer — the maximum number of different tuples modulo 10^9 + 7.
Examples
Input
4
2 3 5 7
Output
210
Input
3
5 3 3
Output
30
Note
In the first example we can choose next parameters: a = [1, 1, 1, 1], b = [1, 1, 1, 1], x = [0, 0, 0, 0], then f_i^{(k)} = k mod p_i.
In the second example we can choose next parameters: a = [1, 1, 2], b = [1, 1, 0], x = [0, 0, 1].
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10, mod = 1e9 + 7;
int rd() {
int x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
return x * w;
}
int prm[N], pm[N], tt, n, a[N], c[N][2];
bool v[N];
int main() {
for (int i = 2; i <= N - 5; ++i) {
if (!pm[i]) pm[i] = prm[++tt] = i;
for (int j = 1; i * prm[j] <= N - 5; ++j) {
pm[i * prm[j]] = prm[j];
if (i % prm[j] == 0) break;
}
}
n = rd();
for (int i = 1; i <= n; ++i) a[i] = rd();
sort(a + 1, a + n + 1), reverse(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) {
if (!c[a[i]][0])
v[i] = 1, c[a[i]][0] = c[a[i]][1] = 1;
else {
int x = a[i] - 1;
while (x > 1) {
int np = pm[x], cn = 0;
while (pm[x] == np) ++cn, x /= np;
if (c[np][0] < cn)
c[np][0] = cn, c[np][1] = 1;
else
c[np][1] += c[np][0] == cn;
}
}
}
int ans = 1;
for (int i = 2; i <= N - 5; ++i)
for (int j = 1; j <= c[i][0]; ++j) ans = 1ll * ans * i % mod;
for (int i = 1; i <= n; ++i)
if (!v[i]) {
int x = a[i] - 1, o = 1;
while (x > 1) {
int np = pm[x], cn = 0;
while (pm[x] == np) ++cn, x /= np;
o &= cn < c[np][0] || c[np][1] > 1;
}
if (o) {
ans = (ans + o) % mod;
break;
}
}
printf("%d\n", ans);
return 0;
}
|
You are given n points on the plane. The polygon formed from all the n points is strictly convex, that is, the polygon is convex, and there are no three collinear points (i.e. lying in the same straight line). The points are numbered from 1 to n, in clockwise order.
We define the distance between two points p_1 = (x_1, y_1) and p_2 = (x_2, y_2) as their Manhattan distance: $$$d(p_1, p_2) = |x_1 - x_2| + |y_1 - y_2|.$$$
Furthermore, we define the perimeter of a polygon, as the sum of Manhattan distances between all adjacent pairs of points on it; if the points on the polygon are ordered as p_1, p_2, …, p_k (k ≥ 3), then the perimeter of the polygon is d(p_1, p_2) + d(p_2, p_3) + … + d(p_k, p_1).
For some parameter k, let's consider all the polygons that can be formed from the given set of points, having any k vertices, such that the polygon is not self-intersecting. For each such polygon, let's consider its perimeter. Over all such perimeters, we define f(k) to be the maximal perimeter.
Please note, when checking whether a polygon is self-intersecting, that the edges of a polygon are still drawn as straight lines. For instance, in the following pictures:
<image>
In the middle polygon, the order of points (p_1, p_3, p_2, p_4) is not valid, since it is a self-intersecting polygon. The right polygon (whose edges resemble the Manhattan distance) has the same order and is not self-intersecting, but we consider edges as straight lines. The correct way to draw this polygon is (p_1, p_2, p_3, p_4), which is the left polygon.
Your task is to compute f(3), f(4), …, f(n). In other words, find the maximum possible perimeter for each possible number of points (i.e. 3 to n).
Input
The first line contains a single integer n (3 ≤ n ≤ 3⋅ 10^5) — the number of points.
Each of the next n lines contains two integers x_i and y_i (-10^8 ≤ x_i, y_i ≤ 10^8) — the coordinates of point p_i.
The set of points is guaranteed to be convex, all points are distinct, the points are ordered in clockwise order, and there will be no three collinear points.
Output
For each i (3≤ i≤ n), output f(i).
Examples
Input
4
2 4
4 3
3 0
1 3
Output
12 14
Input
3
0 0
0 2
2 0
Output
8
Note
In the first example, for f(3), we consider four possible polygons:
* (p_1, p_2, p_3), with perimeter 12.
* (p_1, p_2, p_4), with perimeter 8.
* (p_1, p_3, p_4), with perimeter 12.
* (p_2, p_3, p_4), with perimeter 12.
For f(4), there is only one option, taking all the given points. Its perimeter 14.
In the second example, there is only one possible polygon. Its perimeter is 8.
|
#include <bits/stdc++.h>
using namespace std;
int n;
int ans[300003];
pair<int, int> A[300003];
vector<pair<int, int> > vec;
int state(int first) { return (first < 0) ? -1 : +1; }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d %d", &A[i].first, &A[i].second);
for (int i = 0; i < n; i++) {
int nxt = (i + 1) % n;
int bck = (i - 1 + n) % n;
if (state(A[i].first - A[bck].first) != state(A[nxt].first - A[i].first) ||
state(A[i].second - A[bck].second) !=
state(A[nxt].second - A[i].second))
vec.push_back(A[i]);
}
int nn = vec.size();
if (vec.size() <= 3) {
for (int i = 0; i < nn; i++)
ans[3] += abs(vec[i].first - vec[(i + 1) % nn].first) +
abs(vec[i].second - vec[(i + 1) % nn].second);
ans[4] = ans[3];
} else {
for (int i = 0; i < nn; i++)
ans[4] += abs(vec[i].first - vec[(i + 1) % nn].first) +
abs(vec[i].second - vec[(i + 1) % nn].second);
for (int i = 0; i < nn; i++) {
for (int j = i + 1; j < nn; j++) {
for (int k = 0; k < n; k++) {
if (A[k] == vec[i] || A[k] == vec[j])
continue;
else {
int b1 = max({A[k].first, vec[i].first, vec[j].first}) -
min({A[k].first, vec[i].first, vec[j].first});
int b2 = max({A[k].second, vec[i].second, vec[j].second}) -
min({A[k].second, vec[i].second, vec[j].second});
ans[3] = max(ans[3], 2 * (b1 + b2));
}
}
}
}
}
for (int i = 5; i <= n; i++) ans[i] = ans[4];
for (int i = 3; i <= n; i++) printf("%d%c", ans[i], (i == n) ? '\n' : ' ');
}
|
A permutation of size n is an array of size n such that each integer from 1 to n occurs exactly once in this array. An inversion in a permutation p is a pair of indices (i, j) such that i > j and a_i < a_j. For example, a permutation [4, 1, 3, 2] contains 4 inversions: (2, 1), (3, 1), (4, 1), (4, 3).
You are given a permutation p of size n. However, the numbers on some positions are replaced by -1. Let the valid permutation be such a replacement of -1 in this sequence back to numbers from 1 to n in such a way that the resulting sequence is a permutation of size n.
The given sequence was turned into a valid permutation randomly with the equal probability of getting each valid permutation.
Calculate the expected total number of inversions in the resulting valid permutation.
It can be shown that it is in the form of P/Q where P and Q are non-negative integers and Q ≠ 0. Report the value of P ⋅ Q^{-1} \pmod {998244353}.
Input
The first line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the sequence.
The second line contains n integers p_1, p_2, ..., p_n (-1 ≤ p_i ≤ n, p_i ≠ 0) — the initial sequence.
It is guaranteed that all elements not equal to -1 are pairwise distinct.
Output
Print a single integer — the expected total number of inversions in the resulting valid permutation.
It can be shown that it is in the form of P/Q where P and Q are non-negative integers and Q ≠ 0. Report the value of P ⋅ Q^{-1} \pmod {998244353}.
Examples
Input
3
3 -1 -1
Output
499122179
Input
2
1 2
Output
0
Input
2
-1 -1
Output
499122177
Note
In the first example two resulting valid permutations are possible:
* [3, 1, 2] — 2 inversions;
* [3, 2, 1] — 3 inversions.
The expected value is (2 ⋅ 1 + 3 ⋅ 1)/(2) = 2.5.
In the second example no -1 are present, thus the only valid permutation is possible — the given one. It has 0 inversions.
In the third example there are two resulting valid permutations — one with 0 inversions and one with 1 inversion.
|
#include <bits/stdc++.h>
using namespace std;
const int kNmax = 2e5 + 10;
const int kMod = 998244353;
int n, p[kNmax];
int emptyLeft[kNmax], emptyRight[kNmax];
int countBigger[kNmax], countSmaller[kNmax];
int res;
bool seen[kNmax];
class FT {
public:
FT(int n) {
sz_ = n;
arr_.resize(sz_ + 5);
}
int lsb(int x) { return (x & (x - 1)) ^ x; }
void update(int pos) {
for (; pos <= sz_; pos += lsb(pos)) {
arr_[pos]++;
}
}
int query(int pos) {
int res = 0;
for (; pos > 0; pos -= lsb(pos)) {
res += arr_[pos];
}
return res;
}
vector<int> arr_;
int sz_;
};
FT* ft;
int fastPow(int n, int p) {
if (!p) {
return 1;
}
if (p % 2) {
return (1LL * n * fastPow(n, p - 1)) % kMod;
}
int tmp = fastPow(n, p / 2);
return (1LL * tmp * tmp) % kMod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
ft = new FT(n);
for (int i = 1; i <= n; i++) {
cin >> p[i];
if (p[i] == -1) {
emptyLeft[i]++;
emptyRight[i]++;
continue;
}
seen[p[i]] = true;
}
int cntUnknown = 0;
for (int i = 1; i <= n; i++) {
if (!seen[i]) {
cntUnknown++;
countBigger[i]++;
countSmaller[i]++;
}
}
for (int i = 1; i <= n; i++) {
countSmaller[i] += countSmaller[i - 1];
emptyLeft[i] += emptyLeft[i - 1];
}
for (int i = n; i; i--) {
countBigger[i] += countBigger[i + 1];
emptyRight[i] += emptyRight[i + 1];
}
for (int i = 1; i <= n; i++) {
if (p[i] != -1) {
res = (res + ft->query(n) - ft->query(p[i])) % kMod;
ft->update(p[i]);
int exp = (1LL * countSmaller[p[i]] * emptyRight[i]) % kMod;
exp = (1LL * exp * fastPow(cntUnknown, kMod - 2)) % kMod;
res = (res + exp) % kMod;
exp = (1LL * countBigger[p[i]] * emptyLeft[i]) % kMod;
exp = (1LL * exp * fastPow(cntUnknown, kMod - 2)) % kMod;
res = (res + exp) % kMod;
}
}
int exp = (1LL * cntUnknown * (cntUnknown - 1)) % kMod;
exp = (1LL * exp * fastPow(4, kMod - 2)) % kMod;
res = (res + exp) % kMod;
cout << res;
}
|
You are given a permutation p_1, p_2, ..., p_n. You should answer q queries. Each query is a pair (l_i, r_i), and you should calculate f(l_i, r_i).
Let's denote m_{l, r} as the position of the maximum in subsegment p_l, p_{l+1}, ..., p_r.
Then f(l, r) = (r - l + 1) + f(l, m_{l,r} - 1) + f(m_{l,r} + 1, r) if l ≤ r or 0 otherwise.
Input
The first line contains two integers n and q (1 ≤ n ≤ 10^6, 1 ≤ q ≤ 10^6) — the size of the permutation p and the number of queries.
The second line contains n pairwise distinct integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, p_i ≠ p_j for i ≠ j) — permutation p.
The third line contains q integers l_1, l_2, ..., l_q — the first parts of the queries.
The fourth line contains q integers r_1, r_2, ..., r_q — the second parts of the queries.
It's guaranteed that 1 ≤ l_i ≤ r_i ≤ n for all queries.
Output
Print q integers — the values f(l_i, r_i) for the corresponding queries.
Example
Input
4 5
3 1 4 2
2 1 1 2 1
2 3 4 4 1
Output
1 6 8 5 1
Note
Description of the queries:
1. f(2, 2) = (2 - 2 + 1) + f(2, 1) + f(3, 2) = 1 + 0 + 0 = 1;
2. f(1, 3) = (3 - 1 + 1) + f(1, 2) + f(4, 3) = 3 + (2 - 1 + 1) + f(1, 0) + f(2, 2) = 3 + 2 + (2 - 2 + 1) = 6;
3. f(1, 4) = (4 - 1 + 1) + f(1, 2) + f(4, 4) = 4 + 3 + 1 = 8;
4. f(2, 4) = (4 - 2 + 1) + f(2, 2) + f(4, 4) = 3 + 1 + 1 = 5;
5. f(1, 1) = (1 - 1 + 1) + 0 + 0 = 1.
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long mod = 998244353;
const int MXN = 1e6 + 7;
int n, q;
int ar[MXN], ls[MXN], rs[MXN];
int stk[MXN];
long long ans[MXN];
std::vector<int> vs[MXN];
struct FenwickTree {
long long BIT[MXN], N;
void init(int n) {
N = n + 3;
for (int i = 0; i <= n + 3; ++i) BIT[i] = 0;
}
int lowbit(int x) { return x & (-x); }
void add(int x, int val) {
for (; x <= N; x += lowbit(x)) BIT[x] += val;
}
long long query(int x) {
long long ans = 0;
for (; x; x -= lowbit(x)) ans += BIT[x];
return ans;
}
} bit1, bit2;
void go() {
for (int i = 1; i <= q; ++i) vs[ls[i]].emplace_back(i);
int top = 0;
bit1.init(n), bit2.init(n);
for (int i = n, j; i >= 1; --i) {
while (top && ar[stk[top]] < ar[i]) --top;
j = n + 1;
if (top) j = stk[top];
stk[++top] = i;
bit1.add(j, j - i);
bit1.add(i, -i + 1);
bit1.add(j, i - 1);
bit2.add(i, 1);
bit2.add(j, -1);
for (auto id : vs[i])
ans[id] += (bit1.query(rs[id]) + rs[id] * bit2.query(rs[id]));
}
}
int main(int argc, char const *argv[]) {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) scanf("%d", &ar[i]);
for (int i = 1; i <= q; ++i) scanf("%d", &ls[i]);
for (int i = 1; i <= q; ++i) scanf("%d", &rs[i]);
go();
for (int i = 1; i <= n; ++i) vs[i].clear();
reverse(ar + 1, ar + n + 1);
for (int i = 1; i <= q; ++i) ls[i] = n + 1 - ls[i], rs[i] = n + 1 - rs[i];
for (int i = 1; i <= q; ++i) swap(ls[i], rs[i]);
go();
for (int i = 1; i <= q; ++i)
printf("%lld%c", ans[i] - (rs[i] - ls[i] + 1), i == q ? '\n' : ' ');
return 0;
}
|
Two integer sequences existed initially — one of them was strictly increasing, and the other one — strictly decreasing.
Strictly increasing sequence is a sequence of integers [x_1 < x_2 < ... < x_k]. And strictly decreasing sequence is a sequence of integers [y_1 > y_2 > ... > y_l]. Note that the empty sequence and the sequence consisting of one element can be considered as increasing or decreasing.
They were merged into one sequence a. After that sequence a got shuffled. For example, some of the possible resulting sequences a for an increasing sequence [1, 3, 4] and a decreasing sequence [10, 4, 2] are sequences [1, 2, 3, 4, 4, 10] or [4, 2, 1, 10, 4, 3].
This shuffled sequence a is given in the input.
Your task is to find any two suitable initial sequences. One of them should be strictly increasing and the other one — strictly decreasing. Note that the empty sequence and the sequence consisting of one element can be considered as increasing or decreasing.
If there is a contradiction in the input and it is impossible to split the given sequence a to increasing and decreasing sequences, print "NO".
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
If there is a contradiction in the input and it is impossible to split the given sequence a to increasing and decreasing sequences, print "NO" in the first line.
Otherwise print "YES" in the first line and any two suitable sequences. Note that the empty sequence and the sequence consisting of one element can be considered as increasing or decreasing.
In the second line print n_i — the number of elements in the strictly increasing sequence. n_i can be zero, in this case the increasing sequence is empty.
In the third line print n_i integers inc_1, inc_2, ..., inc_{n_i} in the increasing order of its values (inc_1 < inc_2 < ... < inc_{n_i}) — the strictly increasing sequence itself. You can keep this line empty if n_i = 0 (or just print the empty line).
In the fourth line print n_d — the number of elements in the strictly decreasing sequence. n_d can be zero, in this case the decreasing sequence is empty.
In the fifth line print n_d integers dec_1, dec_2, ..., dec_{n_d} in the decreasing order of its values (dec_1 > dec_2 > ... > dec_{n_d}) — the strictly decreasing sequence itself. You can keep this line empty if n_d = 0 (or just print the empty line).
n_i + n_d should be equal to n and the union of printed sequences should be a permutation of the given sequence (in case of "YES" answer).
Examples
Input
7
7 2 7 3 3 1 4
Output
YES
2
3 7
5
7 4 3 2 1
Input
5
4 3 1 5 3
Output
YES
1
3
4
5 4 3 1
Input
5
1 1 2 1 2
Output
NO
Input
5
0 1 2 3 4
Output
YES
0
5
4 3 2 1 0
|
n = int(input())
a = [int(s) for s in input().split()]
d = dict()
for i in a:
x = d.get(i,0)
if x == 0:
d[i] = 1
else:
d[i] += 1
up = []
down = []
for i in d.keys():
k = d[i]
if k == 1:
up.append(i)
elif k == 2:
up.append(i)
down.append(i)
else:
print('NO')
exit()
up.sort()
down.sort(reverse = True)
print('YES')
print(len(up))
print(' '.join([str(i) for i in up]))
print(len(down))
print(' '.join([str(i) for i in down]))
|
Polycarp wants to train before another programming competition. During the first day of his training he should solve exactly 1 problem, during the second day — exactly 2 problems, during the third day — exactly 3 problems, and so on. During the k-th day he should solve k problems.
Polycarp has a list of n contests, the i-th contest consists of a_i problems. During each day Polycarp has to choose exactly one of the contests he didn't solve yet and solve it. He solves exactly k problems from this contest. Other problems are discarded from it. If there are no contests consisting of at least k problems that Polycarp didn't solve yet during the k-th day, then Polycarp stops his training.
How many days Polycarp can train if he chooses the contests optimally?
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of contests.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5) — the number of problems in the i-th contest.
Output
Print one integer — the maximum number of days Polycarp can train if he chooses the contests optimally.
Examples
Input
4
3 1 4 1
Output
3
Input
3
1 1 1
Output
1
Input
5
1 1 1 2 2
Output
2
|
a = int(input())
b = [int(x) for x in input().split()]
b.sort()
s = 1
q = 0
for i in b:
if i >= s:
s += 1
q += 1
print(q)
|
The Cybermen and the Daleks have long been the Doctor's main enemies. Everyone knows that both these species enjoy destroying everything they encounter. However, a little-known fact about them is that they both also love taking Turing tests!
Heidi designed a series of increasingly difficult tasks for them to spend their time on, which would allow the Doctor enough time to save innocent lives!
The funny part is that these tasks would be very easy for a human to solve.
The first task is as follows. There are some points on the plane. All but one of them are on the boundary of an axis-aligned square (its sides are parallel to the axes). Identify that point.
Input
The first line contains an integer n (2 ≤ n ≤ 10).
Each of the following 4n + 1 lines contains two integers x_i, y_i (0 ≤ x_i, y_i ≤ 50), describing the coordinates of the next point.
It is guaranteed that there are at least n points on each side of the square and all 4n + 1 points are distinct.
Output
Print two integers — the coordinates of the point that is not on the boundary of the square.
Examples
Input
2
0 0
0 1
0 2
1 0
1 1
1 2
2 0
2 1
2 2
Output
1 1
Input
2
0 0
0 1
0 2
0 3
1 0
1 2
2 0
2 1
2 2
Output
0 3
Note
In both examples, the square has four sides x=0, x=2, y=0, y=2.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long int n, i, j;
vector<pair<long long int, long long int> > v;
cin >> n;
for (i = 0; i < 4 * n + 1; i++) {
long long int x, y;
cin >> x >> y;
v.push_back(make_pair(x, y));
}
for (i = 0; i < v.size(); i++) {
vector<pair<long long int, long long int> > aux;
long long int f1 = 0, f2 = 0, f3 = 0, f4 = 0, mx = -1, my = -1, miy = 1e18,
mix = 1e18;
for (j = 0; j < v.size(); j++) {
if (i == j) continue;
mix = min(mix, v[j].first);
miy = min(miy, v[j].second);
mx = max(mx, v[j].first);
my = max(my, v[j].second);
aux.push_back(v[j]);
}
for (j = 0; j < aux.size(); j++) {
if (aux[j].first == mix)
if (aux[j].second >= miy && aux[j].second <= my) f1++;
if (aux[j].first == mx)
if (aux[j].second >= miy && aux[j].second <= my) f2++;
if (aux[j].second == miy)
if (aux[j].first >= mix && aux[j].first <= mx) f3++;
if (aux[j].second == my)
if (aux[j].first >= mix && aux[j].first <= mx) f4++;
if (aux[j].first != mix && aux[j].first != mx && aux[j].second != miy &&
aux[j].second != my)
f1 = -1e18;
}
if (f1 >= n && f2 >= n && f3 >= n && f4 >= n) {
cout << v[i].first << " " << v[i].second << "\n";
return 0;
}
}
return 0;
}
|
The subsequence is a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements.
You are given an integer n.
You have to find a sequence s consisting of digits \{1, 3, 7\} such that it has exactly n subsequences equal to 1337.
For example, sequence 337133377 has 6 subsequences equal to 1337:
1. 337\underline{1}3\underline{3}\underline{3}7\underline{7} (you can remove the second and fifth characters);
2. 337\underline{1}\underline{3}3\underline{3}7\underline{7} (you can remove the third and fifth characters);
3. 337\underline{1}\underline{3}\underline{3}37\underline{7} (you can remove the fourth and fifth characters);
4. 337\underline{1}3\underline{3}\underline{3}\underline{7}7 (you can remove the second and sixth characters);
5. 337\underline{1}\underline{3}3\underline{3}\underline{7}7 (you can remove the third and sixth characters);
6. 337\underline{1}\underline{3}\underline{3}3\underline{7}7 (you can remove the fourth and sixth characters).
Note that the length of the sequence s must not exceed 10^5.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 10) — the number of queries.
Next t lines contains a description of queries: the i-th line contains one integer n_i (1 ≤ n_i ≤ 10^9).
Output
For the i-th query print one string s_i (1 ≤ |s_i| ≤ 10^5) consisting of digits \{1, 3, 7\}. String s_i must have exactly n_i subsequences 1337. If there are multiple such strings, print any of them.
Example
Input
2
6
1
Output
113337
1337
|
for _ in range(int(raw_input())):
n = int(raw_input())
if n <= 10 ** 5 - 5:
print('133' + '7' * n)
else:
cf = 300
g = n - (cf + 2) * (cf + 1) // 2
b = g // (cf * (cf - 1) // 2)
c = g % (cf * (cf - 1) // 2)
print('1' + '3' * cf + '7' * b + '1' * c + '337')
|
For her birthday Alice received an interesting gift from her friends – The Light Square. The Light Square game is played on an N × N lightbulbs square board with a magical lightbulb bar of size N × 1 that has magical properties. At the start of the game some lights on the square board and magical bar are turned on. The goal of the game is to transform the starting light square board pattern into some other pattern using the magical bar without rotating the square board. The magical bar works as follows:
It can be placed on any row or column
The orientation of the magical lightbulb must be left to right or top to bottom for it to keep its magical properties
The entire bar needs to be fully placed on a board
The lights of the magical bar never change
If the light on the magical bar is the same as the light of the square it is placed on it will switch the light on the square board off, otherwise it will switch the light on
The magical bar can be used an infinite number of times
Alice has a hard time transforming her square board into the pattern Bob gave her. Can you help her transform the board or let her know it is impossible? If there are multiple solutions print any.
Input
The first line contains one positive integer number N\ (1 ≤ N ≤ 2000) representing the size of the square board.
The next N lines are strings of length N consisting of 1's and 0's representing the initial state of the square board starting from the top row. If the character in a string is 1 it means the light is turned on, otherwise it is off.
The next N lines are strings of length N consisting of 1's and 0's representing the desired state of the square board starting from the top row that was given to Alice by Bob.
The last line is one string of length N consisting of 1's and 0's representing the pattern of the magical bar in a left to right order.
Output
Transform the instructions for Alice in order to transform the square board into the pattern Bob gave her. The first line of the output contains an integer number M\ (0 ≤ M ≤ 10^5) representing the number of times Alice will need to apply the magical bar.
The next M lines are of the form "col X" or "row X", where X is 0-based index of the matrix, meaning the magical bar should be applied to either row X or column X. If there is no solution, print only -1. In case of multiple solutions print any correct one.
Examples
Input
2
11
11
00
01
11
Output
-1
Input
2
10
00
00
00
10
Output
1
row 0
Input
3
110
011
100
100
011
100
100
Output
3
row 0
col 0
col 1
Note
Example 1: It is impossible to transform square board from one format to another
Example 2: Magic bar can be applied on first row or column.
|
#include <bits/stdc++.h>
const int N = 4050;
int n;
std::vector<int> G[N << 1];
bool mark[N << 1];
int S[N << 1], c;
bool dfs(int x) {
if (mark[x ^ 1]) return 0;
if (mark[x]) return 1;
mark[x] = 1;
S[c++] = x;
for (int i = 0; i < G[x].size(); ++i)
if (!dfs(G[x][i])) return 0;
return 1;
}
void init(int xd) {
n = xd;
for (int i = 0; i < 2 * n; ++i) G[i].clear();
memset(mark, 0, sizeof(mark));
}
void add_clause(int x, int xval, int y, int yval) {
x = (x << 1) + xval;
y = (y << 1) + yval;
G[x ^ 1].push_back(y);
G[y ^ 1].push_back(x);
}
void add_xor(int x, int y) {
add_clause(x, 0, y, 0);
add_clause(x, 1, y, 1);
}
void add_xnor(int x, int y) {
add_clause(x, 1, y, 0);
add_clause(x, 0, y, 1);
}
void add_true(int x) { add_clause(x, 1, x, 1); }
void add_false(int x) { add_clause(x, 0, x, 0); }
bool solve() {
for (int i = 0; i < 2 * n; i += 2)
if (!mark[i] && !mark[i + 1]) {
c = 0;
if (!dfs(i)) {
while (c) mark[S[--c]] = 0;
if (!dfs(i + 1)) return 0;
}
}
return 1;
}
void fail() {
std::cout << -1 << "\n";
std::exit(0);
}
int mat[2005][2005];
int tab[2005];
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
int first;
std::cin >> first;
for (int i = 0; i < (first); ++i) {
for (int j = 0; j < (first); ++j) {
char x;
std::cin >> x;
mat[i][j] = (int)(x == '1');
}
}
for (int i = 0; i < (first); ++i) {
for (int j = 0; j < (first); ++j) {
char a;
std::cin >> a;
mat[i][j] ^= (int)(a == '1');
}
}
for (int i = 0; i < (first); ++i) {
char x;
std::cin >> x;
tab[i] = (int)(x == '1');
}
init(2 * first);
for (int i = 0; i < (first); ++i) {
for (int j = 0; j < (first); ++j) {
int a = tab[j];
int b = tab[i];
if (mat[i][j] == 1) {
if (a == 0 && b == 0) fail();
if (a == 1 && b == 0) add_true(i);
if (a == 0 && b == 1) add_true(first + j);
if (a == 1 && b == 1) add_xor(i, first + j);
} else {
if (a == 1 && b == 0) add_false(i);
if (a == 0 && b == 1) add_false(first + j);
if (a == 1 && b == 1) add_xnor(i, first + j);
}
}
}
if (solve() == false)
std::cout << -1 << "\n";
else {
std::vector<std::pair<int, int> > ans;
for (int i = 0; i < (first); ++i)
if (mark[(i << 1) + 1]) ans.push_back(std::make_pair(0, i));
for (int i = 0; i < (first); ++i)
if (mark[((i + first) << 1) + 1]) ans.push_back(std::make_pair(1, i));
std::cout << (int)(ans).size() << "\n";
for (auto &i : (ans)) {
if (i.first == 0)
std::cout << "row " << i.second << "\n";
else
std::cout << "col " << i.second << "\n";
}
}
return 0;
}
|
You are given a tree consisting of n vertices. A tree is an undirected connected acyclic graph.
<image> Example of a tree.
You have to paint each vertex into one of three colors. For each vertex, you know the cost of painting it in every color.
You have to paint the vertices so that any path consisting of exactly three distinct vertices does not contain any vertices with equal colors. In other words, let's consider all triples (x, y, z) such that x ≠ y, y ≠ z, x ≠ z, x is connected by an edge with y, and y is connected by an edge with z. The colours of x, y and z should be pairwise distinct. Let's call a painting which meets this condition good.
You have to calculate the minimum cost of a good painting and find one of the optimal paintings. If there is no good painting, report about it.
Input
The first line contains one integer n (3 ≤ n ≤ 100 000) — the number of vertices.
The second line contains a sequence of integers c_{1, 1}, c_{1, 2}, ..., c_{1, n} (1 ≤ c_{1, i} ≤ 10^{9}), where c_{1, i} is the cost of painting the i-th vertex into the first color.
The third line contains a sequence of integers c_{2, 1}, c_{2, 2}, ..., c_{2, n} (1 ≤ c_{2, i} ≤ 10^{9}), where c_{2, i} is the cost of painting the i-th vertex into the second color.
The fourth line contains a sequence of integers c_{3, 1}, c_{3, 2}, ..., c_{3, n} (1 ≤ c_{3, i} ≤ 10^{9}), where c_{3, i} is the cost of painting the i-th vertex into the third color.
Then (n - 1) lines follow, each containing two integers u_j and v_j (1 ≤ u_j, v_j ≤ n, u_j ≠ v_j) — the numbers of vertices connected by the j-th undirected edge. It is guaranteed that these edges denote a tree.
Output
If there is no good painting, print -1.
Otherwise, print the minimum cost of a good painting in the first line. In the second line print n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ 3), where the i-th integer should denote the color of the i-th vertex. If there are multiple good paintings with minimum cost, print any of them.
Examples
Input
3
3 2 3
4 3 2
3 1 3
1 2
2 3
Output
6
1 3 2
Input
5
3 4 2 1 2
4 2 1 5 4
5 3 2 1 1
1 2
3 2
4 3
5 3
Output
-1
Input
5
3 4 2 1 2
4 2 1 5 4
5 3 2 1 1
1 2
3 2
4 3
5 4
Output
9
1 3 2 1 3
Note
All vertices should be painted in different colors in the first example. The optimal way to do it is to paint the first vertex into color 1, the second vertex — into color 3, and the third vertex — into color 2. The cost of this painting is 3 + 2 + 1 = 6.
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> adj[100005];
long long parent[100005];
vector<long long> temp;
void find_parent(long long v, long long par) {
parent[v] = par;
for (auto p : adj[v])
if (p != par) find_parent(p, v);
}
long long find_col(long long x, long long y) {
long long z;
if (x == 1 && y == 2) z = 3;
if (x == 2 && y == 1) z = 3;
if (x == 1 && y == 3) z = 2;
if (x == 3 && y == 1) z = 2;
if (x == 2 && y == 3) z = 1;
if (x == 3 && y == 2) z = 1;
return z;
}
void dfs(long long v, long long par) {
if (temp[v] == 0) {
temp[v] = find_col(temp[par], temp[parent[par]]);
}
for (auto p : adj[v])
if (p != par) dfs(p, v);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, i, j, x, y;
cin >> n;
long long c1[n + 1], c2[n + 1], c3[n + 1];
for (i = 1; i <= n; i++) cin >> c1[i];
for (i = 1; i <= n; i++) cin >> c2[i];
for (i = 1; i <= n; i++) cin >> c3[i];
for (i = 1; i < n; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (i = 1; i <= n; i++) {
if (adj[i].size() > 2) {
cout << "-1";
return 0;
}
}
find_parent(1, 0);
long long ans = 1e18, cost;
long long col[n + 1];
temp.assign(n + 1, 0);
temp[1] = 1;
temp[adj[1][0]] = 2;
if (adj[1].size() == 2) temp[adj[1][1]] = 3;
dfs(1, 0);
cost = 0;
for (i = 1; i <= n; i++) {
if (temp[i] == 1) cost += c1[i];
if (temp[i] == 2) cost += c2[i];
if (temp[i] == 3) cost += c3[i];
}
if (cost < ans) {
ans = cost;
for (i = 1; i <= n; i++) col[i] = temp[i];
}
temp.assign(n + 1, 0);
temp[1] = 1;
temp[adj[1][0]] = 3;
if (adj[1].size() == 2) temp[adj[1][1]] = 2;
dfs(1, 0);
cost = 0;
for (i = 1; i <= n; i++) {
if (temp[i] == 1) cost += c1[i];
if (temp[i] == 2) cost += c2[i];
if (temp[i] == 3) cost += c3[i];
}
if (cost < ans) {
ans = cost;
for (i = 1; i <= n; i++) col[i] = temp[i];
}
temp.assign(n + 1, 0);
temp[1] = 2;
temp[adj[1][0]] = 1;
if (adj[1].size() == 2) temp[adj[1][1]] = 3;
dfs(1, 0);
cost = 0;
for (i = 1; i <= n; i++) {
if (temp[i] == 1) cost += c1[i];
if (temp[i] == 2) cost += c2[i];
if (temp[i] == 3) cost += c3[i];
}
if (cost < ans) {
ans = cost;
for (i = 1; i <= n; i++) col[i] = temp[i];
}
temp.assign(n + 1, 0);
temp[1] = 2;
temp[adj[1][0]] = 3;
if (adj[1].size() == 2) temp[adj[1][1]] = 1;
dfs(1, 0);
cost = 0;
for (i = 1; i <= n; i++) {
if (temp[i] == 1) cost += c1[i];
if (temp[i] == 2) cost += c2[i];
if (temp[i] == 3) cost += c3[i];
}
if (cost < ans) {
ans = cost;
for (i = 1; i <= n; i++) col[i] = temp[i];
}
temp.assign(n + 1, 0);
temp[1] = 3;
temp[adj[1][0]] = 1;
if (adj[1].size() == 2) temp[adj[1][1]] = 2;
dfs(1, 0);
cost = 0;
for (i = 1; i <= n; i++) {
if (temp[i] == 1) cost += c1[i];
if (temp[i] == 2) cost += c2[i];
if (temp[i] == 3) cost += c3[i];
}
if (cost < ans) {
ans = cost;
for (i = 1; i <= n; i++) col[i] = temp[i];
}
temp.assign(n + 1, 0);
temp[1] = 3;
temp[adj[1][0]] = 2;
if (adj[1].size() == 2) temp[adj[1][1]] = 1;
dfs(1, 0);
cost = 0;
for (i = 1; i <= n; i++) {
if (temp[i] == 1) cost += c1[i];
if (temp[i] == 2) cost += c2[i];
if (temp[i] == 3) cost += c3[i];
}
if (cost < ans) {
ans = cost;
for (i = 1; i <= n; i++) col[i] = temp[i];
}
cout << ans << "\n";
for (i = 1; i <= n; i++) cout << col[i] << " ";
}
|
An integer sequence is called beautiful if the difference between any two consecutive numbers is equal to 1. More formally, a sequence s_1, s_2, …, s_{n} is beautiful if |s_i - s_{i+1}| = 1 for all 1 ≤ i ≤ n - 1.
Trans has a numbers 0, b numbers 1, c numbers 2 and d numbers 3. He wants to construct a beautiful sequence using all of these a + b + c + d numbers.
However, it turns out to be a non-trivial task, and Trans was not able to do it. Could you please help Trans?
Input
The only input line contains four non-negative integers a, b, c and d (0 < a+b+c+d ≤ 10^5).
Output
If it is impossible to construct a beautiful sequence satisfying the above constraints, print "NO" (without quotes) in one line.
Otherwise, print "YES" (without quotes) in the first line. Then in the second line print a + b + c + d integers, separated by spaces — a beautiful sequence. There should be a numbers equal to 0, b numbers equal to 1, c numbers equal to 2 and d numbers equal to 3.
If there are multiple answers, you can print any of them.
Examples
Input
2 2 2 1
Output
YES
0 1 0 1 2 3 2
Input
1 2 3 4
Output
NO
Input
2 2 2 3
Output
NO
Note
In the first test, it is easy to see, that the sequence is beautiful because the difference between any two consecutive numbers is equal to 1. Also, there are exactly two numbers, equal to 0, 1, 2 and exactly one number, equal to 3.
It can be proved, that it is impossible to construct beautiful sequences in the second and third tests.
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const long long Mod = 1e9 + 7;
long long powmod(long long a, long long b) {
long long res = 1;
a %= Mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % Mod;
a = a * a % Mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int T;
int num[4], sum;
int arr[maxn];
bool solve(int kai) {
int so_num[4] = {0};
for (int i = 0; i <= 3; i++) so_num[i] = num[i];
int kk = kai;
bool boo = true;
for (int i = 1; i <= sum; i++) {
arr[i] = kk;
so_num[kk]--;
if (!boo || i == sum) break;
switch (kk) {
case 0:
if (so_num[1] <= 0) boo = false;
kk = 1;
break;
case 1:
if (so_num[0]) {
kk = 0;
break;
}
if (!so_num[2]) boo = false;
kk = 2;
break;
case 2:
if (so_num[3]) {
kk = 3;
break;
}
if (!so_num[1]) boo = false;
kk = 1;
break;
case 3:
if (so_num[2] <= 0) boo = false;
kk = 2;
break;
}
}
if (!boo) return false;
return true;
}
int main() {
int T = 1;
for (int cas = 1; cas <= T; ++cas) {
sum = 0;
for (int i = 0; i <= 3; i++) scanf("%d", &num[i]);
for (int i = 0; i <= 3; i++) sum += num[i];
bool bo = false;
for (int j = 0; j <= 3; j++)
if (num[j] != 0 && solve(j)) {
bo = true;
break;
}
if (!bo)
puts("NO");
else {
puts("YES");
for (int i = 1; i <= sum; i++) printf("%d ", arr[i]);
puts("");
}
}
return 0;
}
|
Today, as a friendship gift, Bakry gave Badawy n integers a_1, a_2, ..., a_n and challenged him to choose an integer X such that the value \underset{1 ≤ i ≤ n}{max} (a_i ⊕ X) is minimum possible, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
As always, Badawy is too lazy, so you decided to help him and find the minimum possible value of \underset{1 ≤ i ≤ n}{max} (a_i ⊕ X).
Input
The first line contains integer n (1≤ n ≤ 10^5).
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 2^{30}-1).
Output
Print one integer — the minimum possible value of \underset{1 ≤ i ≤ n}{max} (a_i ⊕ X).
Examples
Input
3
1 2 3
Output
2
Input
2
1 5
Output
4
Note
In the first sample, we can choose X = 3.
In the second sample, we can choose X = 5.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int cnt = 1, T[N * 31][2], n;
long long t, a[N * 31];
void insert(long long x) {
int u = 0;
for (int i = 30; i >= 0; i--) {
int v = (x >> i) & 1;
if (!T[u][v]) {
memset(T[cnt], 0, sizeof(T[cnt]));
a[cnt] = 0;
T[u][v] = cnt++;
}
u = T[u][v];
}
a[u] = x;
}
long long dfs(int p, int k) {
if (!T[p][0] && !T[p][1]) return 0;
if (!T[p][0]) return dfs(T[p][1], k - 1);
if (!T[p][1]) return dfs(T[p][0], k - 1);
return (1LL << k) + min(dfs(T[p][0], k - 1), dfs(T[p][1], k - 1));
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &t);
insert(t);
}
printf("%lld\n", dfs(0, 30));
return 0;
}
|
The only difference between easy and hard versions is the constraint on k.
Gildong loves observing animals, so he bought two cameras to take videos of wild animals in a forest. The color of one camera is red, and the other one's color is blue.
Gildong is going to take videos for n days, starting from day 1 to day n. The forest can be divided into m areas, numbered from 1 to m. He'll use the cameras in the following way:
* On every odd day (1-st, 3-rd, 5-th, ...), bring the red camera to the forest and record a video for 2 days.
* On every even day (2-nd, 4-th, 6-th, ...), bring the blue camera to the forest and record a video for 2 days.
* If he starts recording on the n-th day with one of the cameras, the camera records for only one day.
Each camera can observe k consecutive areas of the forest. For example, if m=5 and k=3, he can put a camera to observe one of these three ranges of areas for two days: [1,3], [2,4], and [3,5].
Gildong got information about how many animals will be seen in each area each day. Since he would like to observe as many animals as possible, he wants you to find the best way to place the two cameras for n days. Note that if the two cameras are observing the same area on the same day, the animals observed in that area are counted only once.
Input
The first line contains three integers n, m, and k (1 ≤ n ≤ 50, 1 ≤ m ≤ 2 ⋅ 10^4, 1 ≤ k ≤ min(m,20)) – the number of days Gildong is going to record, the number of areas of the forest, and the range of the cameras, respectively.
Next n lines contain m integers each. The j-th integer in the i+1-st line is the number of animals that can be seen on the i-th day in the j-th area. Each number of animals is between 0 and 1000, inclusive.
Output
Print one integer – the maximum number of animals that can be observed.
Examples
Input
4 5 2
0 2 1 1 0
0 0 3 1 2
1 0 4 3 1
3 3 0 0 4
Output
25
Input
3 3 1
1 2 3
4 5 6
7 8 9
Output
31
Input
3 3 2
1 2 3
4 5 6
7 8 9
Output
44
Input
3 3 3
1 2 3
4 5 6
7 8 9
Output
45
Note
The optimal way to observe animals in the four examples are as follows:
Example 1:
<image>
Example 2:
<image>
Example 3:
<image>
Example 4:
<image>
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
template <typename TI, typename TX, typename TL>
class SegmentTree {
public:
struct node {
long long x = -INF;
node(){};
node(const TX &y) { set(y); };
void set(const TX &y) { x = y; };
};
node merge(const node &a, const node &b) {
node ans;
ans.x = max(a.x, b.x);
return ans;
}
template <typename T>
node merge(const node &a, const T &x, int n) {
node ans = a;
ans.x += x;
return ans;
}
int n;
vector<node> tree;
vector<TL> lazy;
const TL undefined = 0;
inline void unite(int v, int a, int b) { tree[v] = merge(tree[a], tree[b]); }
void build(int v, int l, int r, const vector<TX> &A) {
if (l == r) {
tree[v].set(A[l]);
return;
}
int left = v << 1, right = v << 1 | 1;
int md = (l + r) >> 1;
build(left, l, md, A);
build(right, md + 1, r, A);
unite(v, left, right);
}
void build(int v, int l, int r) {
if (l == r) {
return;
}
int left = v << 1, right = v << 1 | 1;
int md = (l + r) >> 1;
build(left, l, md);
build(right, md + 1, r);
unite(v, left, right);
}
SegmentTree(int _n) : n(_n) {
assert(n > 0);
tree.resize(4 * n);
lazy.assign(4 * n, undefined);
build(1, 0, n - 1);
}
SegmentTree(const vector<TX> &A) {
n = A.size();
assert(n > 0);
tree.resize(4 * n);
lazy.assign(4 * n, undefined);
build(1, 0, n - 1, A);
}
node get(int v, int ll, int rr, int l, int r) {
if (l > r) {
return node();
}
if (l == ll && r == rr) {
return tree[v];
}
push(v, ll, rr);
int left = v << 1, right = v << 1 | 1;
int md = (ll + rr) >> 1;
node a = get(left, ll, md, l, min(md, r));
node b = get(right, md + 1, rr, max(md + 1, l), r);
return merge(a, b);
}
template <typename T>
inline void uplazy(int v, int ll, int rr, const T &x) {
tree[v] = merge(tree[v], x, rr - ll + 1);
lazy[v] += x;
}
void push(int v, int ll, int rr) {
if (lazy[v] != undefined) {
if (ll != rr) {
int left = v << 1, right = v << 1 | 1;
int md = (ll + rr) >> 1;
uplazy(left, ll, md, lazy[v]);
uplazy(right, md + 1, rr, lazy[v]);
}
lazy[v] = undefined;
}
}
template <typename T>
void update(int v, int ll, int rr, int l, int r, const T &x) {
if (l > r) {
return;
}
if (ll == l && rr == r) {
uplazy(v, ll, rr, x);
} else {
push(v, ll, rr);
int left = v << 1, right = v << 1 | 1;
int md = (ll + rr) >> 1;
update(left, ll, md, l, min(md, r), x);
update(right, md + 1, rr, max(md + 1, l), r, x);
unite(v, left, right);
}
}
node get(int i) {
assert(i >= 0 && i < n);
node ans = get(1, 0, n - 1, i, i);
return ans;
}
node get(int l, int r) {
r = min(n - 1, r);
l = max(0, l);
assert(l <= r);
assert(l >= 0 && r < n);
node ans = get(1, 0, n - 1, l, r);
return ans;
}
template <typename T>
void update(int p, const T &x) {
assert(p >= 0 && p < n);
update(1, 0, n - 1, p, p, x);
}
template <typename T>
void update(int l, int r, const T &x) {
r = min(n - 1, r);
l = max(0, l);
assert(l <= r);
assert(l >= 0 && r < n);
update(1, 0, n - 1, l, r, x);
}
};
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, m, k;
cin >> n >> m >> k;
vector<vector<long long>> A(n + 2, vector<long long>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> A[i][j];
}
}
vector<long long> dp(m);
for (int i = n - 1; i >= 0; i--) {
vector<long long> dp2(m);
SegmentTree<long long, long long, long long> sg(dp);
long long res = 0;
for (int j = 0; j < k - 1; j++) {
sg.update(j - k + 1, j, -A[i + 1][j]);
res += A[i][j] + A[i + 1][j];
}
for (int j = 0; j < m; j++) {
if (j + k <= m) {
res += A[i][j + k - 1] + A[i + 1][j + k - 1];
sg.update(j, j + k - 1, -A[i + 1][j + k - 1]);
}
auto tr = sg.get(0, m - 1).x;
tr = max(tr, 0LL);
dp2[j] = res + tr;
sg.update(j - k + 1, j, A[i + 1][j]);
res -= A[i][j] + A[i + 1][j];
}
dp2.swap(dp);
}
cout << *max_element(dp.begin(), dp.end()) << '\n';
return 0;
}
|
Dreamoon likes coloring cells very much.
There is a row of n cells. Initially, all cells are empty (don't contain any color). Cells are numbered from 1 to n.
You are given an integer m and m integers l_1, l_2, …, l_m (1 ≤ l_i ≤ n)
Dreamoon will perform m operations.
In i-th operation, Dreamoon will choose a number p_i from range [1, n-l_i+1] (inclusive) and will paint all cells from p_i to p_i+l_i-1 (inclusive) in i-th color. Note that cells may be colored more one than once, in this case, cell will have the color from the latest operation.
Dreamoon hopes that after these m operations, all colors will appear at least once and all cells will be colored. Please help Dreamoon to choose p_i in each operation to satisfy all constraints.
Input
The first line contains two integers n,m (1 ≤ m ≤ n ≤ 100 000).
The second line contains m integers l_1, l_2, …, l_m (1 ≤ l_i ≤ n).
Output
If it's impossible to perform m operations to satisfy all constraints, print "'-1" (without quotes).
Otherwise, print m integers p_1, p_2, …, p_m (1 ≤ p_i ≤ n - l_i + 1), after these m operations, all colors should appear at least once and all cells should be colored.
If there are several possible solutions, you can print any.
Examples
Input
5 3
3 2 2
Output
2 4 1
Input
10 1
1
Output
-1
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pi = pair<int, int>;
using vi = vector<int>;
const int nax = 100 * 1000 + 10;
int n, m;
int l[nax];
int p[nax];
ll sum;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
cin >> l[i];
sum += l[i];
}
if (sum < n) {
cout << "-1";
return 0;
}
for (int i = 1; i <= m; ++i) {
if (l[i] + i - 1 > n) {
cout << "-1";
return 0;
}
p[i] = i;
}
int w = n, pos = m;
while (pos > 0) {
if (p[pos] + l[pos] - 1 < w) {
p[pos] = w - l[pos] + 1;
w = p[pos] - 1;
pos--;
} else {
break;
}
}
if (p[1] != 1) {
cout << "-1";
return 0;
}
for (int i = 1; i <= m; i++) cout << p[i] << " ";
}
|
For the multiset of positive integers s=\\{s_1,s_2,...,s_k\}, define the Greatest Common Divisor (GCD) and Least Common Multiple (LCM) of s as follow:
* \gcd(s) is the maximum positive integer x, such that all integers in s are divisible on x.
* lcm(s) is the minimum positive integer x, that divisible on all integers from s.
For example, \gcd(\{8,12\})=4,\gcd(\{12,18,6\})=6 and lcm(\{4,6\})=12. Note that for any positive integer x, \gcd(\\{x\})=lcm(\\{x\})=x.
Orac has a sequence a with length n. He come up with the multiset t=\{lcm(\\{a_i,a_j\})\ |\ i<j\}, and asked you to find the value of \gcd(t) for him. In other words, you need to calculate the GCD of LCMs of all pairs of elements in the given sequence.
Input
The first line contains one integer n\ (2≤ n≤ 100 000).
The second line contains n integers, a_1, a_2, …, a_n (1 ≤ a_i ≤ 200 000).
Output
Print one integer: \gcd(\{lcm(\\{a_i,a_j\})\ |\ i<j\}).
Examples
Input
2
1 1
Output
1
Input
4
10 24 40 80
Output
40
Input
10
540 648 810 648 720 540 594 864 972 648
Output
54
Note
For the first example, t=\{lcm(\{1,1\})\}=\{1\}, so \gcd(t)=1.
For the second example, t=\{120,40,80,120,240,80\}, and it's not hard to see that \gcd(t)=40.
|
from collections import Counter
from math import floor, sqrt
try:
long
except NameError:
long = int
def fac(n):
step = lambda x: 1 + (x<<2) - ((x>>1)<<1)
maxq = long(floor(sqrt(n)))
d = 1
q = 2 if n % 2 == 0 else 3
while q <= maxq and n % q != 0:
q = step(d)
d += 1
return [q] + fac(n // q) if q <= maxq else [n]
for _ in range(1):
n=int(input())
li=list(map(int,input().split()))
e=[[] for i in range(200007)]
#f=[30 for i in range(200007)]
#g=[0 for i in range(200007)]
d=[0 for i in range(200007)]
for i in li:
k=Counter(fac(i))
for j in k:
e[j].append(k[j])
d[j]+=1
ans=1
for i in range(200007):
if d[i]==n:
p=min(e[i])
f=30
o=0
for l in e[i]:
if l!=p:
o+=1
f=min(f,l)
if o==n-1:
p=f
ans*=i**(p)
#print(i,p)
if d[i]==n-1:
ans*=i**min(e[i])
print(ans)
|
Lee bought some food for dinner time, but Lee's friends eat dinner in a deadly way. Lee is so scared, he doesn't want to die, at least not before seeing Online IOI 2020...
There are n different types of food and m Lee's best friends. Lee has w_i plates of the i-th type of food and each friend has two different favorite types of food: the i-th friend's favorite types of food are x_i and y_i (x_i ≠ y_i).
Lee will start calling his friends one by one. Whoever is called will go to the kitchen and will try to eat one plate of each of his favorite food types. Each of the friends will go to the kitchen exactly once.
The only problem is the following: if a friend will eat at least one plate of food (in total) then he will be harmless. But if there is nothing left for him to eat (neither x_i nor y_i), he will eat Lee instead ×\\_×.
Lee can choose the order of friends to call, so he'd like to determine if he can survive dinner or not. Also, he'd like to know the order itself.
Input
The first line contains two integers n and m (2 ≤ n ≤ 10^5; 1 ≤ m ≤ 2 ⋅ 10^5) — the number of different food types and the number of Lee's friends.
The second line contains n integers w_1, w_2, …, w_n (0 ≤ w_i ≤ 10^6) — the number of plates of each food type.
The i-th line of the next m lines contains two integers x_i and y_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i) — the favorite types of food of the i-th friend.
Output
If Lee can survive the dinner then print ALIVE (case insensitive), otherwise print DEAD (case insensitive).
Also, if he can survive the dinner, print the order Lee should call friends. If there are multiple valid orders, print any of them.
Examples
Input
3 3
1 2 1
1 2
2 3
1 3
Output
ALIVE
3 2 1
Input
3 2
1 1 0
1 2
1 3
Output
ALIVE
2 1
Input
4 4
1 2 0 1
1 3
1 2
2 3
2 4
Output
ALIVE
1 3 2 4
Input
5 5
1 1 1 2 1
3 4
1 2
2 3
4 5
4 5
Output
ALIVE
5 4 1 3 2
Input
4 10
2 4 1 4
3 2
4 2
4 1
3 1
4 1
1 3
3 2
2 1
3 1
2 4
Output
DEAD
Note
In the first example, any of the following orders of friends are correct : [1, 3, 2], [3, 1, 2], [2, 3, 1], [3, 2, 1].
In the second example, Lee should call the second friend first (the friend will eat a plate of food 1) and then call the first friend (the friend will eat a plate of food 2). If he calls the first friend sooner than the second one, then the first friend will eat one plate of food 1 and food 2 and there will be no food left for the second friend to eat.
|
#include <bits/stdc++.h>
using namespace std;
int X[200005], Y[200005], W[200005], S[200005], colormark[200005], mark[200005];
vector<int> V[200005];
vector<int> ans;
int main() {
set<pair<int, int>> pq;
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> W[i];
for (int i = 0; i < m; i++) {
cin >> X[i] >> Y[i];
S[X[i]]++;
S[Y[i]]++;
V[X[i]].push_back(i);
V[Y[i]].push_back(i);
}
for (long long int i = 1; i <= n; i++) {
if (S[i]) pq.insert({S[i] - W[i], i});
}
while (pq.size()) {
auto q = (*pq.begin());
pq.erase(pq.begin());
if (q.first > 0) {
cout << "DEAD" << '\n';
exit(0);
}
int id = q.second;
vector<int> wt;
for (auto j : V[id]) {
if (mark[j]) continue;
ans.push_back(j);
if (X[j] == id) {
swap(X[j], Y[j]);
}
wt.push_back(X[j]);
mark[j] = 1;
}
for (auto j : wt) {
pq.erase({S[j] - W[j], j});
S[j]--;
if (S[j] > 0) pq.insert({S[j] - W[j], j});
}
}
reverse(ans.begin(), ans.end());
cout << "ALIVE" << '\n';
for (auto j : ans) {
cout << j + 1 << " ";
}
}
|
A binary matrix is called good if every even length square sub-matrix has an odd number of ones.
Given a binary matrix a consisting of n rows and m columns, determine the minimum number of cells you need to change to make it good, or report that there is no way to make it good at all.
All the terms above have their usual meanings — refer to the Notes section for their formal definitions.
Input
The first line of input contains two integers n and m (1 ≤ n ≤ m ≤ 10^6 and n⋅ m ≤ 10^6) — the number of rows and columns in a, respectively.
The following n lines each contain m characters, each of which is one of 0 and 1. If the j-th character on the i-th line is 1, then a_{i,j} = 1. Similarly, if the j-th character on the i-th line is 0, then a_{i,j} = 0.
Output
Output the minimum number of cells you need to change to make a good, or output -1 if it's not possible at all.
Examples
Input
3 3
101
001
110
Output
2
Input
7 15
000100001010010
100111010110001
101101111100100
010000111111010
111010010100001
000011001111101
111111011010011
Output
-1
Note
In the first case, changing a_{1,1} to 0 and a_{2,2} to 1 is enough.
You can verify that there is no way to make the matrix in the second case good.
Some definitions —
* A binary matrix is one in which every element is either 1 or 0.
* A sub-matrix is described by 4 parameters — r_1, r_2, c_1, and c_2; here, 1 ≤ r_1 ≤ r_2 ≤ n and 1 ≤ c_1 ≤ c_2 ≤ m.
* This sub-matrix contains all elements a_{i,j} that satisfy both r_1 ≤ i ≤ r_2 and c_1 ≤ j ≤ c_2.
* A sub-matrix is, further, called an even length square if r_2-r_1 = c_2-c_1 and r_2-r_1+1 is divisible by 2.
|
import java.io.*;
import java.util.*;
import java.math.*;
import java.util.regex.*;
public class Solution {
static class cell{
int r, c;
public cell(int r, int c) {
this.r = r;
this.c = c;
}
}
static class Pair<E, V> implements Comparable<Pair<E, V>>{
E a;
V b;
public Pair(E x, V y) {a = x;b=y;}
public int compareTo(Pair<E, V> p){
return Integer.compare((Integer)a, (Integer)p.a);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + (Integer)a;
result = prime * result + (Integer)b;
return result;
}
@Override
public boolean equals(Object obj) {
Pair<E, V> cur = (Pair<E, V>)obj;
if((Integer)a == (Integer)cur.a && (Integer)b == (Integer)cur.b)return true;
if((Integer)b == (Integer)cur.a && (Integer)a == (Integer)cur.b)return true;
return false;
}
}
public static void main(String[] args) throws Exception {
new Thread(null, null, "Anshum Gupta", 99999999) {
public void run() {
try {
solve();
} catch(Exception e) {
e.printStackTrace();
System.exit(1);
}
}
}.start();
}
public static long gcd(long a,long b)
{
if(a<b)
return gcd(b,a);
if(b==0)
return a;
return gcd(b,a%b);
}
static long lcm(int a,int b) {
return a*b / gcd(a,b);
}
static int[] z(char[]arr) {
int l = 0, r = 0;
int[]z = new int[n];
for(int i=1; i<n; i++) {
if(i > r) {
l = r = i;
while(r < n && arr[r-l] == arr[r])r++;
z[i] = r-- - l;
}else {
int k = i - l;
if(z[k] < r - i + l)z[i] = z[k];
else {
l = i;
while(r < n && arr[r-l] == arr[r])r++;
z[i] = r-- - l;
}
}
}
return z;
}
static long pow(long x,long y){
if(y == 0)return 1;
if(y==1)return x;
long a = pow(x,y/2);
a = (a*a)%mod;
if(y%2==0){
return a;
}
return (a*x)%mod;
}
static long my_inv(long a) {
return pow(a,mod-2);
}
static long bin(int a,int b) {
if(a < b || a<0 || b<0)return 0;
return ((fact[a]*inv_fact[a-b])%mod * inv_fact[b])%mod;
}
static void make_facts() {
fact=new long[mxN];
inv_fact = new long[mxN];
fact[0]=inv_fact[0]=1L;
for(int i=1;i<mxN;i++) {
fact[i] = (i*fact[i-1])%mod;
// inv_fact[i] = my_inv(fact[i]);
}
}
static final long mxx = (long)(1e18+5);
static final int mxN = (int)(1e6+5);
static final int mxV = (int)(1e5+5), log = 18;
static long mod = (long)(1e9+7); //998244353;//
static long[]fact, inv_fact;
static final int INF = (int)1e9;
static boolean[]vis;
static ArrayList<ArrayList<Integer>> adj;
static int n, m, k, x, y, z, q;
static char[]arr, str;
static char[][]a;
static char[][] transpose(char[][]a){
int x = a.length;
int y = a[0].length;
char[][]ans = new char[y][x];
for(int i=0; i<x; i++) {
for(int j=0; j<y; j++) {
ans[j][i] = a[i][j];
}
}
return ans;
}
static boolean works(boolean[][]board) {
// 2 * 2
for(int i=0; i+1 < board.length; i++) {
for(int j=0; j+1 < board[i].length; j++) {
int count = 0;
for(int x=0; x<2; x++) {
for(int y=0; y<2; y++) {
if(board[x+i][y+j])
count++;
}
}
if(count % 2 == 0)return false;
}
}
return true;
}
public static void solve() throws Exception {
// solve the problem here
s = new MyScanner();
out = new PrintWriter(new BufferedOutputStream(System.out), true);
// out = new PrintWriter("output.txt");
int tc = 1;//s.nextInt();
while(tc-->0){
int[] bitsIn=new int[1<<7];
for (int i=0; i<1<<7;i++) bitsIn[i]=Integer.bitCount(i);
n = s.nextInt();
m = s.nextInt();
a = s.next2DCharArray(n, m);
if(Math.min(n, m) > 3) {
out.println("-1");
continue;
}
if(Math.min(m, n) == 1) {
out.println("0");
continue;
}
if(m > n) {
a = transpose(a);
int temp = m;
m = n;
n = temp;
}
boolean[][]possibleTrans = new boolean[1<<m][1<<m];
for(int m1 = 0; m1 < 1<<m; m1++) {
for(int m2 = 0; m2 < 1<<m; m2++) {
boolean[][]mat = new boolean[m][2];
for(int k=0; k<m; k++) {
mat[k][0] = (m1 & (1<<k)) != 0;
}
for(int k=0; k<m; k++) {
mat[k][1] = (m2 & (1<<k)) != 0;
}
possibleTrans[m1][m2] = works(mat);
}
}
int[]dp = new int[1<<m];
int[]masks = new int[n];
for(int i=0; i<n; i++) {
int mask = 0;
for(int j=0; j<m; j++) {
if(a[i][j] == '1')
mask += (1<<j);
}
masks[i] = mask;
}
dp[masks[0]] = 0;
for(int i=0; i < (1<<m); i++) {
dp[i] = bitsIn[i ^ masks[0]];
}
for(int i=1; i<n; i++) {
int[]costs = new int[1<<m];
Arrays.fill(costs, INF);
for(int j=0; j < 1<<m; j++) {
for(int k=0; k< 1<<m; k++) {
if(possibleTrans[k][j]) {
costs[j] = Math.min(costs[j], dp[k] + bitsIn[j ^ masks[i]]);
}
}
}
dp = costs;
}
int ans = dp[0];
for(int i=0; i<(1<<m); i++) {
ans = Math.min(ans, dp[i]);
}
out.println(ans < INF ? ans : "-1");
}
out.flush();
out.close();
}
public static PrintWriter out;
public static MyScanner s;
static class MyScanner {
BufferedReader br;
StringTokenizer st;
public MyScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
public MyScanner(String fileName) {
try {
br = new BufferedReader(new FileReader(fileName));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong() { return Long.parseLong(next()); }
double nextDouble() { return Double.parseDouble(next()); }
int[] nextIntArray(int n){
int[]a = new int[n];
for(int i=0; i<n; i++) {
a[i] = this.nextInt();
}
return a;
}
long[] nextLongArray(int n) {
long[]a = new long[n];
for(int i=0; i<n; i++) {
a[i] = this.nextLong();
}
return a;
}
char[][] next2DCharArray(int n, int m){
char[][]arr = new char[n][m];
for(int i=0; i<n; i++) {
arr[i] = this.next().toCharArray();
}
return arr;
}
ArrayList<ArrayList<Integer>> readUndirectedUnweightedGraph(int n, int m) {
ArrayList<ArrayList<Integer>>adj = new ArrayList<ArrayList<Integer>>();
for(int i=0; i<=n; i++)adj.add(new ArrayList<Integer>());
for(int i=0; i<m; i++) {
int u = s.nextInt();
int v = s.nextInt();
adj.get(u).add(v);
adj.get(v).add(u);
}
return adj;
}
ArrayList<ArrayList<Integer>> readDirectedUnweightedGraph(int n, int m) {
ArrayList<ArrayList<Integer>>adj = new ArrayList<ArrayList<Integer>>();
for(int i=0; i<=n; i++)adj.add(new ArrayList<Integer>());
for(int i=0; i<m; i++) {
int u = s.nextInt();
int v = s.nextInt();
adj.get(u).add(v);
}
return adj;
}
String nextLine(){
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
|
You are given an array a consisting of n integers numbered from 1 to n.
Let's define the k-amazing number of the array as the minimum number that occurs in all of the subsegments of the array having length k (recall that a subsegment of a of length k is a contiguous part of a containing exactly k elements). If there is no integer occuring in all subsegments of length k for some value of k, then the k-amazing number is -1.
For each k from 1 to n calculate the k-amazing number of the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case print n integers, where the i-th integer is equal to the i-amazing number of the array.
Example
Input
3
5
1 2 3 4 5
5
4 4 4 4 2
6
1 3 1 5 3 1
Output
-1 -1 3 2 1
-1 4 4 4 2
-1 -1 1 1 1 1
|
t = int(input())
ns = []
for i in range(t):
n = int(input())
arr = list(map(int, input().split()))
nums = set(arr)
dct1 = {}
dct2 = {num: 0 for num in nums}
for idx, el in enumerate(arr):
if el in dct1:
dct2[el] = max(dct2[el], idx - dct1[el])
else:
dct2[el] = idx + 1
dct1[el] = idx
for el in dct2:
dct2[el] = max(dct2[el], n - dct1[el])
ans = []
temp = sorted(nums, key=lambda x: dct2[x])
index = 0
mini = 10**20
for k in range(1, n + 1):
while index < len(temp) and dct2[temp[index]] == k:
mini = min(mini, temp[index])
index += 1
if mini == 10**20:
ans.append(-1)
else:
ans.append(mini)
ns.append(ans)
for el in ns:
print(" ".join(list(map(str, el))))
|
Polycarp is editing a complicated computer program. First, variable x is declared and assigned to 0. Then there are instructions of two types:
1. set y v — assign x a value y or spend v burles to remove that instruction (thus, not reassign x);
2. if y ... end block — execute instructions inside the if block if the value of x is y and ignore the block otherwise.
if blocks can contain set instructions and other if blocks inside them.
However, when the value of x gets assigned to s, the computer breaks and immediately catches fire. Polycarp wants to prevent that from happening and spend as few burles as possible.
What is the minimum amount of burles he can spend on removing set instructions to never assign x to s?
Input
The first line contains two integers n and s (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ s ≤ 2 ⋅ 10^5) — the number of lines in the program and the forbidden value of x.
The following n lines describe the program. Each line is one of three types:
1. set y v (0 ≤ y ≤ 2 ⋅ 10^5, 1 ≤ v ≤ 10^9);
2. if y (0 ≤ y ≤ 2 ⋅ 10^5);
3. end.
Each if instruction is matched by an end instruction. Each end instruction has an if instruction to match.
Output
Print a single integer — the minimum amount of burles Polycarp can spend on removing set instructions to never assign x to s.
Examples
Input
5 1
set 1 10
set 2 15
if 2
set 1 7
end
Output
17
Input
7 2
set 3 4
if 3
set 10 4
set 2 7
set 10 1
end
set 4 2
Output
4
Input
9 200
if 0
set 5 5
if 5
set 100 13
end
if 100
set 200 1
end
end
Output
1
Input
1 10
set 1 15
Output
0
|
/*
_ _ _ _ _ _ _ _ _
\_\ /_/ \_\_\_\_\_\ \_\ /_/
\_\ /_/ \_\ \_\ /_/
\_\_/ \_\ \_\_/
\_\ \_\ \_\
\_\ \_\ \_\ \_\
\_\ \_\\_\ \_\
*/
#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")
#include <bits/stdc++.h>
using ll = int64_t;
constexpr ll inf = 1e18;
struct SegTree {
ll tag, mn;
SegTree *lc;
SegTree *rc;
};
SegTree *null = new SegTree;
SegTree *_pool[1 << 24];
SegTree *newTree() {
static int _ = 0;
_pool[_] = new SegTree;
auto t = _pool[_++];
t->lc = t->rc = null;
t->tag = 0;
t->mn = inf;
return t;
}
void add(SegTree *p, ll v) {
p->mn += v;
p->tag += v;
}
void push(SegTree *p) {
if (p->lc) {
add(p->lc, p->tag);
}
if (p->rc) {
add(p->rc, p->tag);
}
p->tag = 0;
}
void pull(SegTree *p) {
p->mn = std::min(p->lc->mn, p->rc->mn);
}
void modify(SegTree *&p, int l, int r, int x, ll v) {
if (p == null) {
p = newTree();
}
if (l == r) {
p->mn = v;
return;
}
push(p);
int m = (l + r) / 2;
if (x <= m) {
modify(p->lc, l, m, x, v);
} else {
modify(p->rc, m + 1, r, x, v);
}
pull(p);
}
ll query(SegTree *p, int l, int r, int x) {
if (p == null) {
return p->mn;
}
if (l == r) {
return p->mn;
}
push(p);
int m = (l + r) / 2;
if (x <= m) {
return query(p->lc, l, m, x);
} else {
return query(p->rc, m + 1, r, x);
}
}
SegTree *merge(SegTree *x, SegTree *y) {
if (x == null) {
return y;
} else if (y == null) {
return x;
} else {
x->mn = std::min(x->mn, y->mn);
push(x);
push(y);
x->lc = merge(x->lc, y->lc);
x->rc = merge(x->rc, y->rc);
return x;
}
}
constexpr int lim = 262144;
SegTree *solve(int s, ll v, int ban) {
SegTree *t = null;
modify(t, 0, lim, s, v);
std::string op;
while (std::cin >> op) {
if (op == "end") {
return t;
} else if (op == "set") {
int y, v;
std::cin >> y >> v;
ll mn = t->mn;
add(t, v);
if (y != ban) {
modify(t, 0, lim, y, mn);
}
} else {
int y;
std::cin >> y;
auto nt = solve(y, query(t, 0, lim, y), ban);
modify(t, 0, lim, y, inf);
t = merge(t, nt);
}
}
return t;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
null->mn = inf;
null->lc = null->rc = null;
int n, s;
std::cin >> n >> s;
std::cout << solve(0, 0, s)->mn << "\n";
return 0;
}
|
Homer has two friends Alice and Bob. Both of them are string fans.
One day, Alice and Bob decide to play a game on a string s = s_1 s_2 ... s_n of length n consisting of lowercase English letters. They move in turns alternatively and Alice makes the first move.
In a move, a player must choose an index i (1 ≤ i ≤ n) that has not been chosen before, and change s_i to any other lowercase English letter c that c ≠ s_i.
When all indices have been chosen, the game ends.
The goal of Alice is to make the final string lexicographically as small as possible, while the goal of Bob is to make the final string lexicographically as large as possible. Both of them are game experts, so they always play games optimally. Homer is not a game expert, so he wonders what the final string will be.
A string a is lexicographically smaller than a string b if and only if one of the following holds:
* a is a prefix of b, but a ≠ b;
* in the first position where a and b differ, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 1000) — the number of test cases. Description of the test cases follows.
The only line of each test case contains a single string s (1 ≤ |s| ≤ 50) consisting of lowercase English letters.
Output
For each test case, print the final string in a single line.
Example
Input
3
a
bbbb
az
Output
b
azaz
by
Note
In the first test case: Alice makes the first move and must change the only letter to a different one, so she changes it to 'b'.
In the second test case: Alice changes the first letter to 'a', then Bob changes the second letter to 'z', Alice changes the third letter to 'a' and then Bob changes the fourth letter to 'z'.
In the third test case: Alice changes the first letter to 'b', and then Bob changes the second letter to 'y'.
|
import java.util.Scanner;
public class Welcomejava {
public static void main(String[] args) {
// TODO code application
Scanner input = new Scanner(System.in);
int t ;
t = input.nextInt();
while (t-->0) {
String s ;
s = input.next();
char[] arr = new char[s.length()];
for (int i = 0; i < s.length() ; i++) {
arr[i] = s.charAt(i);
}
boolean flage = false;
for (int i = 0; i < arr.length; i++) {
if (flage == false)
{
if (arr[i] == 'a')
{
arr[i] = 'b';
flage = true;
}
else
{
arr[i] = 'a';
flage = true;
}
}
else
{
if (arr[i] == 'z')
{
arr[i] = 'y';
flage = false;
}
else
{
arr[i] = 'z';
flage = false;
}
}
}
for(char c : arr)
{
System.out.print(c);
}
System.out.println("");
}
}
}
|
You are given a string s, consisting of lowercase Latin letters. While there is at least one character in the string s that is repeated at least twice, you perform the following operation:
* you choose the index i (1 ≤ i ≤ |s|) such that the character at position i occurs at least two times in the string s, and delete the character at position i, that is, replace s with s_1 s_2 … s_{i-1} s_{i+1} s_{i+2} … s_n.
For example, if s="codeforces", then you can apply the following sequence of operations:
* i=6 ⇒ s="codefrces";
* i=1 ⇒ s="odefrces";
* i=7 ⇒ s="odefrcs";
Given a given string s, find the lexicographically maximum string that can be obtained after applying a certain sequence of operations after which all characters in the string become unique.
A string a of length n is lexicographically less than a string b of length m, if:
* there is an index i (1 ≤ i ≤ min(n, m)) such that the first i-1 characters of the strings a and b are the same, and the i-th character of the string a is less than i-th character of string b;
* or the first min(n, m) characters in the strings a and b are the same and n < m.
For example, the string a="aezakmi" is lexicographically less than the string b="aezus".
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case is characterized by a string s, consisting of lowercase Latin letters (1 ≤ |s| ≤ 2 ⋅ 10^5).
It is guaranteed that the sum of the lengths of the strings in all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output the lexicographically maximum string that can be obtained after applying a certain sequence of operations after which all characters in the string become unique.
Example
Input
6
codeforces
aezakmi
abacaba
convexhull
swflldjgpaxs
myneeocktxpqjpz
Output
odfrces
ezakmi
cba
convexhul
wfldjgpaxs
myneocktxqjpz
|
for _ in range(int(input())):
s = input(); stack = []; seen = set(); last_occurrence = {c: i for i, c in enumerate(s)}
for i, c in enumerate(s):
if c not in seen:
while stack and c > stack[-1] and i < last_occurrence[stack[-1]]: seen.discard(stack.pop())
seen.add(c); stack.append(c)
print(''.join(stack))
|
Today we will be playing a red and white colouring game (no, this is not the Russian Civil War; these are just the colours of the Canadian flag).
You are given an n × m grid of "R", "W", and "." characters. "R" is red, "W" is white and "." is blank. The neighbours of a cell are those that share an edge with it (those that only share a corner do not count).
Your job is to colour the blank cells red or white so that every red cell only has white neighbours (and no red ones) and every white cell only has red neighbours (and no white ones). You are not allowed to recolour already coloured cells.
Input
The first line contains t (1 ≤ t ≤ 100), the number of test cases.
In each test case, the first line will contain n (1 ≤ n ≤ 50) and m (1 ≤ m ≤ 50), the height and width of the grid respectively.
The next n lines will contain the grid. Each character of the grid is either 'R', 'W', or '.'.
Output
For each test case, output "YES" if there is a valid grid or "NO" if there is not.
If there is, output the grid on the next n lines. If there are multiple answers, print any.
In the output, the "YES"s and "NO"s are case-insensitive, meaning that outputs such as "yEs" and "nO" are valid. However, the grid is case-sensitive.
Example
Input
3
4 6
.R....
......
......
.W....
4 4
.R.W
....
....
....
5 1
R
W
R
W
R
Output
YES
WRWRWR
RWRWRW
WRWRWR
RWRWRW
NO
YES
R
W
R
W
R
Note
The answer for the first example case is given in the example output, and it can be proven that no grid exists that satisfies the requirements of the second example case. In the third example all cells are initially coloured, and the colouring is valid.
|
I=lambda: map(int, raw_input().split())
t = input()
for _ in xrange(t):
n, m = I()
fCol = None
ok = True
for j in xrange(n):
a = list(raw_input())
if not ok:
continue
for i in xrange(m):
k = (i+j)%2
if a[i] == 'W':
if k == 0:
if fCol == 'R':
if ok:
ok = False
break
else:
fCol = 'W'
if k == 1:
if fCol == 'W':
if ok:
ok = False
break
else:
fCol = 'R'
elif a[i] == 'R':
if k == 1:
if fCol == 'R':
if ok:
ok = False
break
else:
fCol = 'W'
if k == 0:
if fCol == 'W':
if ok:
ok = False
break
else:
fCol = 'R'
if not ok:
print('NO')
continue
line1 = []
line2 = []
for i in xrange(m):
if i%2 == 0:
line1.append('W')
line2.append('R')
else:
line2.append('W')
line1.append('R')
line1 = ''.join(line1)
line2 = ''.join(line2)
print('YES')
for j in xrange(n):
if fCol is None or fCol == 'W':
if j%2 == 0:
print(line1)
else:
print(line2)
else:
if j%2 == 0:
print(line2)
else:
print(line1)
|
Polycarpus analyzes a string called abracadabra. This string is constructed using the following algorithm:
* On the first step the string consists of a single character "a".
* On the k-th step Polycarpus concatenates two copies of the string obtained on the (k - 1)-th step, while inserting the k-th character of the alphabet between them. Polycarpus uses the alphabet that consists of lowercase Latin letters and digits (a total of 36 characters). The alphabet characters are numbered like this: the 1-st character is "a", the 2-nd — "b", ..., the 26-th — "z", the 27-th — "0", the 28-th — "1", ..., the 36-th — "9".
Let's have a closer look at the algorithm. On the second step Polycarpus will concatenate two strings "a" and insert the character "b" between them, resulting in "aba" string. The third step will transform it into "abacaba", and the fourth one - into "abacabadabacaba". Thus, the string constructed on the k-th step will consist of 2k - 1 characters.
Polycarpus wrote down the string he got after 30 steps of the given algorithm and chose two non-empty substrings of it. Your task is to find the length of the longest common substring of the two substrings selected by Polycarpus.
A substring s[i... j] (1 ≤ i ≤ j ≤ |s|) of string s = s1s2... s|s| is a string sisi + 1... sj. For example, substring s[2...4] of string s = "abacaba" equals "bac". The string is its own substring.
The longest common substring of two strings s and t is the longest string that is a substring of both s and t. For example, the longest common substring of "contest" and "systemtesting" is string "test". There can be several common substrings of maximum length.
Input
The input consists of a single line containing four integers l1, r1, l2, r2 (1 ≤ li ≤ ri ≤ 109, i = 1, 2). The numbers are separated by single spaces. li and ri give the indices of the first and the last characters of the i-th chosen substring, correspondingly (i = 1, 2). The characters of string abracadabra are numbered starting from 1.
Output
Print a single number — the length of the longest common substring of the given strings. If there are no common substrings, print 0.
Examples
Input
3 6 1 4
Output
2
Input
1 1 4 4
Output
0
Note
In the first sample the first substring is "acab", the second one is "abac". These two substrings have two longest common substrings "ac" and "ab", but we are only interested in their length — 2.
In the second sample the first substring is "a", the second one is "c". These two substrings don't have any common characters, so the length of their longest common substring is 0.
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d;
int f(int a, int b, int c, int d, int n) {
if (a > b || c > d) return 0;
if (a == c) return min(b, d) - a + 1;
if (a > c) swap(a, c), swap(b, d);
if (b >= d) return d - c + 1;
int x = 1 << n;
if (b < x && d < x) return f(a, b, c, d, n - 1);
if (a > x && c > x) return f(a - x, b - x, c - x, d - x, n);
if (c > x) return f(a, b, c - x, d - x, n);
return max(b - c + 1, max(f(a, b, c, x - 1, n), f(a, b, x + 1, d, n)));
}
int main() {
cin >> a >> b >> c >> d;
cout << f(a, b, c, d, 30);
}
|
Let's imagine that you're playing the following simple computer game. The screen displays n lined-up cubes. Each cube is painted one of m colors. You are allowed to delete not more than k cubes (that do not necessarily go one after another). After that, the remaining cubes join together (so that the gaps are closed) and the system counts the score. The number of points you score equals to the length of the maximum sequence of cubes of the same color that follow consecutively. Write a program that determines the maximum possible number of points you can score.
Remember, you may delete no more than k any cubes. It is allowed not to delete cubes at all.
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 2·105, 1 ≤ m ≤ 105, 0 ≤ k < n). The second line contains n integers from 1 to m — the numbers of cube colors. The numbers of colors are separated by single spaces.
Output
Print the maximum possible number of points you can score.
Examples
Input
10 3 2
1 2 1 1 3 2 1 1 2 2
Output
4
Input
10 2 2
1 2 1 2 1 1 2 1 1 2
Output
5
Input
3 1 2
1 1 1
Output
3
Note
In the first sample you should delete the fifth and the sixth cubes.
In the second sample you should delete the fourth and the seventh cubes.
In the third sample you shouldn't delete any cubes.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<int> v(n);
vector<int> c(m + 5, 0);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int l = 0, r = 0;
int res = 1;
c[v[0] - 1]++;
int maxC = 1;
int maxI = v[0] - 1;
while (r < n) {
if (c[v[r] - 1] > maxC) {
maxC = c[v[r] - 1];
maxI = v[r] - 1;
}
if (c[v[l] - 1] > maxC) {
maxC = c[v[l] - 1];
maxI = v[l] - 1;
}
if (r - l + 1 - maxC > k) {
if (v[l] - 1 == maxI) {
maxC--;
}
c[v[l] - 1]--;
l++;
} else if (r == n - 1) {
break;
} else {
r++;
c[v[r] - 1]++;
if (c[v[r] - 1] > maxC) {
maxC = c[v[r] - 1];
maxI = v[r] - 1;
}
if (r - l + 1 - maxC <= k) {
res = max(res, maxC);
}
}
}
cout << res;
return 0;
}
|
The Little Elephant very much loves sums on intervals.
This time he has a pair of integers l and r (l ≤ r). The Little Elephant has to find the number of such integers x (l ≤ x ≤ r), that the first digit of integer x equals the last one (in decimal notation). For example, such numbers as 101, 477474 or 9 will be included in the answer and 47, 253 or 1020 will not.
Help him and count the number of described numbers x for a given pair l and r.
Input
The single line contains a pair of integers l and r (1 ≤ l ≤ r ≤ 1018) — the boundaries of the interval.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
On a single line print a single integer — the answer to the problem.
Examples
Input
2 47
Output
12
Input
47 1024
Output
98
Note
In the first sample the answer includes integers 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44.
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author George Marcus
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
StreamInputReader in = new StreamInputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskC solver = new TaskC();
solver.solve(1, in, out);
out.close();
}
}
class TaskC {
public void solve(int testNumber, StreamInputReader in, PrintWriter out) {
long left = in.readLong();
long right = in.readLong();
long a = go(right);
long b = go(left - 1);
out.print(a - b);
}
private long go(long upper) {
String repr = Long.toString(upper);
int len = repr.length();
long ret = 0;
long ways = 1;
for(int i = 0; i < len - 1; i++) {
if(i == 0)
ret += 10;
else {
ret += 9 * ways;
}
if(i >= 1)
ways *= 10;
}
if(len == 1)
ret += repr.charAt(0) - '0' + 1;
else {
long samelen = (long) ((repr.charAt(0) - '1') * Math.pow(10, repr.length() - 2));
if(repr.charAt(0) > '0') {
if(repr.charAt(0) > repr.charAt(repr.length() - 1))
samelen += go2(repr, 1, true);
else
samelen += go2(repr, 1, false);
}
ret += samelen;
}
return ret;
}
private long go2(String repr, int pos, boolean smaller) {
long ret = 0;
int len = repr.length();
if(pos >= len - 1) {
if(smaller)
return 0;
return 1;
}
if(smaller) {
ret += Math.pow(10, len - pos - 2) * (repr.charAt(pos) - '0');
ret += go2(repr, pos + 1, true);
}
else {
ret += Math.pow(10, len - pos - 2) * (repr.charAt(pos) - '0');
ret += go2(repr, pos + 1, false);
}
return ret;
}
}
class StreamInputReader extends InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar, numChars;
public StreamInputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
}
abstract class InputReader {
public abstract int read();
public long readLong() {
return Long.parseLong(readString());
}
public String readString() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuffer res = new StringBuffer();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
private boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
|
Berland has n cities, some of them are connected by bidirectional roads. For each road we know whether it is asphalted or not.
The King of Berland Valera II wants to asphalt all roads of Berland, for that he gathered a group of workers. Every day Valera chooses exactly one city and orders the crew to asphalt all roads that come from the city. The valiant crew fulfilled the King's order in a day, then workers went home.
Unfortunately, not everything is as great as Valera II would like. The main part of the group were gastarbeiters — illegal immigrants who are enthusiastic but not exactly good at understanding orders in Berlandian. Therefore, having received orders to asphalt the roads coming from some of the city, the group asphalted all non-asphalted roads coming from the city, and vice versa, took the asphalt from the roads that had it.
Upon learning of this progress, Valera II was very upset, but since it was too late to change anything, he asked you to make a program that determines whether you can in some way asphalt Berlandian roads in at most n days. Help the king.
Input
The first line contains two space-separated integers n, m <image> — the number of cities and roads in Berland, correspondingly. Next m lines contain the descriptions of roads in Berland: the i-th line contains three space-separated integers ai, bi, ci (1 ≤ ai, bi ≤ n; ai ≠ bi; 0 ≤ ci ≤ 1). The first two integers (ai, bi) are indexes of the cities that are connected by the i-th road, the third integer (ci) equals 1, if the road was initially asphalted, and 0 otherwise.
Consider the cities in Berland indexed from 1 to n, and the roads indexed from 1 to m. It is guaranteed that between two Berlandian cities there is not more than one road.
Output
In the first line print a single integer x (0 ≤ x ≤ n) — the number of days needed to asphalt all roads. In the second line print x space-separated integers — the indexes of the cities to send the workers to. Print the cities in the order, in which Valera send the workers to asphalt roads. If there are multiple solutions, print any of them.
If there's no way to asphalt all roads, print "Impossible" (without the quotes).
Examples
Input
4 4
1 2 1
2 4 0
4 3 1
3 2 0
Output
4
3 2 1 3
Input
3 3
1 2 0
2 3 0
3 1 0
Output
Impossible
|
import java.io.*;
import java.util.*;
public class AsphaltedRoads2Sat {
public static void main(String[] args) throws IOException {
BufferedReader rd = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(System.out);
StringTokenizer st = new StringTokenizer(rd.readLine());
N = Integer.parseInt(st.nextToken());
M = Integer.parseInt(st.nextToken());
G = new ArrayList[(N<<1)];
G1 = new ArrayList[(N<<1)];
for(int i=0; i<G.length; i++){
G[i] = new ArrayList<Integer>();
G1[i] = new ArrayList<Integer>();
}
comp = new int[(N<<1)];
for(int i=0; i<M; i++){
st = new StringTokenizer(rd.readLine());
int a = Integer.parseInt(st.nextToken())-1, b = Integer.parseInt(st.nextToken())-1, c = Integer.parseInt(st.nextToken());
if(c==0){
addClause(a, b, 1, 1);
addClause(a, b, 0, 0);
}
else{
addClause(a, b, 1, 0);
addClause(a, b, 0, 1);
}
}
boolean[] used = new boolean[(N<<1)];
for(int i=0; i<(N<<1); i++)
if(!used[i])
dfs1(i, used);
used = new boolean[(N<<1)];
for(int i=0, c=0; i<(N<<1); i++){
int v = order.get((N<<1)-1-i);
if(!used[v]) dfs2(v, used, c);
c++;
}
boolean[] ans = new boolean[N];
for(int i=0; i<N; i++){
int vert = (i<<1);
if(comp[vert] == comp[vert^1]){
pw.println("Impossible");
pw.flush();
return;
}
ans[i] = comp[vert]>comp[vert^1];
}
int num = 0;
for(int i=0; i<N; i++) if(ans[i]) num++;
pw.println(num);
for(int i=0; i<N; i++) if(ans[i]) pw.print((i+1)+" ");
pw.println();
pw.flush();
}
static void dfs1(int v, boolean[] used){
used[v] = true;
for(int i=0; i<G[v].size(); i++){
int to = G[v].get(i);
if(!used[to])
dfs1(to, used);
}
order.add(v);
}
static void dfs2(int v, boolean[] used, int comp_num){
used[v] = true;
comp[v] = comp_num;
for(int i=0; i<G1[v].size(); i++){
int to = G1[v].get(i);
if(!used[to])
dfs2(to, used, comp_num);
}
}
static void addClause(int a, int b, int pos1, int pos2){
int f = (a<<1), s = (b<<1);
if(pos1>0) f ^= 1;
if(pos2>0) s ^= 1;
G[f^1].add(s);
G1[s].add(f^1);
G[s^1].add(f);
G1[f].add(s^1);
}
static int N, M;
static ArrayList<Integer>[] G, G1;
static ArrayList<Integer> order = new ArrayList<Integer>();
static int[] comp;
}
|
Little Petya likes points a lot. Recently his mom has presented him n points lying on the line OX. Now Petya is wondering in how many ways he can choose three distinct points so that the distance between the two farthest of them doesn't exceed d.
Note that the order of the points inside the group of three chosen points doesn't matter.
Input
The first line contains two integers: n and d (1 ≤ n ≤ 105; 1 ≤ d ≤ 109). The next line contains n integers x1, x2, ..., xn, their absolute value doesn't exceed 109 — the x-coordinates of the points that Petya has got.
It is guaranteed that the coordinates of the points in the input strictly increase.
Output
Print a single integer — the number of groups of three points, where the distance between two farthest points doesn't exceed d.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
4 3
1 2 3 4
Output
4
Input
4 2
-3 -2 -1 0
Output
2
Input
5 19
1 10 20 30 50
Output
1
Note
In the first sample any group of three points meets our conditions.
In the seconds sample only 2 groups of three points meet our conditions: {-3, -2, -1} and {-2, -1, 0}.
In the third sample only one group does: {1, 10, 20}.
|
#include <bits/stdc++.h>
using namespace std;
long long a[100005];
int main() {
long long n, d;
cin >> n >> d;
for (int i = 1; i <= n; i++) cin >> a[i];
long long l = 1, r = 2;
long long ans = 0;
while (l <= n || r <= n) {
if (l >= r) {
r = l + 1;
continue;
}
if (r > n) {
ans += max(0ll, (r - l - 1) * (r - l - 2) / 2), r--, l++;
continue;
}
if (a[r] - a[l] <= d)
r++;
else {
ans += max(0ll, (r - l - 1) * (r - l - 2) / 2);
r--;
l++;
}
}
cout << ans << endl;
}
|
Many of you must be familiar with the Google Code Jam round rules. Let us remind you of some key moments that are crucial to solving this problem. During the round, the participants are suggested to solve several problems, each divided into two subproblems: an easy one with small limits (Small input), and a hard one with large limits (Large input). You can submit a solution for Large input only after you've solved the Small input for this problem. There are no other restrictions on the order of solving inputs. In particular, the participant can first solve the Small input, then switch to another problem, and then return to the Large input. Solving each input gives the participant some number of points (usually different for each problem). This takes into account only complete solutions that work correctly on all tests of the input. The participant gets the test result of a Small input right after he submits it, but the test result of a Large input are out only after the round's over. In the final results table the participants are sorted by non-increasing of received points. If the points are equal, the participants are sorted by ascending of time penalty. By the Google Code Jam rules the time penalty is the time when the last correct solution was submitted.
Vasya decided to check out a new tactics on another round. As soon as the round begins, the boy quickly read all the problems and accurately evaluated the time it takes to solve them. Specifically, for each one of the n problems Vasya knows five values:
* Solving the Small input of the i-th problem gives to the participant scoreSmalli points, and solving the Large input gives scoreLargei more points. That is, the maximum number of points you can get for the i-th problem equals scoreSmalli + scoreLargei.
* Writing the solution for the Small input of the i-th problem takes exactly timeSmalli minutes for Vasya. Improving this code and turning it into the solution of the Large input takes another timeLargei minutes.
* Vasya's had much practice, so he solves all Small inputs from the first attempt. But it's not so easy with the Large input: there is the probFaili probability that the solution to the Large input will turn out to be wrong at the end of the round. Please keep in mind that these solutions do not affect the participants' points and the time penalty.
A round lasts for t minutes. The time for reading problems and submitting solutions can be considered to equal zero. Vasya is allowed to submit a solution exactly at the moment when the round ends.
Vasya wants to choose a set of inputs and the order of their solution so as to make the expectation of the total received points maximum possible. If there are multiple ways to do this, he needs to minimize the expectation of the time penalty. Help Vasya to cope with this problem.
Input
The first line contains two integers n and t (1 ≤ n ≤ 1000, 1 ≤ t ≤ 1560). Then follow n lines, each containing 5 numbers: scoreSmalli, scoreLargei, timeSmalli, timeLargei, probFaili (1 ≤ scoreSmalli, scoreLargei ≤ 109, 1 ≤ timeSmalli, timeLargei ≤ 1560, 0 ≤ probFaili ≤ 1).
probFaili are real numbers, given with at most 6 digits after the decimal point. All other numbers in the input are integers.
Output
Print two real numbers — the maximum expectation of the total points and the corresponding minimum possible time penalty expectation. The answer will be considered correct if the absolute or relative error doesn't exceed 10 - 9.
Examples
Input
3 40
10 20 15 4 0.5
4 100 21 1 0.99
1 4 1 1 0.25
Output
24.0 18.875
Input
1 1
100000000 200000000 1 1 0
Output
100000000 1
Note
In the first sample one of the optimal orders of solving problems is:
1. The Small input of the third problem.
2. The Small input of the first problem.
3. The Large input of the third problem.
4. The Large input of the first problem.
Note that if you solve the Small input of the second problem instead of two inputs of the third one, then total score expectation will be the same but the time penalty expectation will be worse (38).
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1605;
const long double eps = 1e-10;
struct data {
int a, b, s, t;
long double p;
bool operator<(const data& d2) const {
return t * p * (1 - d2.p) < d2.t * d2.p * (1 - p);
}
} a[MAXN];
int N, T;
long double f[MAXN][MAXN], g[MAXN][MAXN], ans = -1e100, tim = 1e100;
int main() {
cin >> N >> T;
for (int i = 1; i <= N; ++i)
cin >> a[i].a >> a[i].b >> a[i].s >> a[i].t >> a[i].p;
sort(a + 1, a + N + 1);
for (int i = 1; i <= T; ++i) f[0][i] = -1e100;
for (int i = 1; i <= N; ++i) {
for (int j = 0; j <= T; ++j) f[i][j] = f[i - 1][j], g[i][j] = g[i - 1][j];
for (int j = a[i].s; j <= T; ++j) {
if (f[i - 1][j - a[i].s] + a[i].a - f[i][j] > eps) {
f[i][j] = f[i - 1][j - a[i].s] + a[i].a;
g[i][j] = g[i - 1][j - a[i].s];
} else if (abs(f[i - 1][j - a[i].s] + a[i].a - f[i][j]) < eps) {
g[i][j] = max(g[i][j], g[i - 1][j - a[i].s]);
}
}
for (int j = a[i].s + a[i].t; j <= T; ++j) {
if (f[i - 1][j - a[i].s - a[i].t] + a[i].a + a[i].b * (1 - a[i].p) -
f[i][j] >
eps) {
f[i][j] =
f[i - 1][j - a[i].s - a[i].t] + a[i].a + a[i].b * (1 - a[i].p);
g[i][j] = (g[i - 1][j - a[i].s - a[i].t] + a[i].t) * a[i].p;
} else if (abs(f[i - 1][j - a[i].s - a[i].t] + a[i].a +
a[i].b * (1 - a[i].p) - f[i][j]) < eps) {
g[i][j] =
max(g[i][j], (g[i - 1][j - a[i].s - a[i].t] + a[i].t) * a[i].p);
}
}
}
for (int i = 0; i <= T; ++i) {
if (f[N][i] - ans > eps) {
ans = f[N][i];
tim = i - g[N][i];
} else if (abs(f[N][i] - ans) < eps) {
tim = min(tim, i - g[N][i]);
}
}
cout << fixed << setprecision(10) << ans << ' ' << tim;
return 0;
}
|
The winner of the card game popular in Berland "Berlogging" is determined according to the following rules. If at the end of the game there is only one player with the maximum number of points, he is the winner. The situation becomes more difficult if the number of such players is more than one. During each round a player gains or loses a particular number of points. In the course of the game the number of points is registered in the line "name score", where name is a player's name, and score is the number of points gained in this round, which is an integer number. If score is negative, this means that the player has lost in the round. So, if two or more players have the maximum number of points (say, it equals to m) at the end of the game, than wins the one of them who scored at least m points first. Initially each player has 0 points. It's guaranteed that at the end of the game at least one player has a positive number of points.
Input
The first line contains an integer number n (1 ≤ n ≤ 1000), n is the number of rounds played. Then follow n lines, containing the information about the rounds in "name score" format in chronological order, where name is a string of lower-case Latin letters with the length from 1 to 32, and score is an integer number between -1000 and 1000, inclusive.
Output
Print the name of the winner.
Examples
Input
3
mike 3
andrew 5
mike 2
Output
andrew
Input
3
andrew 3
andrew 2
mike 5
Output
andrew
|
n = int(input())
d = {}
l = []
for _ in range(n):
name, score = input().split()
score = int(score)
l.append((name,score))
d[name] = d.get(name, 0) + score
m = max([x for x in d.values()])
ties = [x for x,y in d.items() if y == m]
# print(ties)
if len(ties) == 1:
print(ties[0])
exit()
else:
d.clear()
for row in l:
name,score = row
d[name] = d.get(name,0) + score
# print(name, d[name])
if name in ties and d[name] >= m:
print(name)
break
|
You are given n rectangles. The corners of rectangles have integer coordinates and their edges are parallel to the Ox and Oy axes. The rectangles may touch each other, but they do not overlap (that is, there are no points that belong to the interior of more than one rectangle).
Your task is to determine if the rectangles form a square. In other words, determine if the set of points inside or on the border of at least one rectangle is precisely equal to the set of points inside or on the border of some square.
Input
The first line contains a single integer n (1 ≤ n ≤ 5). Next n lines contain four integers each, describing a single rectangle: x1, y1, x2, y2 (0 ≤ x1 < x2 ≤ 31400, 0 ≤ y1 < y2 ≤ 31400) — x1 and x2 are x-coordinates of the left and right edges of the rectangle, and y1 and y2 are y-coordinates of the bottom and top edges of the rectangle.
No two rectangles overlap (that is, there are no points that belong to the interior of more than one rectangle).
Output
In a single line print "YES", if the given rectangles form a square, or "NO" otherwise.
Examples
Input
5
0 0 2 3
0 3 3 5
2 0 5 2
3 2 5 5
2 2 3 3
Output
YES
Input
4
0 0 2 3
0 3 3 5
2 0 5 2
3 2 5 5
Output
NO
|
#include <bits/stdc++.h>
using namespace std;
struct coord {
int x1, x2, y1, y2;
};
int main() {
int n;
cin >> n;
coord rect[n];
int mnX = 31401, mnY = 31401, mxX = 0, mxY = 0;
long long area = 0;
for (int i = 0; i < n; i++) {
cin >> rect[i].x1 >> rect[i].y1 >> rect[i].x2 >> rect[i].y2;
area += 1LL * abs(rect[i].x1 - rect[i].x2) * abs(rect[i].y1 - rect[i].y2);
mnX = min(mnX, rect[i].x1);
mnY = min(mnY, rect[i].y1);
mxX = max(mxX, rect[i].x2);
mxY = max(mxY, rect[i].y2);
}
int x = mxX - mnX, y = mxY - mnY;
if (x == y && area == (1LL * x * y)) {
cout << "YES\n";
} else {
cout << "NO\n";
}
return 0;
}
|
You are given a rooted tree with n vertices. In each leaf vertex there's a single integer — the number of apples in this vertex.
The weight of a subtree is the sum of all numbers in this subtree leaves. For instance, the weight of a subtree that corresponds to some leaf is the number written in the leaf.
A tree is balanced if for every vertex v of the tree all its subtrees, corresponding to the children of vertex v, are of equal weight.
Count the minimum number of apples that you need to remove from the tree (specifically, from some of its leaves) in order to make the tree balanced. Notice that you can always achieve the goal by just removing all apples.
Input
The first line contains integer n (2 ≤ n ≤ 105), showing the number of vertices in the tree. The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 108), ai is the number of apples in the vertex number i. The number of apples in non-leaf vertices is guaranteed to be zero.
Then follow n - 1 lines, describing the tree edges. Each line contains a pair of integers xi, yi (1 ≤ xi, yi ≤ n, xi ≠ yi) — the vertices connected by an edge.
The vertices are indexed from 1 to n. Vertex 1 is the root.
Output
Print a single integer — the minimum number of apples to remove in order to make the tree balanced.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the sin, cout streams cin, cout or the %I64d specifier.
Examples
Input
6
0 0 12 13 5 6
1 2
1 3
1 4
2 5
2 6
Output
6
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const long long inf = 1ll << 60;
int n, tot;
int to[N << 1], nex[N << 1], head[N];
long long ans = 0, p[N], sum[N];
bool flag;
void SE(int u, int v) {
to[++tot] = v;
nex[tot] = head[u];
head[u] = tot;
return;
}
long long _GCD(long long x, long long y) {
long long r = x % y;
while (r) x = y, y = r, r = x % y;
return y;
}
void DFS(int x, int fa) {
long long mi = inf, cnt = 0;
for (int i = head[x]; i; i = nex[i]) {
if (to[i] == fa) continue;
DFS(to[i], x);
if (flag) return;
if (p[to[i]] < mi) mi = p[to[i]];
cnt++;
}
if (cnt == 0) {
sum[x] = 1;
return;
}
long long lcm = 1ll;
for (int i = head[x]; i; i = nex[i]) {
if (to[i] == fa) continue;
if ((double)lcm / _GCD(lcm, sum[to[i]]) * sum[to[i]] > (double)mi) {
flag = 1;
return;
}
lcm = lcm / _GCD(lcm, sum[to[i]]) * sum[to[i]];
}
p[x] = mi / lcm * lcm * cnt;
sum[x] = lcm * cnt;
return;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &p[i]);
ans += p[i];
}
for (int u, v, i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
SE(u, v), SE(v, u);
}
DFS(1, 0);
if (!flag) ans -= p[1];
printf("%I64d\n", ans);
return 0;
}
|
Polycarpus loves hamburgers very much. He especially adores the hamburgers he makes with his own hands. Polycarpus thinks that there are only three decent ingredients to make hamburgers from: a bread, sausage and cheese. He writes down the recipe of his favorite "Le Hamburger de Polycarpus" as a string of letters 'B' (bread), 'S' (sausage) и 'C' (cheese). The ingredients in the recipe go from bottom to top, for example, recipe "ВSCBS" represents the hamburger where the ingredients go from bottom to top as bread, sausage, cheese, bread and sausage again.
Polycarpus has nb pieces of bread, ns pieces of sausage and nc pieces of cheese in the kitchen. Besides, the shop nearby has all three ingredients, the prices are pb rubles for a piece of bread, ps for a piece of sausage and pc for a piece of cheese.
Polycarpus has r rubles and he is ready to shop on them. What maximum number of hamburgers can he cook? You can assume that Polycarpus cannot break or slice any of the pieces of bread, sausage or cheese. Besides, the shop has an unlimited number of pieces of each ingredient.
Input
The first line of the input contains a non-empty string that describes the recipe of "Le Hamburger de Polycarpus". The length of the string doesn't exceed 100, the string contains only letters 'B' (uppercase English B), 'S' (uppercase English S) and 'C' (uppercase English C).
The second line contains three integers nb, ns, nc (1 ≤ nb, ns, nc ≤ 100) — the number of the pieces of bread, sausage and cheese on Polycarpus' kitchen. The third line contains three integers pb, ps, pc (1 ≤ pb, ps, pc ≤ 100) — the price of one piece of bread, sausage and cheese in the shop. Finally, the fourth line contains integer r (1 ≤ r ≤ 1012) — the number of rubles Polycarpus has.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print the maximum number of hamburgers Polycarpus can make. If he can't make any hamburger, print 0.
Examples
Input
BBBSSC
6 4 1
1 2 3
4
Output
2
Input
BBC
1 10 1
1 10 1
21
Output
7
Input
BSC
1 1 1
1 1 3
1000000000000
Output
200000000001
|
st = input()
B = st.count('B')
S = st.count('S')
C = st.count('C')
b,s,c=map(int,input().split())
bp, sp, cp = map(int,input().split())
r=int(input())
lm=0; rm=int(1e15)+1
while rm-lm>1:
m=(rm+lm)//2
# print(m)
bb=max(m*B-b,0)
ss=max(m*S-s,0)
cc=max(m*C-c, 0)
#print(bp*bb+ss*sp+cc*cp)
if bp*bb+ss*sp+cc*cp <= r:
lm=m
else:
rm=m
print(lm)
|
SmallR likes a game called "Deleting Substrings". In the game you are given a sequence of integers w, you can modify the sequence and get points. The only type of modification you can perform is (unexpected, right?) deleting substrings. More formally, you can choose several contiguous elements of w and delete them from the sequence. Let's denote the sequence of chosen elements as wl, wl + 1, ..., wr. They must meet the conditions:
* the equality |wi - wi + 1| = 1 must hold for all i (l ≤ i < r);
* the inequality 2·wi - wi + 1 - wi - 1 ≥ 0 must hold for all i (l < i < r).
After deleting the chosen substring of w, you gain vr - l + 1 points. You can perform the described operation again and again while proper substrings exist. Also you can end the game at any time. Your task is to calculate the maximum total score you can get in the game.
Input
The first line contains a single integer n (1 ≤ n ≤ 400) — the initial length of w. The second line contains n integers v1, v2, ..., vn (0 ≤ |vi| ≤ 2000) — the costs of operations. The next line contains n integers w1, w2, ..., wn (1 ≤ wi ≤ 109) — the initial w.
Output
Print a single integer — the maximum total score you can get.
Examples
Input
3
0 0 3
1 2 1
Output
3
Input
6
1 4 5 6 7 1000
2 1 1 2 2 3
Output
12
|
#include <bits/stdc++.h>
const int N = 405, inf = 1000000007;
using namespace std;
int g[N], f[N][N][2], n, a[N], v[N];
void dp() {
for (int i = 1; i <= n; ++i) {
f[i][i][0] = 0;
f[i][i][1] = v[1];
}
for (int L = 2; L <= n; ++L)
for (int l = 1; l <= n - L + 1; ++l) {
int r = l + L - 1;
f[l][r][0] = -inf;
if (a[l] != a[r]) {
int st = (a[l] < a[r] ? 1 : -1);
for (int k = l + 1; k <= r; ++k)
if (a[k] == a[l] + st)
f[l][r][0] = max(f[l][r][0], f[l + 1][k - 1][1] + f[k][r][0]);
}
f[l][r][1] = -inf;
for (int k = l; k <= r - 1; ++k)
f[l][r][1] = max(f[l][r][1], f[l][k][1] + f[k + 1][r][1]);
for (int k = l; k <= r; ++k)
if (a[l] <= a[k] && a[r] <= a[k] && a[k] - a[l] + a[k] - a[r] + 1 <= n)
f[l][r][1] = max(f[l][r][1], f[l][k][0] + f[k][r][0] +
v[a[k] - a[l] + a[k] - a[r] + 1]);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &v[i]);
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
dp();
g[0] = 0;
for (int i = 1; i <= n; ++i) {
g[i] = g[i - 1];
for (int j = 0; j <= i - 1; ++j) g[i] = max(g[i], g[j] + f[j + 1][i][1]);
}
printf("%d\n", g[n]);
return 0;
}
|
A TV show called "Guess a number!" is gathering popularity. The whole Berland, the old and the young, are watching the show.
The rules are simple. The host thinks of an integer y and the participants guess it by asking questions to the host. There are four types of acceptable questions:
* Is it true that y is strictly larger than number x?
* Is it true that y is strictly smaller than number x?
* Is it true that y is larger than or equal to number x?
* Is it true that y is smaller than or equal to number x?
On each question the host answers truthfully, "yes" or "no".
Given the sequence of questions and answers, find any integer value of y that meets the criteria of all answers. If there isn't such value, print "Impossible".
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10000) — the number of questions (and answers). Next n lines each contain one question and one answer to it. The format of each line is like that: "sign x answer", where the sign is:
* ">" (for the first type queries),
* "<" (for the second type queries),
* ">=" (for the third type queries),
* "<=" (for the fourth type queries).
All values of x are integer and meet the inequation - 109 ≤ x ≤ 109. The answer is an English letter "Y" (for "yes") or "N" (for "no").
Consequtive elements in lines are separated by a single space.
Output
Print any of such integers y, that the answers to all the queries are correct. The printed number y must meet the inequation - 2·109 ≤ y ≤ 2·109. If there are many answers, print any of them. If such value doesn't exist, print word "Impossible" (without the quotes).
Examples
Input
4
>= 1 Y
< 3 N
<= -3 N
> 55 N
Output
17
Input
2
> 100 Y
< -100 Y
Output
Impossible
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int a;
cin >> a;
int l = -2e9;
int r = 2e9;
while (a--) {
string c;
int n;
char s;
cin >> c >> n >> s;
if (c == ">") {
if (s == 'Y')
l = max(l, n + 1);
else
r = min(r, n);
} else if (c == "<") {
if (s == 'Y')
r = min(r, n - 1);
else
l = max(l, n);
} else if (c == "<=") {
if (s == 'Y')
r = min(r, n);
else
l = max(l, n + 1);
} else {
if (s == 'Y')
l = max(l, n);
else
r = min(r, n - 1);
}
}
if (l <= r)
cout << l;
else
cout << "Impossible";
}
|
When Adam gets a rooted tree (connected non-directed graph without cycles), he immediately starts coloring it. More formally, he assigns a color to each edge of the tree so that it meets the following two conditions:
* There is no vertex that has more than two incident edges painted the same color.
* For any two vertexes that have incident edges painted the same color (say, c), the path between them consists of the edges of the color c.
Not all tree paintings are equally good for Adam. Let's consider the path from some vertex to the root. Let's call the number of distinct colors on this path the cost of the vertex. The cost of the tree's coloring will be the maximum cost among all the vertexes. Help Adam determine the minimum possible cost of painting the tree.
Initially, Adam's tree consists of a single vertex that has number one and is the root. In one move Adam adds a new vertex to the already existing one, the new vertex gets the number equal to the minimum positive available integer. After each operation you need to calculate the minimum cost of coloring the resulting tree.
Input
The first line contains integer n (1 ≤ n ≤ 106) — the number of times a new vertex is added. The second line contains n numbers pi (1 ≤ pi ≤ i) — the numbers of the vertexes to which we add another vertex.
Output
Print n integers — the minimum costs of the tree painting after each addition.
Examples
Input
11
1 1 1 3 4 4 7 3 7 6 6
Output
1 1 1 1 1 2 2 2 2 2 3
Note
The figure below shows one of the possible variants to paint a tree from the sample at the last moment. The cost of the vertexes with numbers 11 and 12 equals 3.
<image>
|
#include <bits/stdc++.h>
int _max(int x, int y) { return x > y ? x : y; }
int n;
int f[1002000], dp[1002000], ma[1002000], sec[1002000];
bool Update(int x) {
int o = dp[x], pos = 0;
if (ma[f[x]] == dp[x]) pos = 1;
dp[x] = _max(ma[x], sec[x] + 1);
if (pos == 0) {
if (ma[f[x]] <= dp[x])
sec[f[x]] = ma[f[x]], ma[f[x]] = dp[x];
else if (sec[f[x]] <= dp[x])
sec[f[x]] = dp[x];
} else
ma[f[x]] = dp[x];
if (dp[x] == o)
return 0;
else
return 1;
}
void gi(int &x) {
char ch = getchar();
x = 0;
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - 48, ch = getchar();
}
void pi(int x) {
if (x > 9) pi(x / 10);
putchar(x % 10 + 48);
}
int main() {
gi(n);
n++;
for (int i = 2; i <= n; i++) {
gi(f[i]);
dp[i] = 1;
if (dp[i] > ma[f[i]])
sec[f[i]] = ma[f[i]], ma[f[i]] = dp[i];
else if (dp[i] > sec[f[i]])
sec[f[i]] = dp[i];
Update(i);
for (int j = f[i]; j; j = f[j])
if (!Update(j)) break;
pi(ma[1]);
putchar(' ');
}
return 0;
}
|
You are given a weighted undirected graph on n vertices and m edges. Find the shortest path from vertex s to vertex t or else state that such path doesn't exist.
Input
The first line of the input contains two space-separated integers — n and m (1 ≤ n ≤ 105; 0 ≤ m ≤ 105).
Next m lines contain the description of the graph edges. The i-th line contains three space-separated integers — ui, vi, xi (1 ≤ ui, vi ≤ n; 0 ≤ xi ≤ 105). That means that vertices with numbers ui and vi are connected by edge of length 2xi (2 to the power of xi).
The last line contains two space-separated integers — the numbers of vertices s and t.
The vertices are numbered from 1 to n. The graph contains no multiple edges and self-loops.
Output
In the first line print the remainder after dividing the length of the shortest path by 1000000007 (109 + 7) if the path exists, and -1 if the path doesn't exist.
If the path exists print in the second line integer k — the number of vertices in the shortest path from vertex s to vertex t; in the third line print k space-separated integers — the vertices of the shortest path in the visiting order. The first vertex should be vertex s, the last vertex should be vertex t. If there are multiple shortest paths, print any of them.
Examples
Input
4 4
1 4 2
1 2 0
2 3 0
3 4 0
1 4
Output
3
4
1 2 3 4
Input
4 3
1 2 4
2 3 5
3 4 6
1 4
Output
112
4
1 2 3 4
Input
4 2
1 2 0
3 4 1
1 4
Output
-1
Note
A path from vertex s to vertex t is a sequence v0, ..., vk, such that v0 = s, vk = t, and for any i from 0 to k - 1 vertices vi and vi + 1 are connected by an edge.
The length of the path is the sum of weights of edges between vi and vi + 1 for all i from 0 to k - 1.
The shortest path from s to t is the path which length is minimum among all possible paths from s to t.
|
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
template <class T>
inline bool cmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
inline int read() {
char ch;
bool flag = 0;
int res;
while (!isdigit(
ch = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++)))
(ch == '-') && (flag = true);
for (res = ch - '0'; isdigit(
ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin),
p1 == p2)
? EOF
: *p1++));
res = res * 10 + ch - '0')
;
(flag) && (res = -res);
return res;
}
const int N = 1e5 + 5, mod = 1e9 + 7;
int n, m, head[N], Next[N << 1], ver[N << 1], edge[N << 1];
int S, T, lim, b[N << 1], rt[N], Pre[N], tot, cnt;
int L[N * 120], R[N * 120], sum[N * 120];
inline void add(int u, int v, int e) {
ver[++tot] = v, Next[tot] = head[u], head[u] = tot, edge[tot] = e;
ver[++tot] = u, Next[tot] = head[v], head[v] = tot, edge[tot] = e;
}
bool cmp(int u, int v, int l, int r) {
if (l == r) return sum[u] > sum[v];
int mid = (l + r) >> 1;
if (sum[R[u]] == sum[R[v]])
return cmp(L[u], L[v], l, mid);
else
return cmp(R[u], R[v], mid + 1, r);
}
int update(int last, int &now, int l, int r, int k) {
L[now = ++cnt] = L[last], R[now] = R[last];
if (l == r) {
sum[now] = sum[last] ^ 1;
return sum[last];
}
int mid = (l + r) >> 1, res;
if (k > mid)
res = update(R[last], R[now], mid + 1, r, k);
else {
res = update(L[last], L[now], l, mid, k);
if (res) res = update(R[last], R[now], mid + 1, r, k);
}
sum[now] = (1ll * sum[R[now]] * b[mid - l + 1] + sum[L[now]]) % mod;
return res;
}
struct node {
int x, rt;
bool operator<(const node &b) const { return cmp(rt, b.rt, 0, lim); }
};
priority_queue<node> q;
void dfs(int u, int dep) {
if (u == S) {
printf("%d\n%d ", dep, u);
return;
}
dfs(Pre[u], dep + 1);
printf("%d ", u);
}
void print(int u) {
printf("%d\n", sum[rt[u]]);
dfs(u, 1);
exit(0);
}
int main() {
n = read(), m = read();
for (int i = 1; i <= m; ++i) {
int u, v, e;
u = read(), v = read(), e = read();
add(u, v, e);
cmax(lim, e);
}
lim += 18;
b[0] = 1;
for (int i = 1; i <= lim; ++i) b[i] = (1ll * b[i - 1] << 1) % mod;
S = read(), T = read();
q.push((node){S, rt[S]});
while (!q.empty()) {
node u = q.top();
q.pop();
if (u.rt != rt[u.x]) continue;
if (u.x == T) print(T);
for (int i = head[u.x]; i; i = Next[i]) {
int v = ver[i], RT;
update(u.rt, RT, 0, lim, edge[i]);
if (!rt[v] || cmp(rt[v], RT, 0, lim))
rt[v] = RT, q.push((node){v, rt[v]}), Pre[v] = u.x;
}
}
puts("-1");
return 0;
}
|
Alexandra has a paper strip with n numbers on it. Let's call them ai from left to right.
Now Alexandra wants to split it into some pieces (possibly 1). For each piece of strip, it must satisfy:
* Each piece should contain at least l numbers.
* The difference between the maximal and the minimal number on the piece should be at most s.
Please help Alexandra to find the minimal number of pieces meeting the condition above.
Input
The first line contains three space-separated integers n, s, l (1 ≤ n ≤ 105, 0 ≤ s ≤ 109, 1 ≤ l ≤ 105).
The second line contains n integers ai separated by spaces ( - 109 ≤ ai ≤ 109).
Output
Output the minimal number of strip pieces.
If there are no ways to split the strip, output -1.
Examples
Input
7 2 2
1 3 1 2 4 1 2
Output
3
Input
7 2 2
1 100 1 100 1 100 1
Output
-1
Note
For the first sample, we can split the strip into 3 pieces: [1, 3, 1], [2, 4], [1, 2].
For the second sample, we can't let 1 and 100 be on the same piece, so no solution exists.
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int INF = 1e9 + 7;
int n, s, l, dp[maxn], a[maxn];
multiset<int> st, v;
int main() {
cin >> n >> s >> l;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1, j = 1; i <= n; i++) {
st.insert(a[i]);
while (*st.rbegin() - *st.begin() > s) {
st.erase(st.find(a[j]));
if (i - j >= l) {
v.erase(v.find(dp[j - 1]));
}
j++;
}
if (i - j + 1 >= l) v.insert(dp[i - l]);
if (v.begin() == v.end())
dp[i] = INF;
else
dp[i] = *v.begin() + 1;
}
if (dp[n] >= INF)
cout << -1 << endl;
else
cout << dp[n] << endl;
return 0;
}
|
Fox Ciel is participating in a party in Prime Kingdom. There are n foxes there (include Fox Ciel). The i-th fox is ai years old.
They will have dinner around some round tables. You want to distribute foxes such that:
1. Each fox is sitting at some table.
2. Each table has at least 3 foxes sitting around it.
3. The sum of ages of any two adjacent foxes around each table should be a prime number.
If k foxes f1, f2, ..., fk are sitting around table in clockwise order, then for 1 ≤ i ≤ k - 1: fi and fi + 1 are adjacent, and f1 and fk are also adjacent.
If it is possible to distribute the foxes in the desired manner, find out a way to do that.
Input
The first line contains single integer n (3 ≤ n ≤ 200): the number of foxes in this party.
The second line contains n integers ai (2 ≤ ai ≤ 104).
Output
If it is impossible to do this, output "Impossible".
Otherwise, in the first line output an integer m (<image>): the number of tables.
Then output m lines, each line should start with an integer k -=– the number of foxes around that table, and then k numbers — indices of fox sitting around that table in clockwise order.
If there are several possible arrangements, output any of them.
Examples
Input
4
3 4 8 9
Output
1
4 1 2 4 3
Input
5
2 2 2 2 2
Output
Impossible
Input
12
2 3 4 5 6 7 8 9 10 11 12 13
Output
1
12 1 2 3 6 5 12 9 8 7 10 11 4
Input
24
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Output
3
6 1 2 3 6 5 4
10 7 8 9 12 15 14 13 16 11 10
8 17 18 23 22 19 20 21 24
Note
In example 1, they can sit around one table, their ages are: 3-8-9-4, adjacent sums are: 11, 17, 13 and 7, all those integers are primes.
In example 2, it is not possible: the sum of 2+2 = 4 is not a prime number.
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const long long INF = (long long)5e18;
const int MOD = 998244353;
int _abs(int x) { return x < 0 ? -x : x; }
int add(int x, int y) {
x += y;
return x >= MOD ? x - MOD : x;
}
int sub(int x, int y) {
x -= y;
return x < 0 ? x + MOD : x;
}
void Add(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
void Sub(int &x, int y) {
x -= y;
if (x < 0) x += MOD;
}
void Mul(int &x, int y) { x = (long long)(x) * (y) % MOD; }
int qpow(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = (long long)(ret) * (x) % MOD;
x = (long long)(x) * (x) % MOD;
y >>= 1;
}
return ret;
}
void checkmin(int &x, int y) {
if (x > y) x = y;
}
void checkmax(int &x, int y) {
if (x < y) x = y;
}
void checkmin(long long &x, long long y) {
if (x > y) x = y;
}
void checkmax(long long &x, long long y) {
if (x < y) x = y;
}
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x * f;
}
const int N = 1001;
const int M = 500005;
int first[N], nxt[M], point[M], w[M], cur[N], e = 0, tot = 0;
int S, T, a[N], id[N][N];
namespace Flow {
void add_edge(int x, int y, int z) {
point[e] = y;
w[e] = z;
nxt[e] = first[x];
first[x] = e++;
}
void add(int x, int y, int z) {
add_edge(x, y, z);
add_edge(y, x, 0);
id[x][y] = e - 1;
id[y][x] = e - 1;
}
int vis[N], dep[N];
bool bfs() {
queue<int> q;
while (!q.empty()) q.pop();
for (int i = 1; i <= tot; i++) vis[i] = 0;
vis[S] = 1;
q.push(S);
dep[S] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = first[u]; i != -1; i = nxt[i])
if (w[i]) {
int to = point[i];
if (vis[to]) continue;
dep[to] = dep[u] + 1;
vis[to] = 1;
q.push(to);
}
}
return vis[T];
}
int dfs(int u, int flow) {
if (u == T) return flow;
int ret = flow;
for (int &i = cur[u]; i != -1; i = nxt[i])
if (w[i]) {
int to = point[i];
if (dep[to] != dep[u] + 1) continue;
int tmp = dfs(to, min(w[i], ret));
if (tmp) w[i] -= tmp, w[i ^ 1] += tmp, ret -= tmp;
if (!ret) break;
}
return flow - ret;
}
int Dinic() {
int ret = 0;
while (bfs()) {
for (int i = 1; i <= tot; i++) cur[i] = first[i];
ret += dfs(S, inf);
}
return ret;
}
} // namespace Flow
int n, bl[M];
void init() {
memset(first, -1, sizeof(first));
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 2; i < M; i++) {
if (!bl[i])
for (int j = i + i; j < M; j += i) bl[j] = 1;
}
tot = n;
S = ++tot;
T = ++tot;
for (int i = 1; i <= n; i++) {
if (a[i] & 1) {
Flow::add(S, i, 2);
for (int j = 1; j <= n; j++)
if (!bl[a[i] + a[j]]) {
Flow::add(i, j, 1);
}
} else
Flow::add(i, T, 2);
}
}
int vis[N];
vector<vector<int> > ans;
int main() {
init();
int F = Flow::Dinic();
if (F != n) {
puts("Impossible");
return 0;
}
for (int i = 1; i <= n; i++)
if (!vis[i]) {
vector<int> v;
int x = i;
while (1) {
vis[x] = 1;
v.push_back(x);
int to = -1;
for (int j = 1; j <= n; j++)
if (w[id[x][j]] && !vis[j]) {
to = j;
break;
}
if (to == -1) break;
x = to;
}
ans.push_back(v);
}
printf("%d\n", (int)(ans).size());
for (auto &v : ans) {
printf("%d ", (int)(v).size());
for (auto &u : v) printf("%d ", u);
puts("");
}
return 0;
}
|
Tavas lives in Kansas. Kansas has n cities numbered from 1 to n connected with m bidirectional roads. We can travel from any city to any other city via these roads. Kansas is as strange as Tavas. So there may be a road between a city and itself or more than one road between two cities.
Tavas invented a game and called it "Dashti". He wants to play Dashti with his girlfriends, Nafas.
In this game, they assign an arbitrary integer value to each city of Kansas. The value of i-th city equals to pi.
During the game, Tavas is in city s and Nafas is in city t. They play in turn and Tavas goes first. A player in his/her turn, must choose a non-negative integer x and his/her score increases by the sum of values of all cities with (shortest) distance no more than x from his/her city. Each city may be used once, or in the other words, after first time a player gets score from a city, city score becomes zero.
There is an additional rule: the player must choose x such that he/she gets the point of at least one city that was not used before. Note that city may initially have value 0, such city isn't considered as been used at the beginning of the game, i. e. each player may use it to fullfill this rule.
The game ends when nobody can make a move.
A player's score is the sum of the points he/she earned during the game. The winner is the player with greater score, or there is a draw if players score the same value. Both players start game with zero points.
<image>
If Tavas wins, he'll break his girlfriend's heart, and if Nafas wins, Tavas will cry. But if their scores are equal, they'll be happy and Tavas will give Nafas flowers.
They're not too emotional after all, so they'll play optimally. Your task is to tell Tavas what's going to happen after the game ends.
Input
The first line of input contains two integers n and m (2 ≤ n ≤ 2000, n - 1 ≤ m ≤ 105).
The second line of input contains two integers s and t (1 ≤ s, t ≤ n, s ≠ t).
The next line contains n integers p1, p2, ..., pn separated by spaces (|pi| ≤ 109).
The next m lines contain the roads. Each line contains three integers v, u, w and it means that there's an road with length w between cities v and u (1 ≤ u, v ≤ n and 0 ≤ w ≤ 109). The road may lead from the city to itself, there may be several roads between each pair of cities.
Output
If Tavas wins, print "Break a heart". If Nafas wins print "Cry" and if nobody wins (i. e. the game ended with draw) print "Flowers".
Examples
Input
4 4
1 2
3 2 5 -11
1 4 2
3 4 2
3 1 5
3 2 1
Output
Cry
Input
5 4
1 2
2 2 -5 -4 6
1 2 4
2 3 5
2 4 2
4 5 2
Output
Break a heart
Input
2 1
1 2
-5 -5
1 2 10
Output
Flowers
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
struct arr {
long long x, s;
bool operator<(const arr &A) const { return A.s < s; }
};
long long n, m, s, t, v[200005], w[200005], head[200005], nxt[200005], cnt,
dis[200005], ds[200005], dt[200005], a[200005], f[2][2005][2005],
num[2005][2005], sum[2005][2005], vis[200005];
long long sumx[2005][2005], sumy[2005][2005], numx[2005][2005],
numy[2005][2005];
vector<long long> dds, ddt;
void add(long long a, long long b, long long c) {
v[++cnt] = b;
w[cnt] = c;
nxt[cnt] = head[a];
head[a] = cnt;
}
inline void dijkstra(long long S) {
memset(dis, 999999, sizeof(dis));
memset(vis, 0, sizeof(vis));
dis[S] = 0;
priority_queue<arr> q;
q.push((arr){S, 0});
while (!q.empty()) {
long long x = q.top().x;
q.pop();
if (vis[x]) continue;
vis[x] = 1;
for (long long i = head[x]; i; i = nxt[i]) {
if (dis[v[i]] > dis[x] + w[i]) {
dis[v[i]] = dis[x] + w[i];
q.push((arr){v[i], dis[v[i]]});
}
}
}
}
long long getsumx(long long x, long long l, long long r) {
return sumx[x][r] - sumx[x][l - 1];
}
long long getsumy(long long y, long long l, long long r) {
return sumy[r][y] - sumy[l - 1][y];
}
long long getnumx(long long x, long long l, long long r) {
return sumx[x][r] - sumx[x][l - 1];
}
long long getnumy(long long y, long long l, long long r) {
return sumy[r][y] - sumy[l - 1][y];
}
signed main() {
n = read();
m = read();
s = read();
t = read();
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = 1; i <= m; i++) {
long long x = read(), y = read(), z = read();
add(x, y, z);
add(y, x, z);
}
dijkstra(s);
for (long long i = 1; i <= n; i++) ds[i] = dis[i], dds.push_back(ds[i]);
dijkstra(t);
for (long long i = 1; i <= n; i++) dt[i] = dis[i], ddt.push_back(dt[i]);
sort(dds.begin(), dds.end());
sort(ddt.begin(), ddt.end());
long long ds_ = unique(dds.begin(), dds.end()) - dds.begin();
long long dt_ = unique(ddt.begin(), ddt.end()) - ddt.begin();
for (long long i = 1; i <= n; i++) {
long long xx = lower_bound(dds.begin(), dds.end(), ds[i]) - dds.begin() + 1;
long long yy = lower_bound(ddt.begin(), ddt.end(), dt[i]) - ddt.begin() + 1;
num[xx][yy]++;
sum[xx][yy] += a[i];
}
for (long long i = 1; i <= dt_ + 1; i++) {
for (long long j = 1; j <= ds_ + 1; j++) {
sumx[i][j] = sumx[i][j - 1] + sum[i][j];
sumy[i][j] = sumy[i - 1][j] + sum[i][j];
numx[i][j] = numx[i][j - 1] + num[i][j];
numy[i][j] = numy[i - 1][j] + num[i][j];
}
}
for (long long i = dt_; i >= 0; i--) {
for (long long j = ds_; j >= 0; j--) {
if (i != dt_) {
long long now = getnumx(i + 1, j + 1, ds_);
long long sc = getsumx(i + 1, j + 1, ds_);
if (!now)
f[0][i][j] = f[0][i + 1][j];
else
f[0][i][j] = max(f[0][i + 1][j], f[1][i + 1][j]) + sc;
}
if (j != ds_) {
long long now = getnumy(j + 1, i + 1, dt_);
long long sc = getsumy(j + 1, i + 1, dt_);
if (!now)
f[1][i][j] = f[1][i][j + 1];
else
f[1][i][j] = min(f[0][i][j + 1], f[1][i][j + 1]) - sc;
}
}
}
if (f[0][0][0] > 0)
puts("Break a heart");
else if (f[0][0][0] == 0)
puts("Flowers");
else
puts("Cry");
}
|
Giant chess is quite common in Geraldion. We will not delve into the rules of the game, we'll just say that the game takes place on an h × w field, and it is painted in two colors, but not like in chess. Almost all cells of the field are white and only some of them are black. Currently Gerald is finishing a game of giant chess against his friend Pollard. Gerald has almost won, and the only thing he needs to win is to bring the pawn from the upper left corner of the board, where it is now standing, to the lower right corner. Gerald is so confident of victory that he became interested, in how many ways can he win?
The pawn, which Gerald has got left can go in two ways: one cell down or one cell to the right. In addition, it can not go to the black cells, otherwise the Gerald still loses. There are no other pawns or pieces left on the field, so that, according to the rules of giant chess Gerald moves his pawn until the game is over, and Pollard is just watching this process.
Input
The first line of the input contains three integers: h, w, n — the sides of the board and the number of black cells (1 ≤ h, w ≤ 105, 1 ≤ n ≤ 2000).
Next n lines contain the description of black cells. The i-th of these lines contains numbers ri, ci (1 ≤ ri ≤ h, 1 ≤ ci ≤ w) — the number of the row and column of the i-th cell.
It is guaranteed that the upper left and lower right cell are white and all cells in the description are distinct.
Output
Print a single line — the remainder of the number of ways to move Gerald's pawn from the upper left to the lower right corner modulo 109 + 7.
Examples
Input
3 4 2
2 2
2 3
Output
2
Input
100 100 3
15 16
16 15
99 88
Output
545732279
|
#include <bits/stdc++.h>
using namespace std;
const int maxv = 2045;
const long long mod = 1e9 + 7;
const int maxn = 1e6 + 40;
long long fac[maxn], inv[maxn];
long long qpow(long long a, long long p) {
long long ans = 1;
long long xx = a;
while (p > 0) {
if (p & 1) ans = (xx * ans) % mod;
xx = (xx * xx) % mod;
p >>= 1;
}
return ans;
}
void init() {
fac[0] = 1;
inv[0] = 1;
for (long long i = 1; i < maxn; i++) {
fac[i] = (fac[i - 1] * i) % mod;
inv[i] = inv[i - 1] * qpow(i, mod - 2) % mod;
}
}
int h, w, n;
pair<long long, long long> a[maxv];
long long dp[maxv];
long long culC(long long a, long long b) {
return fac[a] * inv[a - b] % mod * inv[b] % mod;
}
long long path(long long sx, long long sy, long long tx, long long ty) {
return culC(ty - sy + tx - sx, tx - sx);
}
void solve() {
for (int i = 0; i <= n; i++) {
long long ans = 0;
for (int j = 0; j < i; j++) {
if (a[j].second <= a[i].second)
ans += path(a[j].first, a[j].second, a[i].first, a[i].second) * dp[j] %
mod,
ans %= mod;
}
dp[i] = (path(1, 1, a[i].first, a[i].second) - ans) % mod + mod,
dp[i] %= mod;
}
}
int main() {
init();
cin >> h >> w >> n;
for (int i = 0; i < n; i++) {
int c, r;
scanf("%d%d", &r, &c);
a[i].first = r;
a[i].second = c;
}
sort(a, a + n);
a[n] = pair<long long, long long>(h, w);
solve();
cout << dp[n] << endl;
return 0;
}
|
Recently, Duff has been practicing weight lifting. As a hard practice, Malek gave her a task. He gave her a sequence of weights. Weight of i-th of them is 2wi pounds. In each step, Duff can lift some of the remaining weights and throw them away. She does this until there's no more weight left. Malek asked her to minimize the number of steps.
<image>
Duff is a competitive programming fan. That's why in each step, she can only lift and throw away a sequence of weights 2a1, ..., 2ak if and only if there exists a non-negative integer x such that 2a1 + 2a2 + ... + 2ak = 2x, i. e. the sum of those numbers is a power of two.
Duff is a competitive programming fan, but not a programmer. That's why she asked for your help. Help her minimize the number of steps.
Input
The first line of input contains integer n (1 ≤ n ≤ 106), the number of weights.
The second line contains n integers w1, ..., wn separated by spaces (0 ≤ wi ≤ 106 for each 1 ≤ i ≤ n), the powers of two forming the weights values.
Output
Print the minimum number of steps in a single line.
Examples
Input
5
1 1 2 3 3
Output
2
Input
4
0 1 2 3
Output
4
Note
In the first sample case: One optimal way would be to throw away the first three in the first step and the rest in the second step. Also, it's not possible to do it in one step because their sum is not a power of two.
In the second sample case: The only optimal way is to throw away one weight in each step. It's not possible to do it in less than 4 steps because there's no subset of weights with more than one weight and sum equal to a power of two.
|
#include <bits/stdc++.h>
using namespace std;
int n;
int w[1000000];
int m[2000001];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &w[i]);
m[w[i]]++;
}
sort(w, w + n);
long long ans = 0;
for (int i = 0; i <= 1000130; i++) {
long long f = m[i];
if (f == 0) {
continue;
}
vector<int> v1;
for (int j = 0; j < 22; j++) {
v1.push_back(f % 2LL);
f /= 2LL;
}
long long t = 1;
for (int j = 0; j < 22; j++) {
m[i] -= t * v1[j];
m[j + i] += v1[j];
t *= 2LL;
}
ans += m[i];
}
cout << ans << endl;
return 0;
}
|
In the school computer room there are n servers which are responsible for processing several computing tasks. You know the number of scheduled tasks for each server: there are mi tasks assigned to the i-th server.
In order to balance the load for each server, you want to reassign some tasks to make the difference between the most loaded server and the least loaded server as small as possible. In other words you want to minimize expression ma - mb, where a is the most loaded server and b is the least loaded one.
In one second you can reassign a single task. Thus in one second you can choose any pair of servers and move a single task from one server to another.
Write a program to find the minimum number of seconds needed to balance the load of servers.
Input
The first line contains positive number n (1 ≤ n ≤ 105) — the number of the servers.
The second line contains the sequence of non-negative integers m1, m2, ..., mn (0 ≤ mi ≤ 2·104), where mi is the number of tasks assigned to the i-th server.
Output
Print the minimum number of seconds required to balance the load.
Examples
Input
2
1 6
Output
2
Input
7
10 11 10 11 10 11 11
Output
0
Input
5
1 2 3 4 5
Output
3
Note
In the first example two seconds are needed. In each second, a single task from server #2 should be moved to server #1. After two seconds there should be 3 tasks on server #1 and 4 tasks on server #2.
In the second example the load is already balanced.
A possible sequence of task movements for the third example is:
1. move a task from server #4 to server #1 (the sequence m becomes: 2 2 3 3 5);
2. then move task from server #5 to server #1 (the sequence m becomes: 3 2 3 3 4);
3. then move task from server #5 to server #2 (the sequence m becomes: 3 3 3 3 3).
The above sequence is one of several possible ways to balance the load of servers in three seconds.
|
input()
servers = [int(x) for x in input().split(" ", )]
servers.sort()
avg = int(sum(servers) / len(servers))
extra = sum(servers) % len(servers)
count = 0
for i in range(len(servers)):
count += abs(avg + (i >= (len(servers) - extra)) - servers[i]) / 2
print(int(count))
|
The city administration of IT City decided to fix up a symbol of scientific and technical progress in the city's main square, namely an indicator board that shows the effect of Moore's law in real time.
Moore's law is the observation that the number of transistors in a dense integrated circuit doubles approximately every 24 months. The implication of Moore's law is that computer performance as function of time increases exponentially as well.
You are to prepare information that will change every second to display on the indicator board. Let's assume that every second the number of transistors increases exactly 1.000000011 times.
Input
The only line of the input contains a pair of integers n (1000 ≤ n ≤ 10 000) and t (0 ≤ t ≤ 2 000 000 000) — the number of transistors in the initial time and the number of seconds passed since the initial time.
Output
Output one number — the estimate of the number of transistors in a dence integrated circuit in t seconds since the initial time. The relative error of your answer should not be greater than 10 - 6.
Examples
Input
1000 1000000
Output
1011.060722383550382782399454922040
|
n,t=map(int,input().split())
print(n*((1.000000011)**t))
|
Input
The only line of the input is a string of 7 characters. The first character is letter A, followed by 6 digits. The input is guaranteed to be valid (for certain definition of "valid").
Output
Output a single integer.
Examples
Input
A221033
Output
21
Input
A223635
Output
22
Input
A232726
Output
23
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int i, l, z = 0;
cin >> s;
l = s.size();
for (i = 0; i < l; i++)
if (s[i] == 'A')
z += 1;
else if (s[i] == '1')
z += 10;
else
z += s[i] - '0';
cout << z;
return 0;
}
|
A little bear Limak plays a game. He has five cards. There is one number written on each card. Each number is a positive integer.
Limak can discard (throw out) some cards. His goal is to minimize the sum of numbers written on remaining (not discarded) cards.
He is allowed to at most once discard two or three cards with the same number. Of course, he won't discard cards if it's impossible to choose two or three cards with the same number.
Given five numbers written on cards, cay you find the minimum sum of numbers on remaining cards?
Input
The only line of the input contains five integers t1, t2, t3, t4 and t5 (1 ≤ ti ≤ 100) — numbers written on cards.
Output
Print the minimum possible sum of numbers written on remaining cards.
Examples
Input
7 3 7 3 20
Output
26
Input
7 9 3 1 8
Output
28
Input
10 10 10 10 10
Output
20
Note
In the first sample, Limak has cards with numbers 7, 3, 7, 3 and 20. Limak can do one of the following.
* Do nothing and the sum would be 7 + 3 + 7 + 3 + 20 = 40.
* Remove two cards with a number 7. The remaining sum would be 3 + 3 + 20 = 26.
* Remove two cards with a number 3. The remaining sum would be 7 + 7 + 20 = 34.
You are asked to minimize the sum so the answer is 26.
In the second sample, it's impossible to find two or three cards with the same number. Hence, Limak does nothing and the sum is 7 + 9 + 1 + 3 + 8 = 28.
In the third sample, all cards have the same number. It's optimal to discard any three cards. The sum of two remaining numbers is 10 + 10 = 20.
|
from collections import Counter
a = map(int,raw_input().split())
s = sum(a)
a = Counter(a)
#print a
result = s
#print result
for k,v in a.items():
#print k,v
if v>=2:
result = min(result,s - k *min(3,v))
print result
|
The big consignment of t-shirts goes on sale in the shop before the beginning of the spring. In all n types of t-shirts go on sale. The t-shirt of the i-th type has two integer parameters — ci and qi, where ci — is the price of the i-th type t-shirt, qi — is the quality of the i-th type t-shirt. It should be assumed that the unlimited number of t-shirts of each type goes on sale in the shop, but in general the quality is not concerned with the price.
As predicted, k customers will come to the shop within the next month, the j-th customer will get ready to spend up to bj on buying t-shirts.
All customers have the same strategy. First of all, the customer wants to buy the maximum possible number of the highest quality t-shirts, then to buy the maximum possible number of the highest quality t-shirts from residuary t-shirts and so on. At the same time among several same quality t-shirts the customer will buy one that is cheaper. The customers don't like the same t-shirts, so each customer will not buy more than one t-shirt of one type.
Determine the number of t-shirts which each customer will buy, if they use the described strategy. All customers act independently from each other, and the purchase of one does not affect the purchase of another.
Input
The first line contains the positive integer n (1 ≤ n ≤ 2·105) — the number of t-shirt types.
Each of the following n lines contains two integers ci and qi (1 ≤ ci, qi ≤ 109) — the price and the quality of the i-th type t-shirt.
The next line contains the positive integer k (1 ≤ k ≤ 2·105) — the number of the customers.
The next line contains k positive integers b1, b2, ..., bk (1 ≤ bj ≤ 109), where the j-th number is equal to the sum, which the j-th customer gets ready to spend on t-shirts.
Output
The first line of the input data should contain the sequence of k integers, where the i-th number should be equal to the number of t-shirts, which the i-th customer will buy.
Examples
Input
3
7 5
3 5
4 3
2
13 14
Output
2 3
Input
2
100 500
50 499
4
50 200 150 100
Output
1 2 2 1
Note
In the first example the first customer will buy the t-shirt of the second type, then the t-shirt of the first type. He will spend 10 and will not be able to buy the t-shirt of the third type because it costs 4, and the customer will owe only 3. The second customer will buy all three t-shirts (at first, the t-shirt of the second type, then the t-shirt of the first type, and then the t-shirt of the third type). He will spend all money on it.
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &n) {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
n = x * f;
}
int outputarray[20];
inline void write(int k) {
int num = 0;
if (k < 0) putchar('-'), k = -k;
do {
outputarray[++num] = k % 10, k /= 10;
} while (k);
while (num) putchar(outputarray[num--] + '0');
}
const int maxn = 200001;
int n, m, ans[maxn];
struct T {
int p, q;
bool operator<(const T &b) const { return q != b.q ? q > b.q : p < b.p; }
} s[maxn];
struct node {
int key, id, l1, l2, s1, s2;
node *l, *r;
node(int w, int id) : s1(w), id(id) {
key = rand();
l1 = l2 = s2 = 0;
l = r = NULL;
}
void pushdown() {
if (l1) {
if (l != NULL) l->l1 += l1, l->s1 += l1;
if (r != NULL) r->l1 += l1, r->s1 += l1;
l1 = 0;
}
if (l2) {
if (l != NULL) l->l2 += l2, l->s2 += l2;
if (r != NULL) r->l2 += l2, r->s2 += l2;
l2 = 0;
}
}
};
void split(node *root, node *&a, node *&b, int v) {
if (root == NULL) {
a = b = NULL;
return;
}
root->pushdown();
if (root->s1 >= v)
b = root, split(root->l, a, b->l, v);
else
a = root, split(root->r, a->r, b, v);
}
node *merge(node *a, node *b) {
if (a == NULL) return b;
if (b == NULL) return a;
if (a->key < b->key) {
a->pushdown(), a->r = merge(a->r, b);
return a;
}
b->pushdown(), b->l = merge(a, b->l);
return b;
}
node *insert(node *a, node *b) {
if (a == NULL) return b;
node *l, *r;
split(a, l, r, b->s1);
return merge(l, merge(b, r));
}
node *left(node *root) {
while (root->l != NULL) {
root->pushdown();
root = root->l;
}
return root;
}
node *right(node *root) {
while (root->r != NULL) {
root->pushdown();
root = root->r;
}
return root;
}
void updata(node *root, int v, int w) {
root->l1 += v, root->l2 += w, root->s1 += v, root->s2 += w;
}
void query(node *root) {
if (root == NULL) return;
ans[root->id] = root->s2;
root->pushdown();
if (root->l != NULL) query(root->l);
if (root->r != NULL) query(root->r);
}
int main() {
read(n);
for (int i = 1; i <= n; i++) read(s[i].p), read(s[i].q);
sort(s + 1, s + n + 1);
read(m);
node *root = NULL;
int k;
for (int i = 1; i <= m; i++) {
read(k);
root = insert(root, new node(k, i));
}
node *l, *r, *x, *y, *L, *R;
for (int i = 1; i <= n; i++) {
split(root, l, r, s[i].p);
if (r == NULL) {
root = l;
continue;
}
updata(r, -s[i].p, 1);
if (l == NULL) {
root = r;
continue;
}
x = left(r), y = right(l);
while (x->s1 < y->s1) {
split(r, L, R, x->s1 + 1);
l = insert(l, L), r = R;
if (l == NULL || r == NULL) break;
x = left(r), y = right(l);
}
root = merge(l, r);
}
query(root);
for (int i = 1; i <= m; i++) write(ans[i]), putchar(' ');
return 0;
}
|
You are given an undirected graph, constisting of n vertices and m edges. Each edge of the graph has some non-negative integer written on it.
Let's call a triple (u, v, s) interesting, if 1 ≤ u < v ≤ n and there is a path (possibly non-simple, i.e. it can visit the same vertices and edges multiple times) between vertices u and v such that xor of all numbers written on the edges of this path is equal to s. When we compute the value s for some path, each edge is counted in xor as many times, as it appear on this path. It's not hard to prove that there are finite number of such triples.
Calculate the sum over modulo 109 + 7 of the values of s over all interesting triples.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 100 000, 0 ≤ m ≤ 200 000) — numbers of vertices and edges in the given graph.
The follow m lines contain three integers ui, vi and ti (1 ≤ ui, vi ≤ n, 0 ≤ ti ≤ 1018, ui ≠ vi) — vertices connected by the edge and integer written on it. It is guaranteed that graph doesn't contain self-loops and multiple edges.
Output
Print the single integer, equal to the described sum over modulo 109 + 7.
Examples
Input
4 4
1 2 1
1 3 2
2 3 3
3 4 1
Output
12
Input
4 4
1 2 1
2 3 2
3 4 4
4 1 8
Output
90
Input
8 6
1 2 2
2 3 1
2 4 4
4 5 5
4 6 3
7 8 5
Output
62
Note
In the first example the are 6 interesting triples:
1. (1, 2, 1)
2. (1, 3, 2)
3. (1, 4, 3)
4. (2, 3, 3)
5. (2, 4, 2)
6. (3, 4, 1)
The sum is equal to 1 + 2 + 3 + 3 + 2 + 1 = 12.
In the second example the are 12 interesting triples:
1. (1, 2, 1)
2. (2, 3, 2)
3. (1, 3, 3)
4. (3, 4, 4)
5. (2, 4, 6)
6. (1, 4, 7)
7. (1, 4, 8)
8. (2, 4, 9)
9. (3, 4, 11)
10. (1, 3, 12)
11. (2, 3, 13)
12. (1, 2, 14)
The sum is equal to 1 + 2 + 3 + 4 + 6 + 7 + 8 + 9 + 11 + 12 + 13 + 14 = 90.
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int mxn = 400005, maxnn = 100005;
const int mod = 1e9 + 7;
long long ans;
int n, m, num, cir, r, cnt;
int head[maxnn], que[maxnn];
struct edge {
int to, next;
long long w;
} f[mxn << 2];
long long p[70], circle[mxn], dis[maxnn], dig[2], pw[105];
inline void add(int u, int v, long long w) {
f[++cnt].to = v, f[cnt].w = w, f[cnt].next = head[u], head[u] = cnt;
}
inline void dfs(int u, int fa, long long now) {
dis[u] = now, que[++num] = u;
for (int i = head[u]; i; i = f[i].next) {
int v = f[i].to;
if (v == fa) continue;
if (dis[v] == -1)
dfs(v, u, dis[u] ^ f[i].w);
else
circle[++cir] = dis[u] ^ dis[v] ^ f[i].w;
}
}
inline void init() {
int i, j;
r = 0;
memset(p, 0, sizeof p);
for (i = 1; i <= cir; i++) {
long long x = circle[i];
for (j = 62; j >= 0; j--) {
if (!(x >> j)) continue;
if (!p[j]) {
p[j] = x;
break;
}
x ^= p[j];
}
}
for (j = 0; j <= 62; j++)
if (p[j]) r++;
}
inline void calc() {
init();
int i, j;
for (j = 0; j <= 62; j++) {
bool flag = 0;
dig[0] = dig[1] = 0;
for (i = 1; i <= num; i++) dig[(dis[que[i]] >> j) & 1]++;
for (i = 0; i <= 62; i++)
if ((p[i] >> j) & 1) {
flag = 1;
break;
}
long long now =
(dig[0] * (dig[0] - 1) / 2 + dig[1] * (dig[1] - 1) / 2) % mod;
if (flag) {
if (r) now = now * pw[r - 1] % mod;
now = now * pw[j] % mod;
ans = (ans + now) % mod;
}
now = dig[0] * dig[1] % mod;
if (flag) {
if (r) now = now * pw[r - 1] % mod;
} else
now = now * pw[r] % mod;
now = now * pw[j] % mod;
ans = (ans + now) % mod;
}
}
int main() {
int i, j, u, v;
long long w;
memset(dis, -1, sizeof dis);
pw[0] = 1;
for (j = 1; j <= 100; j++) pw[j] = pw[j - 1] * 2 % mod;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d%lld", &u, &v, &w);
add(u, v, w), add(v, u, w);
}
for (i = 1; i <= n; i++)
if (dis[i] == -1) {
num = cir = 0;
dfs(i, 0, 0);
calc();
}
printf("%lld", ans);
return 0;
}
|
There are n cities in Berland, each of them has a unique id — an integer from 1 to n, the capital is the one with id 1. Now there is a serious problem in Berland with roads — there are no roads.
That is why there was a decision to build n - 1 roads so that there will be exactly one simple path between each pair of cities.
In the construction plan t integers a1, a2, ..., at were stated, where t equals to the distance from the capital to the most distant city, concerning new roads. ai equals the number of cities which should be at the distance i from the capital. The distance between two cities is the number of roads one has to pass on the way from one city to another.
Also, it was decided that among all the cities except the capital there should be exactly k cities with exactly one road going from each of them. Such cities are dead-ends and can't be economically attractive. In calculation of these cities the capital is not taken into consideration regardless of the number of roads from it.
Your task is to offer a plan of road's construction which satisfies all the described conditions or to inform that it is impossible.
Input
The first line contains three positive numbers n, t and k (2 ≤ n ≤ 2·105, 1 ≤ t, k < n) — the distance to the most distant city from the capital and the number of cities which should be dead-ends (the capital in this number is not taken into consideration).
The second line contains a sequence of t integers a1, a2, ..., at (1 ≤ ai < n), the i-th number is the number of cities which should be at the distance i from the capital. It is guaranteed that the sum of all the values ai equals n - 1.
Output
If it is impossible to built roads which satisfy all conditions, print -1.
Otherwise, in the first line print one integer n — the number of cities in Berland. In the each of the next n - 1 line print two integers — the ids of cities that are connected by a road. Each road should be printed exactly once. You can print the roads and the cities connected by a road in any order.
If there are multiple answers, print any of them. Remember that the capital has id 1.
Examples
Input
7 3 3
2 3 1
Output
7
1 3
2 1
2 6
2 4
7 4
3 5
Input
14 5 6
4 4 2 2 1
Output
14
3 1
1 4
11 6
1 2
10 13
6 10
10 12
14 12
8 4
5 1
3 7
2 6
5 9
Input
3 1 1
2
Output
-1
|
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.util.List;
import java.util.ArrayList;
public class G {
public static void main(String args[]) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
Solver solver = new Solver();
solver.solve(in, out);
out.close();
}
static class Solver {
int n, m, k;
int[] a, s;
public void solve(InputReader in, PrintWriter out) {
n = in.readInt();
m = in.readInt();
k = in.readInt();
a = new int[m + 1];
s = new int[m + 1];
for(int i=1; i<=m; i++)
a[i] = in.readInt();
a[0] = 1;
int expectK = a[m];
for(int i=1; i<m; i++)
expectK += Math.max(0, a[i] - a[i + 1]);
if (expectK > k) {
out.println(-1);
return;
}
expectK = k - expectK;
int st = 2;
s[0] = 1;
for(int i=1; i<=m; i++) {
s[i] = st;
st += a[i];
}
List <Edge> g = new ArrayList <Edge> ();
for(int i=0; i<m; i++) {
int rl = Math.min(a[i], a[i + 1]);
int tru = Math.min(expectK, rl - 1);
int sl = a[i] - Math.max(0, a[i] - a[i + 1]) - tru;
//out.println(i + " " + sl);
for(int j=0; j<a[i+1]; j++) {
g.add(new Edge(s[i] + (j % sl), s[i+1] + j));
}
expectK -= tru;
}
if (expectK > 0) {
out.println(-1);
return;
}
out.println(n);
for(Edge e : g)
out.println(e.u + " " + e.v);
}
class Edge {
public int u, v;
public Edge(int _u, int _v) {
u = _u; v = _v;
}
}
}
static class InputReader {
BufferedReader reader;
StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public InputReader(File f) {
try {
reader = new BufferedReader(new FileReader(f));
} catch (FileNotFoundException e) {
throw (new RuntimeException(e));
}
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw (new RuntimeException(e));
}
}
return tokenizer.nextToken();
}
public int readInt() {
return Integer.parseInt(next());
}
public long readLong() {
return Long.parseLong(next());
}
public double readDouble() {
return Double.parseDouble(next());
}
public String readLine() {
String s = "";
try {
s = reader.readLine();
} catch (IOException e) {
throw (new RuntimeException(e));
}
return s;
}
}
}
|
Scientists of planet Olympia are conducting an experiment in mutation of primitive organisms. Genome of organism from this planet can be represented as a string of the first K capital English letters. For each pair of types of genes they assigned ai, j — a risk of disease occurence in the organism provided that genes of these types are adjacent in the genome, where i — the 1-based index of the first gene and j — the index of the second gene. The gene 'A' has index 1, 'B' has index 2 and so on. For example, a3, 2 stands for the risk of 'CB' fragment. Risk of disease occurence in the organism is equal to the sum of risks for each pair of adjacent genes in the genome.
Scientists have already obtained a base organism. Some new organisms can be obtained by mutation of this organism. Mutation involves removal of all genes of some particular types. Such removal increases the total risk of disease occurence additionally. For each type of genes scientists determined ti — the increasement of the total risk of disease occurence provided by removal of all genes having type with index i. For example, t4 stands for the value of additional total risk increasement in case of removing all the 'D' genes.
Scientists want to find a number of different organisms that can be obtained from the given one which have the total risk of disease occurence not greater than T. They can use only the process of mutation described above. Two organisms are considered different if strings representing their genomes are different. Genome should contain at least one gene.
Input
The first line of the input contains three integer numbers N (1 ≤ N ≤ 200 000) — length of the genome of base organism, K (1 ≤ K ≤ 22) — the maximal index of gene type in the genome and T (1 ≤ T ≤ 2·109) — maximal allowable risk of disease occurence. The second line contains the genome of the given organism. It is a string of the first K capital English letters having length N.
The third line contains K numbers t1, t2, ..., tK, where ti is additional risk value of disease occurence provided by removing of all genes of the i-th type.
The following K lines contain the elements of the given matrix ai, j. The i-th line contains K numbers. The j-th number of the i-th line stands for a risk of disease occurence for the pair of genes, first of which corresponds to the i-th letter and second of which corresponds to the j-th letter. The given matrix is not necessarily symmetrical.
All the numbers in the input are integer, non-negative and all of them except T are not greater than 109. It is guaranteed that the maximal possible risk of organism that can be obtained from the given organism is strictly smaller than 231.
Output
Output the number of organisms that can be obtained from the base one and which have the total risk of disease occurence not greater than T.
Examples
Input
5 3 13
BACAC
4 1 2
1 2 3
2 3 4
3 4 10
Output
5
Note
Explanation: one can obtain the following organisms (risks are stated in brackets): BACAC (11), ACAC (10), BAA (5), B (6), AA (4).
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline T1 max(T1 a, T2 b) {
return a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 min(T1 a, T2 b) {
return a < b ? a : b;
}
const char lf = '\n';
namespace ae86 {
const int bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline int fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t) return EOF;
}
return *s++;
}
inline int ty() {
int a = 0;
int b = 1, c = fetch();
while (!isdigit(c)) b ^= c == '-', c = fetch();
while (isdigit(c)) a = a * 10 + c - 48, c = fetch();
return b ? a : -a;
}
template <typename T>
inline int ts(T *s) {
int a = 0, c = fetch();
while (c <= 32 && c != EOF) c = fetch();
while (c > 32 && c != EOF) s[a++] = c, c = fetch();
s[a] = 0;
return a;
}
} // namespace ae86
using ae86::ts;
using ae86::ty;
const int _ = 200007, alp = 22, __ = 4233333;
int n, ps, str[_], ned[alp], val[alp][alp];
long long lim, f[__] = {0};
int main() {
ios::sync_with_stdio(0), cout.tie(nullptr);
n = ty(), ps = ty(), lim = ty(), ts(str + 1);
for (int i = 0; i < ps; i++) ned[i] = ty();
for (int i = 0; i < ps; i++)
for (int j = 0; j < ps; j++) val[i][j] = ty();
for (int i = 1; i <= n; i++) str[i] -= 'A';
int las[alp];
memset(las, -1, sizeof(las));
int all = 0;
for (int i = 0; i < ps; i++) f[(1 << (i))] = ned[i];
for (int i = 1; i <= n; i++) {
all |= (1 << (str[i]));
for (int j = 0; j < ps; j++) {
if (las[j] < 0) continue;
if (!(((las[j]) >> (j)) & 1) && !(((las[j]) >> (str[i])) & 1)) {
f[las[j]] += val[j][str[i]];
f[las[j] | (1 << (j))] -= val[j][str[i]];
f[las[j] | (1 << (str[i]))] -= val[j][str[i]];
f[las[j] | (1 << (j)) | (1 << (str[i]))] += val[j][str[i]];
}
las[j] |= (1 << (str[i]));
}
las[str[i]] = 0;
}
for (int i = 0; i < alp; i++)
for (int j = 0; j < (1 << (alp)); j++)
if ((((j) >> (i)) & 1)) f[j] += f[j - (1 << (i))];
int ans = 0;
for (int i = 0; i < (1 << (alp)); i++)
if ((i & all) == i && i != all && f[i] <= lim) ans++;
cout << ans << lf;
return 0;
}
|
Oleg the bank client solves an interesting chess problem: place on n × n chessboard the maximum number of rooks so that they don't beat each other. Of course, no two rooks can share the same cell.
Remind that a rook standing in the cell (a, b) beats a rook standing in the cell (x, y) if and only if a = x or b = y.
Unfortunately (of fortunately?) for Oleg the answer in this problem was always n, so the task bored Oleg soon. He decided to make it more difficult by removing some cells from the board. If a cell is deleted, Oleg can't put a rook there, but rooks do beat each other "through" deleted cells.
Oleg deletes the cells in groups, namely, he repeatedly choose a rectangle with sides parallel to the board sides and deletes all the cells inside the rectangle. Formally, if he chooses a rectangle, lower left cell of which has coordinates (x1, y1), and upper right cell of which has coordinates (x2, y2), then he deletes all such cells with coordinates (x, y) that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2. It is guaranteed that no cell is deleted twice, i.e. the chosen rectangles do not intersect.
This version of the problem Oleg can't solve, and his friend Igor is busy at a conference, so he can't help Oleg.
You are the last hope for Oleg! Help him: given the size of the board and the deleted rectangles find the maximum possible number of rooks that could be placed on the board so that no two rooks beat each other.
Input
The first line contains single integer n (1 ≤ n ≤ 10000) — the size of the board.
The second line contains single integer q (0 ≤ q ≤ 10000) — the number of deleted rectangles.
The next q lines contain the information about the deleted rectangles.
Each of these lines contains four integers x1, y1, x2 and y2 (1 ≤ x1 ≤ x2 ≤ n, 1 ≤ y1 ≤ y2 ≤ n) — the coordinates of the lower left and the upper right cells of a deleted rectangle.
If is guaranteed that the rectangles do not intersect.
Output
In the only line print the maximum number of rooks Oleg can place on the board so that no two rooks beat each other.
Examples
Input
5
5
1 1 2 1
1 3 1 5
4 1 5 5
2 5 2 5
3 2 3 5
Output
3
Input
8
4
2 2 4 6
1 8 1 8
7 1 8 2
5 4 6 8
Output
8
Note
Here is the board and the example of rooks placement in the first example:
<image>
|
#include <bits/stdc++.h>
using PII = std::pair<int, int>;
template <class F = int>
class Graph {
public:
struct Edge {
int v;
F w;
};
Graph(int n) : e(), g(n), d(n), cur(n) {}
std::vector<Edge> e;
std::vector<std::vector<int>> g;
void AddEdge(int x, int y, F z) {
g[x].push_back(e.size()), e.push_back({y, z});
g[y].push_back(e.size()), e.push_back({x, 0});
}
F MaxFlow(int s_, int t_) {
s = s_, t = t_;
F f = 0;
while (bfs()) {
std::fill(cur.begin(), cur.end(), 0);
f += dfs(s, std::numeric_limits<F>().max());
}
return f;
}
private:
std::vector<int> d, cur;
int s, t;
int bfs() {
static int q[1000005], l, r;
std::fill(d.begin(), d.end(), -1);
q[l = r = 1] = s, d[s] = 0;
while (l <= r) {
int x = q[l++];
for (int i : g[x]) {
if (e[i].w && !~d[e[i].v]) {
d[q[++r] = e[i].v] = d[x] + 1;
}
}
}
return ~d[t];
}
F dfs(int x, F flow) {
if (x == t || !flow) return flow;
F used = 0;
for (; cur[x] < g[x].size(); cur[x]++) {
int i = g[x][cur[x]], y = e[i].v;
if (!e[i].w || d[y] != d[x] + 1) continue;
F f = dfs(y, std::min(flow - used, e[i].w));
e[i].w -= f, e[i ^ 1].w += f, used += f;
if (flow == used) return used;
}
if (!used) d[x] = -1;
return used;
}
};
Graph<int> *g;
struct Node {
int ls, rs;
} t[666666];
int cnt;
std::map<PII, int> id;
void build(int &o, int l, int r) {
id[PII(l, r)] = o = ++cnt;
t[o].ls = t[o].rs = 0;
if (l == r) return;
int m = l + r >> 1;
build(t[o].ls, l, m), build(t[o].rs, m + 1, r);
}
bool vis[666666];
void link(int o) {
if (vis[o]) return;
vis[o] = true;
if (t[o].ls) {
g->AddEdge(o, t[o].ls, INT_MAX);
link(t[o].ls);
}
if (t[o].rs) {
g->AddEdge(o, t[o].rs, INT_MAX);
link(t[o].rs);
}
}
void update(int &o, int l, int r, int x, int y, int z) {
if (x <= l && r <= y) {
if (z) {
o = 0;
} else {
assert(!o);
o = id[PII(l, r)];
}
return;
}
t[++cnt] = t[o], o = cnt;
int m = l + r >> 1;
if (x <= m) update(t[o].ls, l, m, x, y, z);
if (y > m) update(t[o].rs, m + 1, r, x, y, z);
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, m;
std::cin >> n >> m;
std::vector<std::vector<PII>> add(n + 1), del(n + 1);
while (m--) {
int x1, y1, x2, y2;
std::cin >> x1 >> y1 >> x2 >> y2;
x1--;
add[x1].emplace_back(y1, y2);
del[x2].emplace_back(y1, y2);
}
std::vector<PII> root(1);
build(root[0].first, 1, n);
for (int i = 0; i < n; i++) {
if (add[i].empty() && del[i].empty()) {
root.back().second++;
continue;
}
root.emplace_back(root.back().first, 1);
for (auto [l, r] : del[i]) {
update(root.back().first, 1, n, l, r, 0);
}
for (auto [l, r] : add[i]) {
update(root.back().first, 1, n, l, r, 1);
}
}
int s = 0, t = cnt + 1;
g = new Graph<int>(cnt + 2);
for (auto [r, x] : root) {
g->AddEdge(s, r, x);
link(r);
}
for (int i = 1; i <= n; i++) g->AddEdge(id[PII(i, i)], t, 1);
std::cout << g->MaxFlow(s, t) << "\n";
return 0;
}
|
The crowdedness of the discotheque would never stop our friends from having fun, but a bit more spaciousness won't hurt, will it?
The discotheque can be seen as an infinite xy-plane, in which there are a total of n dancers. Once someone starts moving around, they will move only inside their own movement range, which is a circular area Ci described by a center (xi, yi) and a radius ri. No two ranges' borders have more than one common point, that is for every pair (i, j) (1 ≤ i < j ≤ n) either ranges Ci and Cj are disjoint, or one of them is a subset of the other. Note that it's possible that two ranges' borders share a single common point, but no two dancers have exactly the same ranges.
Tsukihi, being one of them, defines the spaciousness to be the area covered by an odd number of movement ranges of dancers who are moving. An example is shown below, with shaded regions representing the spaciousness if everyone moves at the same time.
<image>
But no one keeps moving for the whole night after all, so the whole night's time is divided into two halves — before midnight and after midnight. Every dancer moves around in one half, while sitting down with friends in the other. The spaciousness of two halves are calculated separately and their sum should, of course, be as large as possible. The following figure shows an optimal solution to the example above.
<image>
By different plans of who dances in the first half and who does in the other, different sums of spaciousness over two halves are achieved. You are to find the largest achievable value of this sum.
Input
The first line of input contains a positive integer n (1 ≤ n ≤ 1 000) — the number of dancers.
The following n lines each describes a dancer: the i-th line among them contains three space-separated integers xi, yi and ri ( - 106 ≤ xi, yi ≤ 106, 1 ≤ ri ≤ 106), describing a circular movement range centered at (xi, yi) with radius ri.
Output
Output one decimal number — the largest achievable sum of spaciousness over two halves of the night.
The output is considered correct if it has a relative or absolute error of at most 10 - 9. Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
5
2 1 6
0 4 1
2 -1 3
1 -2 1
4 -1 1
Output
138.23007676
Input
8
0 0 1
0 0 2
0 0 3
0 0 4
0 0 5
0 0 6
0 0 7
0 0 8
Output
289.02652413
Note
The first sample corresponds to the illustrations in the legend.
|
#include <bits/stdc++.h>
using namespace std;
long long sqr(long long x) { return (x * x); }
long long dist(pair<long long, long long> a, pair<long long, long long> b) {
return sqr(a.first - b.first) + sqr(a.second - b.second);
}
long long func(long long i) {
if (i < 2 || i & 1) return 1;
return -1;
}
int main() {
int n;
scanf("%d", &n);
vector<pair<long long, pair<long long, long long> > > a;
long long x, y, r;
for (int i = 0; i < n; i++) {
scanf("%lld %lld %lld", &x, &y, &r);
a.push_back(make_pair(r, make_pair(x, y)));
}
long long deg[n];
memset(deg, 0, sizeof deg);
sort(a.begin(), a.end());
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if (dist(a[i].second, a[j].second) <= sqr(a[j].first) && i != j) deg[i]++;
double answer = 0.0;
for (int i = 0; i < n; i++) {
answer += (double)acos(-1) * a[i].first * a[i].first * func(deg[i]);
}
printf("%.20lf\n", answer);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.