input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
For given two segments s1 and s2, print the distance between them.
s1 is formed by end points p0 and p1, and s2 is formed by end points p2 and p3.
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xpi, ypi ≤ 10000
* p0 ≠ p1 and p2 ≠ p3.
Input
The entire input looks like:
q (the number of queries)
1st query
2nd query
...
qth query
Each query consists of integer coordinates of end points of s1 and s2 in the following format:
xp0 yp0 xp1 yp1 xp2 yp2 xp3 yp3
Output
For each query, print the distance. The output values should be in a decimal fraction with an error less than 0.00000001.
Example
Input
3
0 0 1 0 0 1 1 1
0 0 1 0 2 1 1 2
-1 0 1 0 0 1 0 -1
Output
1.0000000000
1.4142135624
0.0000000000
|
///
// File: cgl_2_d.cpp
// Author: ymiyamoto
//
// Created on Mon Oct 23 00:28:22 2017
//
#include <cmath>
#include <cstdint>
#include <iomanip>
#include <iostream>
using namespace std;
#define EPS 1e-10
#define equals(x, y) (fabs(x - y) < EPS)
struct vector_t {
double x;
double y;
vector_t(double a, double b) : x(a), y(b)
{
}
double norm2()
{
return x * x + y * y;
}
double norm()
{
return sqrt(norm2());
}
double dot(vector_t a)
{
return x * a.x + y * a.y;
}
double cross(vector_t a)
{
return x * a.y - y * a.x;
}
vector_t operator*(double a)
{
return vector_t(a * x, a * y);
}
};
struct point_t {
double x;
double y;
point_t operator+(const point_t a)
{
return point_t({x + a.x, y + a.y});
}
void print()
{
cout << fixed << setprecision(10) << x << " " << y << endl;
}
point_t operator+(const vector_t vec)
{
return point_t({x + vec.x, y + vec.y});
}
vector_t operator-(const point_t p)
{
return vector_t({x - p.x, y - p.y});
}
point_t project(point_t p1, point_t p2)
{
vector_t vec1(x - p1.x, y - p1.y);
vector_t vec2(p2.x - x, p2.y - y);
return point_t({x, y}) + vec1 * (vec1.dot(vec2) / vec1.norm2());
}
point_t reflect(point_t p1, point_t p2)
{
point_t proj = project(p1, p2);
return p2 + (proj - p2) * 2.0;
}
};
enum pos_t {
CCLOCKWISE = -1,
CLOCKWISE = 1,
ONLINE_BACK = 2,
ONLINE_FRONT = -2,
ON_SEGMENT = 0,
};
pos_t ccw(point_t p0, point_t p1, point_t p2)
{
if ((p1 - p0).cross(p2 - p0) > EPS) {
return CCLOCKWISE;
} else if ((p1 - p0).cross(p2 - p0) < -EPS) {
return CLOCKWISE;
} else if ((p1 - p0).dot(p2 - p0) < -EPS) {
return ONLINE_BACK;
} else {
if ((p1 - p0).norm2() < (p2 - p0).norm2()) {
return ONLINE_FRONT;
} else {
return ON_SEGMENT;
}
}
}
bool intersection(point_t p0, point_t p1, point_t p2, point_t p3)
{
return (ccw(p0, p1, p2) * ccw(p0, p1, p3) <= 0) && (ccw(p2, p3, p0) * ccw(p2, p3, p1) <= 0);
}
struct segment_t {
point_t a;
point_t b;
double distance(point_t p0)
{
if ((b - a).dot(p0 - a) < 0.0) {
return (p0 - a).norm();
} else if ((a - b).dot(p0 - b) < 0.0) {
return (p0 - b).norm();
} else {
return fabs((b - a).cross(p0 - a) / (b - a).norm());
}
}
};
int32_t main()
{
uint32_t q;
cin >> q;
for (uint32_t i = 0; i < q; i++) {
double x, y;
cin >> x >> y;
point_t p0({x, y});
cin >> x >> y;
point_t p1({x, y});
cin >> x >> y;
point_t p2({x, y});
cin >> x >> y;
point_t p3({x, y});
if (intersection(p0, p1, p2, p3)) {
cout << fixed << setprecision(10) << 0.0 << endl;
} else {
segment_t seg1({p0, p1});
segment_t seg2({p2, p3});
double dist = min(seg2.distance(p0), min(seg2.distance(p1), min(seg1.distance(p2), seg1.distance(p3))));
cout << fixed << setprecision(10) << dist << endl;
}
}
return 0;
}
|
Write a program which reads a sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and reverse specified elements by a list of the following operation:
* reverse($b, e$): reverse the order of $a_b, a_{b+1}, ..., a_{e-1}$
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b < e \leq n$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ...,\; a_{n-1}$
$q$
$b_1 \; e_1$
$b_2 \; e_2$
:
$b_{q} \; b_{q}$
In the first line, $n$ (the number of elements in $A$) is given. In the second line, $a_i$ (each element in $A$) are given. In the third line, the number of queries $q$ is given and each query is given by two integers $b_i \; e_i$ in the following $q$ lines.
Output
Print all elements of $A$ in a line after performing the given operations. Put a single space character between adjacency elements and a newline at the end of the last element.
Example
Input
8
1 2 3 4 5 6 7 8
2
1 6
3 8
Output
1 6 5 8 7 2 3 4
|
#include <iostream>
#include <cstring>
#include <vector>
#include <cstdio>
#include <stack>
#include<queue>
#include<list>
#include<algorithm>
int main()
{
int n,q,b,e;
std::cin>>n;
std::vector<int> S;
for(int i = 0; i < n; i++)
{
int hoge;
std::cin>>hoge;
S.push_back(hoge);
}
std::cin>>q;
for(int i = 0; i < q; i++)
{
std::cin>>b>>e;
reverse(S.begin()+b,S.begin()+e);
}
printf("%d",S[0]);
for(int i = 1; i < n; i++)
{
printf(" %d",S[i]);
}
printf("\n");
return 0;
}
|
The auditorium of Stanford University is made up of L*R matrix (assume each coordinate has a chair). On the occasion of an event Chef was called as a chief guest. The auditorium was filled with males (M) and females (F), occupying one chair each. Our Chef is very curious guy, so he asks the gatekeeper some queries. The queries were as follows: Is there any K*K sub-matrix in the auditorium which contains all Males or Females.
Input
The first line contains three space-separated integers L, R and Q describing the dimension of the auditorium and the number of questions Chef will ask.
Each of next L lines contains R characters (M or F).
Next Q lines contains K and a character (M or F).
Output
For each query output "yes" (without quotes) if there exist any K*K sub-matrix in the auditorium which contains all Males (if he asks about Male) or Females (if he asks about Female), otherwise output "no" (without quotes).
Constraints and Example
Input:
4 3 3
MMF
MMM
FFM
FFM
2 F
3 M
1 M
Output:
yes
no
yes
|
# cook your code here
n,m,t=map(int,raw_input().split())
a=[[0 for i in range(m)]for i in range(n)]
b=[[0 for i in range(m)]for i in range(n)]
q=[]
m_max=0
f_max=0
for i in range(n):
q.append(raw_input())
for j in range(m):
if i==0 or j==0:
if q[i][j]=='M':
a[i][j]=1
m_max=1
else:
b[i][j]=1
f_max=1
for i in range(1,n):
for j in range(1,m):
if q[i][j]=='M':
a[i][j]=min(min(a[i-1][j],a[i][j-1]),a[i-1][j-1])+1
else:
b[i][j]=min(min(b[i-1][j],b[i][j-1]),b[i-1][j-1])+1
m_max=max(m_max,a[i][j])
f_max=max(f_max,b[i][j])
for _ in range(t):
k,s=map(str,raw_input().split())
if(s=='M'):
if(int(k)>m_max):
print 'no'
else:
print 'yes'
else:
if(int(k)>f_max):
print 'no'
else:
print 'yes'
|
The Titanic ship is sinking. The nearest ship has answered the SOS call, and come to rescue the people. Everyone is anxious to get to safety. Unfortunately, the new ship may not have enough room to take everyone to safe land. This adds to the anxiety of people.
To avoid stampede, there has to be some rescue plan. You are made incharge of this. You have to make sure that as many people are safe as possible. Given the capacity of the ship, that is, the number of people that can board the ship, you have to calculate how many men, women and children can be sent to safety.
The following rules apply:
* The foremost priority is safety for children, but there must be atleast one adult (a man or a woman) for every four children sent to the rescue ship. For upto four children, one adult, for five to eight children, 2 adults, and so on.
* Next priority is for women, but there must be at least one man for every two women. For upto two women, one man, for three to four women, two men, and so on.
Input
First line contains the number of test cases (t less than 10000)
The next t lines contain four integers (each between 1 to 10000 inclusive) each separated by a single space.
The integers represent the capacity of the rescue ship, number of men on TITANIC, number of women and number of children, in this order.
Output
Display t lines, each line has three space separated integers denoting the number of men, women and children put to safety, in this order.
Example
Input:
3
17 5 10 19
18 2 6 10
20 5 2 23
Output:
2 2 13
2 4 10
2 2 16
Explanation:
Explanation for case 2: Since only 2 men are present, the number of women can not be more than 4.
|
#!/usr/bin/python
"Solve the Rescue problem at CodeChef"
def main():
testcases = int(raw_input())
for testcase in xrange(testcases):
capacity, men, women, children = map(int, raw_input().split())
max_women = min(women, (men << 1))
max_children = min((men + max_women) << 2, int(capacity * 0.8))
children_rescued = min(children, max_children)
adults_rescued = min(men + max_women, capacity - children_rescued)
women_rescued = min(max_women, int(adults_rescued * 0.66666667))
men_rescued = adults_rescued - women_rescued
print men_rescued, women_rescued, children_rescued
main()
|
Problem description.
Tima wants to contest for Mr. Ignus. But there are many obstacles which Tima must cross to become Mr. Ignus. Tima has qualified and passed all the tests and there remains a last test for him to complete successfully. The task is as follows :
There are n judges. The ith judge have A[i] coins with him. Now Tima has to collect maximum coins from all the judges by following rules :.
He can collect all the coins from any judge. If he collects coins from ith judge then he shouldn't have collected coins from the judge just before the current one.
Input
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test case contains a single integer N denoting the number of judges. The second line contains N space-separated integers, number of coins each judge has
Output
For each test case, output a single line containing maximum number of coins Tima can collect.
Constraints
Should contain all the constraints on the input data that you may have. Format it like:
1 ≤ T ≤ 10
0 ≤ N ≤ 100000
0 ≤ A[i] ≤ 1000000000
Example
Input:
2
5
1 2 3 4 5
1
10
Output:
9
10
Explanation
Example Case 1.He can collect 1st, 3rd and 5th coin to receive total of (1+3+5) 9 coins
|
t=int(raw_input())
for _ in range(t):
s=int(raw_input())
if s>0:
arr=map(int,raw_input().split())
dp=[0]*s
dp[0]=arr[0]
if s>1:
dp[1]=max(arr[0],arr[1])
if s>2:
for i in range(2,s):
dp[i]=max(dp[i-2]+arr[i], dp[i-1])
print dp[s-1]
else:
print 0
|
Problem description.
Jojo is so good at multiplying that she can multiply two 15-digits integers within 5 seconds. After practicing for years, she decided to approach the Limca Book of Records. As a jury member you are given the task to decide if she is eligible enough for holding the record. But before you test her, you should know the result of multiplication of numbers so that you can verify them with her answers.As an computer science literate, create a program that can calculate the multiplication of two numbers efficiently.
Input
Each sub-task contains just two integers A , B in two separate lines.
There will be a total of 10 sub-tasks.
Output
For each sub-task, output a single line containing the result of multiplication of both the integers.
Constraints
All the subtask contains different numbers.
1 ≤ A , B ≤ 10^15
Example
Input:
111111
111111
Output:
12345654321
Explanation
Self-explanatory.
|
print input() * input()
|
After IOI Ilya decided to make a business. He found a social network called "TheScorpyBook.com". It currently has N registered users. As in any social network two users can be friends. Ilya wants the world to be as connected as possible, so he wants to suggest friendship to some pairs of users. He will suggest user u to have a friendship with user v if they are not friends yet and there is a user w who is friends of both of them. Note that u, v and w are different users. Ilya is too busy with IPO these days, so he asks you to count how many friendship suggestions he has to send over his social network.
Input
The first line contains an integer number N — the number of users in the network. Next N lines contain N characters each denoting friendship relations. j^th character if the i^th lines equals one, if users i and j are friends and equals to zero otherwise. This relation is symmetric, i.e. if user a is friend of b then b is also a friend of a.
Output
Output a single integer — number of friendship suggestions Ilya has to send.
Constraints
1 ≤ N ≤ 2000
Example
Input:
4
0111
1000
1000
1000
Output:
6
Explanation
Each of users [2, 3, 4] should receive two friendship suggestions, while user 1 does not need any, since he already has all other users in his friend-list.
|
a = int (raw_input())
c= []
d= []
for i in range(a):
now = raw_input()
c.append(now)
d.append(int(now,2))
i=0
for k in xrange(a):
for j in xrange(k+1,a):
if c[k][j]!='1':
if int(d[k])&int(d[j]):
i= i+2
print i
|
After Chef successfully built a modern (L, K)-window on the attic wall he decided to expand the notion of the (L, K)-window in some other areas. Now he considers a rectangular grid that contains only zeroes and ones and has size N x M. He considers the (L, K)-window here as any submatrix of size L x K that contains only ones. Formally he defines (L, K)-window as any (K+L)-tuple (R1, ..., RL, C1, ..., CK) such that 1 <= R1 < ... < RL <= N, 1 <= C1 < ... < CK <= M and A[Ri][Cj]=1 for all 1 <= i <= L, 1<= j <= K. Here A[r][c] is the c-th element of the r-th row of considered rectangular grid.
Why does Chef call some (K+L)-tuple of numbers by the window? Just mark all points (Ri,Cj) (1 <= i <= L, 1<= j <= K) on the plane and join by line segments all pairs of points that has equal abscises or ordinates and you will see that this picture is like a window.
Now Chef considers some particular N x M grid and wants to calculate the total number of (L, K)-windows in this rectangular grid. Help him. Since this number can be very large calculate the result modulo 1000000080798150871.
Input
The first line contains a single positive integer T <= 100, the number of test cases. T test cases follow. The first line of each test case contains four positive integers N, M, L, K, where L, N <= 1000, K, M <=3. Next N lines describe the rectangular grid considered by Chef. Each of these lines contains M symbols. Every symbol is either one or zero.
Output
For each test case, output a single line containing the total number of (L, K)-windows for the given grid modulo 1000000080798150871.
Example
Input:
2
3 2 2 1
11
01
10
3 3 2 2
111
101
111
Output:
2
5
Explanation
In the first case it is just the number of pairs of cells with value 1 that have the same column number.
In the second case we have the following (2, 2)-windows:
(First row, Second row, First column, Third column)
(First row, Third row, First column, Second column)
(First row, Third row, First column, Third column)
(First row, Third row, Second column, Third column)
(Second row, Third row, First column, Third column)
|
#!/usr/bin/python
mainlis=[]
maxv=1000000080798150871
for i in range(0,1000,1):
mainlis.append([])
varlis=mainlis[i]
for j in range(0,3,1):
varlis.append(0)
test=input()
while test >0:
string=raw_input()
lis=string.split()
n=int(lis[0])
m=int(lis[1])
l=int(lis[2])
k=int(lis[3])
for i in range(0,n,1):
string=raw_input()
varlis=mainlis[i]
for j in range(0,m,1):
varlis[j]=int(string[j])
if m==1:
count=0
for i in range(0,n,1):
varlis=mainlis[i]
if varlis[0]==1:
count=count+1
ans=1
for i in range(0,l,1):
ans=(ans*(count-i))/(i+1)
elif m==2:
if k==2:
count=0
for i in range(0,n,1):
varlis=mainlis[i]
if varlis[0]==1 and varlis[1]==1:
count=count+1
ans=1
for i in range(0,l,1):
ans=(ans*(count-i))/(i+1)
elif k==1:
count1=0
count2=0
for i in range(0,n,1):
varlis=mainlis[i]
if varlis[0]==1:
count1=count1+1
if varlis[1]==1:
count2=count2+1
ans1=1
ans2=1
for i in range(0,l,1):
ans1=(ans1*(count1-i))/(i+1)
ans2=(ans2*(count2-i))/(i+1)
ans=ans1%maxv+ans2%maxv
elif m==3:
if k==3:
count=0
for i in range(0,n,1):
varlis=mainlis[i]
if varlis[0]==1 and varlis[1]==1 and varlis[2]==1:
count=count+1
ans=1
for i in range(0,l,1):
ans=(ans*(count-i))/(i+1)
elif k==1:
count1=0
count2=0
count3=0
for i in range(0,n,1):
varlis=mainlis[i]
if varlis[0]==1:
count1=count1+1
if varlis[1]==1:
count2=count2+1
if varlis[2]==1:
count3=count3+1
ans1=1
ans2=1
ans3=1
for i in range(0,l,1):
ans1=(ans1*(count1-i))/(i+1)
ans2=(ans2*(count2-i))/(i+1)
ans3=(ans3*(count3-i))/(i+1)
ans=ans1%maxv + ans2%maxv +ans3%maxv
elif k==2:
count1=0
count2=0
count3=0
for i in range(0,n,1):
varlis=mainlis[i]
if varlis[0]==1 and varlis[1]==1:
count1=count1+1
if varlis[0]==1 and varlis[2]==1:
count2=count2+1
if varlis[1]==1 and varlis[2]==1:
count3=count3+1
ans1=1
ans2=1
ans3=1
# print count1,count2,count3
for i in range(0,l,1):
ans1=(ans1*(count1-i))/(i+1)
ans2=(ans2*(count2-i))/(i+1)
ans3=(ans3*(count3-i))/(i+1)
ans=ans1%maxv + ans2%maxv + ans3%maxv
print ans%maxv
test=test-1
|
You are looking at the floor plan of the Summer Informatics School's new building. You were tasked with SIS logistics, so you really care about travel time between different locations: it is important to know how long it would take to get from the lecture room to the canteen, or from the gym to the server room.
The building consists of n towers, h floors each, where the towers are labeled from 1 to n, the floors are labeled from 1 to h. There is a passage between any two adjacent towers (two towers i and i + 1 for all i: 1 ≤ i ≤ n - 1) on every floor x, where a ≤ x ≤ b. It takes exactly one minute to walk between any two adjacent floors of a tower, as well as between any two adjacent towers, provided that there is a passage on that floor. It is not permitted to leave the building.
<image>
The picture illustrates the first example.
You have given k pairs of locations (ta, fa), (tb, fb): floor fa of tower ta and floor fb of tower tb. For each pair you need to determine the minimum walking time between these locations.
Input
The first line of the input contains following integers:
* n: the number of towers in the building (1 ≤ n ≤ 108),
* h: the number of floors in each tower (1 ≤ h ≤ 108),
* a and b: the lowest and highest floor where it's possible to move between adjacent towers (1 ≤ a ≤ b ≤ h),
* k: total number of queries (1 ≤ k ≤ 104).
Next k lines contain description of the queries. Each description consists of four integers ta, fa, tb, fb (1 ≤ ta, tb ≤ n, 1 ≤ fa, fb ≤ h). This corresponds to a query to find the minimum travel time between fa-th floor of the ta-th tower and fb-th floor of the tb-th tower.
Output
For each query print a single integer: the minimum walking time between the locations in minutes.
Example
Input
3 6 2 3 3
1 2 1 3
1 4 3 4
1 2 2 3
Output
1
4
2
|
t,f,lw,hw,q = map(int,input().split())
while(q):
t1,f1,t2,f2=map(int,input().split())
if(t1==t2):
print(abs(f1-f2))
else:
ans=abs(t1-t2)
if((f1>=lw and f1<=hw) or (f2>=lw and f2<=hw)):
ans+=abs(f1-f2)
print(ans)
elif(f1<lw and f2 <lw) :
ans+=(abs(lw-f1)+abs(lw-f2))
print(ans)
elif(f1>hw and f2>hw) :
ans+=(abs(hw-f1)+abs(hw-f2))
print(ans)
else:
if(f1>hw):
ans+=(abs(hw-f1)+abs(hw-f2))
else:
ans+=(abs(lw-f1)+abs(lw-f2))
print(ans)
q-=1
|
Acingel is a small town. There was only one doctor here — Miss Ada. She was very friendly and nobody has ever said something bad about her, so who could've expected that Ada will be found dead in her house? Mr Gawry, world-famous detective, is appointed to find the criminal. He asked m neighbours of Ada about clients who have visited her in that unlucky day. Let's number the clients from 1 to n. Each neighbour's testimony is a permutation of these numbers, which describes the order in which clients have been seen by the asked neighbour.
However, some facts are very suspicious – how it is that, according to some of given permutations, some client has been seen in the morning, while in others he has been seen in the evening? "In the morning some of neighbours must have been sleeping!" — thinks Gawry — "and in the evening there's been too dark to see somebody's face...". Now he wants to delete some prefix and some suffix (both prefix and suffix can be empty) in each permutation, so that they'll be non-empty and equal to each other after that — some of the potential criminals may disappear, but the testimony won't stand in contradiction to each other.
In how many ways he can do it? Two ways are called different if the remaining common part is different.
Input
The first line contains two integers n and m (1 ≤ n ≤ 100 000, 1 ≤ m ≤ 10) — the number of suspects and the number of asked neighbors.
Each of the next m lines contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n). It is guaranteed that these integers form a correct permutation (that is, each number from 1 to n appears exactly once).
Output
Output a single integer denoting the number of ways to delete some prefix and some suffix of each permutation (possibly empty), such that the remaining parts will be equal and non-empty.
Examples
Input
3 2
1 2 3
2 3 1
Output
4
Input
5 6
1 2 3 4 5
2 3 1 4 5
3 4 5 1 2
3 5 4 2 1
2 3 5 4 1
1 2 3 4 5
Output
5
Input
2 2
1 2
2 1
Output
2
Note
In the first example, all possible common parts are [1], [2], [3] and [2, 3].
In the second and third examples, you can only leave common parts of length 1.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
long long ret = 0;
vector<vector<int>> a(m);
int pos[100002][11];
for (int i = 0; i < m; i++) {
int aa;
for (int j = 0; j < n; j++) {
scanf("%d", &aa);
a[i].push_back(aa);
pos[aa][i] = j;
}
}
bool flag1 = false;
for (long long i = 0; i < n - 1; i++) {
bool flag = true;
long long k = i;
while (flag) {
int cu = a[0][k];
int ne = a[0][k + 1];
for (int j = 1; j < m; j++) {
if (pos[ne][j] - pos[cu][j] != 1) {
flag = false;
break;
}
}
if (!flag) break;
if (k + 1 == n - 1) flag1 = true;
k++;
if (k == n - 1) break;
}
ret += ((k - i + 2) * (k - i + 1)) / 2;
i = k;
}
if (!flag1) ret++;
cout << ret << endl;
return 0;
}
|
Vova's house is an array consisting of n elements (yeah, this is the first problem, I think, where someone lives in the array). There are heaters in some positions of the array. The i-th element of the array is 1 if there is a heater in the position i, otherwise the i-th element of the array is 0.
Each heater has a value r (r is the same for all heaters). This value means that the heater at the position pos can warm up all the elements in range [pos - r + 1; pos + r - 1].
Vova likes to walk through his house while he thinks, and he hates cold positions of his house. Vova wants to switch some of his heaters on in such a way that each element of his house will be warmed up by at least one heater.
Vova's target is to warm up the whole house (all the elements of the array), i.e. if n = 6, r = 2 and heaters are at positions 2 and 5, then Vova can warm up the whole house if he switches all the heaters in the house on (then the first 3 elements will be warmed up by the first heater and the last 3 elements will be warmed up by the second heater).
Initially, all the heaters are off.
But from the other hand, Vova didn't like to pay much for the electricity. So he wants to switch the minimum number of heaters on in such a way that each element of his house is warmed up by at least one heater.
Your task is to find this number of heaters or say that it is impossible to warm up the whole house.
Input
The first line of the input contains two integers n and r (1 ≤ n, r ≤ 1000) — the number of elements in the array and the value of heaters.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 1) — the Vova's house description.
Output
Print one integer — the minimum number of heaters needed to warm up the whole house or -1 if it is impossible to do it.
Examples
Input
6 2
0 1 1 0 0 1
Output
3
Input
5 3
1 0 0 0 1
Output
2
Input
5 10
0 0 0 0 0
Output
-1
Input
10 3
0 0 1 1 0 1 0 0 0 1
Output
3
Note
In the first example the heater at the position 2 warms up elements [1; 3], the heater at the position 3 warms up elements [2, 4] and the heater at the position 6 warms up elements [5; 6] so the answer is 3.
In the second example the heater at the position 1 warms up elements [1; 3] and the heater at the position 5 warms up elements [3; 5] so the answer is 2.
In the third example there are no heaters so the answer is -1.
In the fourth example the heater at the position 3 warms up elements [1; 5], the heater at the position 6 warms up elements [4; 8] and the heater at the position 10 warms up elements [8; 10] so the answer is 3.
|
//package Contest515div3;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class mainB {
public static Scanner enter = new Scanner(System.in);
public static PrintWriter out = new PrintWriter(System.out);
public static void main(String[] args) {
int n=enter.nextInt();
int r=enter.nextInt();
int[] mass=new int[n+1];
for (int i = 1; i <mass.length ; i++) {
mass[i]=enter.nextInt();
}
int last=1-r;
int ans=0;
int c=1;
while(true){
for (int i = Math.min(last+2*r-1,n); i >Math.max(last,0) ; i--) {
if(mass[i]==1){
ans++;
c=0;
last=i;
break;
}
}
if(c==1) {
out.println(-1);
out.close();
return;
}
c=1;
if(last+r>=n+1){
break;
}
}
out.println(ans);
out.close();
}
}
|
Alice is a big fan of volleyball and especially of the very strong "Team A".
Volleyball match consists of up to five sets. During each set teams score one point for winning a ball. The first four sets are played until one of the teams scores at least 25 points and the fifth set is played until one of the teams scores at least 15 points. Moreover, if one of the teams scores 25 (or 15 in the fifth set) points while the other team scores 24 (or 14 in the fifth set), the set is played until the absolute difference between teams' points becomes two. The match ends when one of the teams wins three sets. The match score is the number of sets won by each team.
Alice found a book containing all the results of all matches played by "Team A". The book is old, and some parts of the book became unreadable. Alice can not read the information on how many sets each of the teams won, she can not read the information on how many points each of the teams scored in each set, she even does not know the number of sets played in a match. The only information she has is the total number of points scored by each of the teams in all the sets during a single match.
Alice wonders what is the best match score "Team A" could achieve in each of the matches. The bigger is the difference between the number of sets won by "Team A" and their opponent, the better is the match score. Find the best match score or conclude that no match could end like that. If there is a solution, then find any possible score for each set that results in the best match score.
Input
The first line contains a single integer m (1 ≤ m ≤ 50 000) — the number of matches found by Alice in the book.
Each of the next m lines contains two integers a and b (0 ≤ a, b ≤ 200) — the number of points scored by "Team A" and the number of points scored by their opponents respectively.
Output
Output the solution for every match in the same order as they are given in the input. If the teams could not score a and b points respectively, output "Impossible".
Otherwise, output the match score formatted as "x:y", where x is the number of sets won by "Team A" and y is the number of sets won by their opponent.
The next line should contain the set scores in the order they were played. Each set score should be printed in the same format as the match score, with x being the number of points scored by "Team A" in this set, and y being the number of points scored by their opponent.
Example
Input
6
75 0
90 90
20 0
0 75
78 50
80 100
Output
3:0
25:0 25:0 25:0
3:1
25:22 25:22 15:25 25:21
Impossible
0:3
0:25 0:25 0:25
3:0
25:11 28:26 25:13
3:2
25:17 0:25 25:22 15:25 15:11
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
int ans[N][2];
void update(int w, int l, int L, int R, int a, int b) {
int st = 0;
for (int i = L; i <= R; i++) {
if (i < l)
st = 1;
else
st = 0;
int val = min(st == 1 ? a : b, ans[i][st] - 2);
ans[i][1 - st] = val;
if (st == 1)
a -= val;
else
b -= val;
}
}
int judge(int a, int b, int w, int l) {
if (w < l) {
swap(a, b);
swap(w, l);
}
int space_a = 0;
int space_b = 0;
for (int i = 0; i < l + w; i++) {
ans[i][0] = ans[i][1] = 0;
int st = (i < l) ? 1 : 0;
ans[i][st] = i == 4 ? 15 : 25;
if (st == 1) {
b -= ans[i][st];
space_a += ans[i][st] - 2;
} else {
a -= ans[i][st];
space_b += ans[i][st] - 2;
}
}
int min_a = 0, min_b = 0;
if (w) min_b = 23;
if (l) min_a = 23;
if (w + l == 5) min_b = 13;
if (a < 0 || b < 0) return 0;
if (space_a >= a && space_b >= b) {
update(w, l, 0, w + l - 1, a, b);
return 1;
} else if (min_a != 0 && a >= min_a && space_b >= b - min(b, (a - min_a)) &&
space_a - min_a >= (a - min_a) - min(b, a - min_a)) {
a -= min_a;
ans[0][0] = min_a;
int val = min(a, b);
ans[0][0] += val;
ans[0][1] += val;
a -= val;
b -= val;
update(w, l, 1, w + l - 1, a, b);
return 1;
} else if (min_b != 0 && b >= min_b && space_a >= a - min(a, (b - min_b)) &&
space_b - min_b >= (b - min_b) - min(a, (b - min_b))) {
b -= min_b;
ans[w + l - 1][1] = min_b;
int val = min(a, b);
ans[w + l - 1][0] += val;
ans[w + l - 1][1] += val;
a -= val;
b -= val;
update(w, l, 0, w + l - 2, a, b);
return 1;
}
return 0;
}
int main() {
int T;
int a, b;
scanf("%d", &T);
while (T-- > 0) {
int flag = 0;
scanf("%d%d", &a, &b);
for (int j = 3; j >= -3; j--) {
if (j == 0) continue;
int w, l;
if (j > 0)
w = 3, l = w - j;
else
l = 3, w = l + j;
if (judge(a, b, w, l)) {
printf("%d:%d\n", w, l);
for (int i = 0; i < w + l; i++) {
if (w < l) swap(ans[i][0], ans[i][1]);
printf("%d:%d", ans[i][0], ans[i][1]);
if (i == w + l - 1)
printf("\n");
else
printf(" ");
}
flag = 1;
break;
}
}
if (!flag) printf("Impossible\n");
}
return 0;
}
|
Vasya got really tired of these credits (from problem F) and now wants to earn the money himself! He decided to make a contest to gain a profit.
Vasya has n problems to choose from. They are numbered from 1 to n. The difficulty of the i-th problem is d_i. Moreover, the problems are given in the increasing order by their difficulties. The difficulties of all tasks are pairwise distinct. In order to add the i-th problem to the contest you need to pay c_i burles to its author. For each problem in the contest Vasya gets a burles.
In order to create a contest he needs to choose a consecutive subsegment of tasks.
So the total earnings for the contest are calculated as follows:
* if Vasya takes problem i to the contest, he needs to pay c_i to its author;
* for each problem in the contest Vasya gets a burles;
* let gap(l, r) = max_{l ≤ i < r} (d_{i + 1} - d_i)^2. If Vasya takes all the tasks with indices from l to r to the contest, he also needs to pay gap(l, r). If l = r then gap(l, r) = 0.
Calculate the maximum profit that Vasya can earn by taking a consecutive segment of tasks.
Input
The first line contains two integers n and a (1 ≤ n ≤ 3 ⋅ 10^5, 1 ≤ a ≤ 10^9) — the number of proposed tasks and the profit for a single problem, respectively.
Each of the next n lines contains two integers d_i and c_i (1 ≤ d_i, c_i ≤ 10^9, d_i < d_{i+1}).
Output
Print one integer — maximum amount of burles Vasya can earn.
Examples
Input
5 10
1 15
5 3
6 11
7 2
11 22
Output
13
Input
3 5
1 8
2 19
3 11
Output
0
|
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
inline void read(Tp &x) {
static char c;
static bool neg;
x = 0, c = getchar(), neg = false;
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
neg = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (neg) {
x = -x;
}
}
const int N = 3e5 + 5;
const int B = 19;
int n, a;
int d[N];
long long c[N];
namespace RMQ {
int log2[N];
long long bz[B][N];
inline void init() {
log2[1] = 0;
for (int i = 2; i < N; ++i) {
log2[i] = log2[i >> 1] + 1;
}
memcpy(bz[0] + 1, c + 1, sizeof(long long) * n);
for (int i = 1; i < B; ++i) {
for (int j = 0; j + (1 << (i - 1)) < N; ++j) {
bz[i][j] = std::min(bz[i - 1][j], bz[i - 1][j + (1 << (i - 1))]);
}
}
}
inline long long query(int l, int r) {
int lg = log2[r - l + 1];
l = std::max(l - 1, 0);
r = std::min(r - 1, n);
return std::min(bz[lg][l], bz[lg][r - (1 << lg) + 1]);
}
} // namespace RMQ
int main() {
read(n), read(a);
for (int i = 1; i <= n; ++i) {
read(d[i]), read(c[i]);
c[i] = a - c[i];
}
long long ans = std::max(0LL, *max_element(c + 1, c + n + 1));
for (int i = 1; i <= n; ++i) {
c[i] += c[i - 1];
}
RMQ::init();
stack<tuple<long long, int, long long>> sk;
multiset<long long> st;
for (int r = 2, l; r <= n; ++r) {
long long cur = (long long)(d[r] - d[r - 1]) * (d[r] - d[r - 1]);
while (!sk.empty() && get<0>(sk.top()) <= cur) {
st.erase(st.find(get<2>(sk.top())));
sk.pop();
}
l = sk.empty() ? 0 : get<1>(sk.top());
sk.emplace(cur, r, RMQ::query(l, r) + cur);
st.emplace(get<2>(sk.top()));
ans = std::max(ans, c[r] - *st.begin());
}
printf("%lld\n", ans);
return 0;
}
|
The new camp by widely-known over the country Spring Programming Camp is going to start soon. Hence, all the team of friendly curators and teachers started composing the camp's schedule. After some continuous discussion, they came up with a schedule s, which can be represented as a binary string, in which the i-th symbol is '1' if students will write the contest in the i-th day and '0' if they will have a day off.
At the last moment Gleb said that the camp will be the most productive if it runs with the schedule t (which can be described in the same format as schedule s). Since the number of days in the current may be different from number of days in schedule t, Gleb required that the camp's schedule must be altered so that the number of occurrences of t in it as a substring is maximum possible. At the same time, the number of contest days and days off shouldn't change, only their order may change.
Could you rearrange the schedule in the best possible way?
Input
The first line contains string s (1 ⩽ |s| ⩽ 500 000), denoting the current project of the camp's schedule.
The second line contains string t (1 ⩽ |t| ⩽ 500 000), denoting the optimal schedule according to Gleb.
Strings s and t contain characters '0' and '1' only.
Output
In the only line print the schedule having the largest number of substrings equal to t. Printed schedule should consist of characters '0' and '1' only and the number of zeros should be equal to the number of zeros in s and the number of ones should be equal to the number of ones in s.
In case there multiple optimal schedules, print any of them.
Examples
Input
101101
110
Output
110110
Input
10010110
100011
Output
01100011
Input
10
11100
Output
01
Note
In the first example there are two occurrences, one starting from first position and one starting from fourth position.
In the second example there is only one occurrence, which starts from third position. Note, that the answer is not unique. For example, if we move the first day (which is a day off) to the last position, the number of occurrences of t wouldn't change.
In the third example it's impossible to make even a single occurrence.
|
def findNeedSubstring(s):
n = len(s)
rst = ''
tmp = 0
for i in range(1, n-1, 1):
if(s[0:i] == s[n-i:n]):
rst = s[0:i] # this is the longest substring that prefix = suffix
tmp = i
return s[tmp: n]
def polyHash(s):
rst = [0] * (len(s) + 1)
hashValue = 0
for i in range(len(s)):
hashValue = (hashValue*alpha) % TABLE_SIZE + ( ord(s[i]) - ord('a') )
rst[i+1] = hashValue % TABLE_SIZE
return rst
def findNeedSubstringEnhance(f, t):
# print(f)
n = len(t)
i = n - 2
while(i >= 0):
if(f[i] ==( f[n] - ((( f[n-i ] )*power[i] ) % TABLE_SIZE) + TABLE_SIZE) % TABLE_SIZE) :
return t[i:n]
i = i -1
return t
def powArray():
rst = [1] * int(5e5+ 7)
# rst[0] = 1
for i in range(1, int(5e5+ 2), 1):
rst[i] = (rst[i-1] * alpha) % TABLE_SIZE
return rst
if __name__ == '__main__':
s = str(input())
t = str(input())
s0, s1 = 0, 0
t0 , t1 = 0, 0
ls, lt = len(s), len(t)
if(lt > ls):
print(s)
else:
for c in s:
if(c == '0'):
s0 += 1
else:
s1 += 1
for c in t:
if(c == '0'):
t0 += 1
else:
t1 += 1
if ((s0 and s1 and t0 and t1) == 0 or len(s) == len(t)):
if(s0 == t0 and s1 == t1):
print(t)
else:
print(s)
else:
alpha = 257
TABLE_SIZE =int( 1e9 + 7)
power = powArray()
# flag = findNeedSubstring(t)
f = polyHash(t)
flag = findNeedSubstringEnhance(f, t)
if(len(flag) != len(t)):
tmp = t
f0, f1 = 0,0
for c in flag:
# f0 += 1 if c =='0' else f1+= 1
if c == '0':
f0 += 1
else:
f1 += 1
k = min( (s0 - t0)// f0 , (s1 - t1)// f1 )
for i in range(k):
tmp += flag
for i in range( (s0 - t0) - k*f0 ):
tmp += '0'
for i in range( (s1 - t1) - k*f1 ):
tmp+= '1'
print(tmp)
else:
k = min( s0//t0 , s1//t1 )
tmp = ''
for i in range(k):
tmp += t
for i in range(s0 - k*t0):
tmp += '0'
for i in range(s1 - k*t1):
tmp += '1'
print(tmp)
|
You are given an array a consisting of n integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of a and multiply all values contained in this subarray by x. You want to maximize the beauty of array after applying at most one such operation.
Input
The first line contains two integers n and x (1 ≤ n ≤ 3 ⋅ 10^5, -100 ≤ x ≤ 100) — the length of array a and the integer x respectively.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the array a.
Output
Print one integer — the maximum possible beauty of array a after multiplying all values belonging to some consecutive subarray x.
Examples
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
Note
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be equal to 0.
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
const long long mod = 1e9 + 7;
long long modpow(long long a, long long e) {
if (e == 0) return 1;
long long x = modpow(a * a % mod, e >> 1);
return e & 1 ? x * a % mod : x;
}
int n;
long long dp[300005], a[300005], cep[300005], sag[300005], ans, mn, p[300005],
x;
int main() {
scanf("%d%lld", &n, &x);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
p[i] = p[i - 1] + a[i];
mn = min(mn, p[i]);
cep[i] = p[i] - mn;
ans = max(ans, cep[i]);
}
mn = 0;
for (int i = n; i >= 1; i--) {
p[i] = p[i + 1] + a[i];
mn = min(mn, p[i]);
sag[i] = p[i] - mn;
}
for (int i = 1; i <= n; i++) {
dp[i] = max(dp[i - 1] + (a[i] * x), a[i] * x + cep[i - 1]);
ans = max(ans, dp[i] + sag[i + 1]);
}
printf("%lld", ans);
}
|
Alice is the leader of the State Refactoring Party, and she is about to become the prime minister.
The elections have just taken place. There are n parties, numbered from 1 to n. The i-th party has received a_i seats in the parliament.
Alice's party has number 1. In order to become the prime minister, she needs to build a coalition, consisting of her party and possibly some other parties. There are two conditions she needs to fulfil:
* The total number of seats of all parties in the coalition must be a strict majority of all the seats, i.e. it must have strictly more than half of the seats. For example, if the parliament has 200 (or 201) seats, then the majority is 101 or more seats.
* Alice's party must have at least 2 times more seats than any other party in the coalition. For example, to invite a party with 50 seats, Alice's party must have at least 100 seats.
For example, if n=4 and a=[51, 25, 99, 25] (note that Alice'a party has 51 seats), then the following set [a_1=51, a_2=25, a_4=25] can create a coalition since both conditions will be satisfied. However, the following sets will not create a coalition:
* [a_2=25, a_3=99, a_4=25] since Alice's party is not there;
* [a_1=51, a_2=25] since coalition should have a strict majority;
* [a_1=51, a_2=25, a_3=99] since Alice's party should have at least 2 times more seats than any other party in the coalition.
Alice does not have to minimise the number of parties in a coalition. If she wants, she can invite as many parties as she wants (as long as the conditions are satisfied). If Alice's party has enough people to create a coalition on her own, she can invite no parties.
Note that Alice can either invite a party as a whole or not at all. It is not possible to invite only some of the deputies (seats) from another party. In other words, if Alice invites a party, she invites all its deputies.
Find and print any suitable coalition.
Input
The first line contains a single integer n (2 ≤ n ≤ 100) — the number of parties.
The second line contains n space separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100) — the number of seats the i-th party has.
Output
If no coalition satisfying both conditions is possible, output a single line with an integer 0.
Otherwise, suppose there are k (1 ≤ k ≤ n) parties in the coalition (Alice does not have to minimise the number of parties in a coalition), and their indices are c_1, c_2, ..., c_k (1 ≤ c_i ≤ n). Output two lines, first containing the integer k, and the second the space-separated indices c_1, c_2, ..., c_k.
You may print the parties in any order. Alice's party (number 1) must be on that list. If there are multiple solutions, you may print any of them.
Examples
Input
3
100 50 50
Output
2
1 2
Input
3
80 60 60
Output
0
Input
2
6 5
Output
1
1
Input
4
51 25 99 25
Output
3
1 2 4
Note
In the first example, Alice picks the second party. Note that she can also pick the third party or both of them. However, she cannot become prime minister without any of them, because 100 is not a strict majority out of 200.
In the second example, there is no way of building a majority, as both other parties are too large to become a coalition partner.
In the third example, Alice already has the majority.
The fourth example is described in the problem statement.
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
int n;
cin >> n;
int s = 0;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
}
v.push_back(0);
int sum = a[0];
for (int i = 1; i < n; i++) {
if (a[0] >= 2 * a[i]) {
sum += a[i];
v.push_back(i);
}
if (sum * 2 > s) break;
}
if (sum * 2 > s) {
cout << v.size() << "\n";
for (int i = 0; i < v.size(); i++) {
cout << v[i] + 1 << " ";
}
} else
cout << 0;
}
|
Alice and Bob have received three big piles of candies as a gift. Now they want to divide these candies as fair as possible. To do this, Alice takes one pile of candies, then Bob takes one of the other two piles. The last pile is split between Alice and Bob as they want: for example, it is possible that Alice takes the whole pile, and Bob gets nothing from it.
After taking the candies from the piles, if Alice has more candies than Bob, she discards some candies so that the number of candies she has is equal to the number of candies Bob has. Of course, Bob does the same if he has more candies.
Alice and Bob want to have as many candies as possible, and they plan the process of dividing candies accordingly. Please calculate the maximum number of candies Alice can have after this division process (of course, Bob will have the same number of candies).
You have to answer q independent queries.
Let's see the following example: [1, 3, 4]. Then Alice can choose the third pile, Bob can take the second pile, and then the only candy from the first pile goes to Bob — then Alice has 4 candies, and Bob has 4 candies.
Another example is [1, 10, 100]. Then Alice can choose the second pile, Bob can choose the first pile, and candies from the third pile can be divided in such a way that Bob takes 54 candies, and Alice takes 46 candies. Now Bob has 55 candies, and Alice has 56 candies, so she has to discard one candy — and after that, she has 55 candies too.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 1000) — the number of queries. Then q queries follow.
The only line of the query contains three integers a, b and c (1 ≤ a, b, c ≤ 10^{16}) — the number of candies in the first, second and third piles correspondingly.
Output
Print q lines. The i-th line should contain the answer for the i-th query — the maximum number of candies Alice can have after the division, if both Alice and Bob act optimally (of course, Bob will have the same number of candies).
Example
Input
4
1 3 4
1 10 100
10000000000000000 10000000000000000 10000000000000000
23 34 45
Output
4
55
15000000000000000
51
|
for z in range (int(input())):
a=list(map(int,input().split()))
print(sum(a)//2)
|
Polycarp is reading a book consisting of n pages numbered from 1 to n. Every time he finishes the page with the number divisible by m, he writes down the last digit of this page number. For example, if n=15 and m=5, pages divisible by m are 5, 10, 15. Their last digits are 5, 0, 5 correspondingly, their sum is 10.
Your task is to calculate the sum of all digits Polycarp has written down.
You have to answer q independent queries.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 1000) — the number of queries.
The following q lines contain queries, one per line. Each query is given as two integers n and m (1 ≤ n, m ≤ 10^{16}) — the number of pages in the book and required divisor, respectively.
Output
For each query print the answer for it — the sum of digits written down by Polycarp.
Example
Input
7
1 1
10 1
100 3
1024 14
998244353 1337
123 144
1234312817382646 13
Output
1
45
153
294
3359835
0
427262129093995
|
q = int(input())
for i in range(q):
n, m = input().split(" ")
n = int(n)
m = int(m)
if n == m:
print(m%10)
continue
inicial = m
aux = (m%10)
m += inicial
while (m%10) != (inicial%10) and m <= n:
aux += (m%10)
m += inicial
m = m-inicial
mult = int(n/m)
resultado = mult*aux
m = m*mult
m += inicial
while m <= n:
resultado += (m%10)
m += inicial
print(resultado)
|
Alice got a new doll these days. It can even walk!
Alice has built a maze for the doll and wants to test it. The maze is a grid with n rows and m columns. There are k obstacles, the i-th of them is on the cell (x_i, y_i), which means the cell in the intersection of the x_i-th row and the y_i-th column.
However, the doll is clumsy in some ways. It can only walk straight or turn right at most once in the same cell (including the start cell). It cannot get into a cell with an obstacle or get out of the maze.
More formally, there exist 4 directions, in which the doll can look:
1. The doll looks in the direction along the row from the first cell to the last. While moving looking in this direction the doll will move from the cell (x, y) into the cell (x, y + 1);
2. The doll looks in the direction along the column from the first cell to the last. While moving looking in this direction the doll will move from the cell (x, y) into the cell (x + 1, y);
3. The doll looks in the direction along the row from the last cell to first. While moving looking in this direction the doll will move from the cell (x, y) into the cell (x, y - 1);
4. The doll looks in the direction along the column from the last cell to the first. While moving looking in this direction the doll will move from the cell (x, y) into the cell (x - 1, y).
.
Standing in some cell the doll can move into the cell in the direction it looks or it can turn right once. Turning right once, the doll switches it's direction by the following rules: 1 → 2, 2 → 3, 3 → 4, 4 → 1. Standing in one cell, the doll can make at most one turn right.
Now Alice is controlling the doll's moves. She puts the doll in of the cell (1, 1) (the upper-left cell of the maze). Initially, the doll looks to the direction 1, so along the row from the first cell to the last. She wants to let the doll walk across all the cells without obstacles exactly once and end in any place. Can it be achieved?
Input
The first line contains three integers n, m and k, separated by spaces (1 ≤ n,m ≤ 10^5, 0 ≤ k ≤ 10^5) — the size of the maze and the number of obstacles.
Next k lines describes the obstacles, the i-th line contains two integer numbers x_i and y_i, separated by spaces (1 ≤ x_i ≤ n,1 ≤ y_i ≤ m), which describes the position of the i-th obstacle.
It is guaranteed that no two obstacles are in the same cell and no obstacle is in cell (1, 1).
Output
Print 'Yes' (without quotes) if the doll can walk across all the cells without obstacles exactly once by the rules, described in the statement.
If it is impossible to walk across the maze by these rules print 'No' (without quotes).
Examples
Input
3 3 2
2 2
2 1
Output
Yes
Input
3 3 2
3 1
2 2
Output
No
Input
3 3 8
1 2
1 3
2 1
2 2
2 3
3 1
3 2
3 3
Output
Yes
Note
Here is the picture of maze described in the first example:
<image>
In the first example, the doll can walk in this way:
* The doll is in the cell (1, 1), looks to the direction 1. Move straight;
* The doll is in the cell (1, 2), looks to the direction 1. Move straight;
* The doll is in the cell (1, 3), looks to the direction 1. Turn right;
* The doll is in the cell (1, 3), looks to the direction 2. Move straight;
* The doll is in the cell (2, 3), looks to the direction 2. Move straight;
* The doll is in the cell (3, 3), looks to the direction 2. Turn right;
* The doll is in the cell (3, 3), looks to the direction 3. Move straight;
* The doll is in the cell (3, 2), looks to the direction 3. Move straight;
* The doll is in the cell (3, 1), looks to the direction 3. The goal is achieved, all cells of the maze without obstacles passed exactly once.
|
#include <bits/stdc++.h>
using namespace std;
long long m, n, flag, x = 1, y = 1, k;
const int maxn = 1e5 + 5;
vector<long long> line[maxn];
vector<long long> col[maxn];
struct node {
int x, y;
} last;
bool fun(int x, int y) {
if (last.x == x && last.y == y) return true;
return false;
}
void run(long long ans) {
if (ans + k == n * m)
cout << "Yes\n";
else
cout << "No\n";
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
cin >> x >> y;
line[x].push_back(y);
col[y].push_back(x);
}
for (int i = 0; i < maxn; i++) sort(line[i].begin(), line[i].end());
for (int i = 0; i < maxn; i++) sort(col[i].begin(), col[i].end());
int a = 0, b = m + 1, c = 1, d = n + 1;
long long ans = 1;
x = 1, y = 1;
while (1) {
int i;
for (i = 0; i < line[x].size(); i++) {
if (line[x][i] > y && line[x][i] < b) {
if (line[x][i] - y == 1 && fun(x, y)) {
run(ans);
return 0;
}
ans += line[x][i] - y - 1;
y = line[x][i] - 1;
b = y;
last.x = x;
last.y = y;
break;
}
}
if (i == line[x].size()) {
if (y + 1 == b && fun(x, y)) {
run(ans);
return 0;
}
ans += b - y - 1;
y = --b;
last.x = x;
last.y = y;
}
for (i = 0; i < col[y].size(); i++) {
if (col[y][i] > x && col[y][i] < d) {
if (col[y][i] - x == 1 && fun(x, y)) {
run(ans);
return 0;
}
ans += col[y][i] - x - 1;
x = col[y][i] - 1;
d = x;
last.x = x;
last.y = y;
break;
}
}
if (i == col[y].size()) {
if (d - x == 1 && fun(x, y)) {
run(ans);
return 0;
}
ans += d - x - 1;
x = --d;
last.x = x;
last.y = y;
}
for (i = line[x].size() - 1; i >= 0; i--) {
if (line[x][i] < y && line[x][i] > a) {
if (y - line[x][i] == 1 && fun(x, y)) {
run(ans);
return 0;
}
ans += y - line[x][i] - 1;
y = line[x][i] + 1;
a = y;
last.x = x;
last.y = y;
break;
}
}
if (i == -1) {
if (y - a == 1 && fun(x, y)) {
run(ans);
return 0;
}
ans += y - a - 1;
y = ++a;
last.x = x;
last.y = y;
}
for (i = col[y].size() - 1; i >= 0; i--) {
if (col[y][i] < x && col[y][i] > c) {
if (x - col[y][i] == 1 && fun(x, y)) {
run(ans);
return 0;
}
ans += x - col[y][i] - 1;
x = col[y][i] + 1;
c = x;
last.x = x;
last.y = y;
break;
}
}
if (i == -1) {
if (x - c == 1 && fun(x, y)) {
run(ans);
return 0;
}
ans += x - c - 1;
x = ++c;
last.x = x;
last.y = y;
}
}
return 0;
}
|
This is the harder version of the problem. In this version, 1 ≤ n ≤ 10^6 and 0 ≤ a_i ≤ 10^6. You can hack this problem if you locked it. But you can hack the previous problem only if you locked both problems
Christmas is coming, and our protagonist, Bob, is preparing a spectacular present for his long-time best friend Alice. This year, he decides to prepare n boxes of chocolate, numbered from 1 to n. Initially, the i-th box contains a_i chocolate pieces.
Since Bob is a typical nice guy, he will not send Alice n empty boxes. In other words, at least one of a_1, a_2, …, a_n is positive. Since Alice dislikes coprime sets, she will be happy only if there exists some integer k > 1 such that the number of pieces in each box is divisible by k. Note that Alice won't mind if there exists some empty boxes.
Charlie, Alice's boyfriend, also is Bob's second best friend, so he decides to help Bob by rearranging the chocolate pieces. In one second, Charlie can pick up a piece in box i and put it into either box i-1 or box i+1 (if such boxes exist). Of course, he wants to help his friend as quickly as possible. Therefore, he asks you to calculate the minimum number of seconds he would need to make Alice happy.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the number of chocolate boxes.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^6) — the number of chocolate pieces in the i-th box.
It is guaranteed that at least one of a_1, a_2, …, a_n is positive.
Output
If there is no way for Charlie to make Alice happy, print -1.
Otherwise, print a single integer x — the minimum number of seconds for Charlie to help Bob make Alice happy.
Examples
Input
3
4 8 5
Output
9
Input
5
3 10 2 1 5
Output
2
Input
4
0 5 15 10
Output
0
Input
1
1
Output
-1
Note
In the first example, Charlie can move all chocolate pieces to the second box. Each box will be divisible by 17.
In the second example, Charlie can move a piece from box 2 to box 3 and a piece from box 4 to box 5. Each box will be divisible by 3.
In the third example, each box is already divisible by 5.
In the fourth example, since Charlie has no available move, he cannot help Bob make Alice happy.
|
/**
* @author derrick20
*/
import java.io.*;
import java.util.*;
public class SendBoxesToAlice {
public static void main(String args[]) throws Exception {
FastScanner sc = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
int N = sc.nextInt();
long[] arr = sc.nextLongs(N);
long sum = 0;
for (long v : arr) {
sum += v;
}
ArrayList<Long> factors = new ArrayList<>();
boolean[] visited = new boolean[(int) Math.sqrt(sum) + 1 + 1];
for (int i = 2; i < visited.length; i++) {
if (!visited[i] && sum % i == 0) {
visited[i] = true;
factors.add((long) i);
while (sum % i == 0) {
sum /= i;
}
for (int j = i + i; j < visited.length; j += i) {
visited[j] = true;
}
}
}
if (sum > 1) {
// the last one
factors.add(sum);
}
long min = (long) 1e18;
for (long factor : factors) {
min = Math.min(min, cost(arr, factor));
}
out.println(factors.size() >= 1 ? min : -1);
out.close();
}
static long cost(long[] arr, long mod) {
long delta = 0;
// Delta is carried over from previous people.
// The moment we can unload, we do so
long cost = 0;
for (long val : arr) {
long realVal = val % mod;
cost += Math.abs(delta);
// Immediately unload or absorb whatever what was needed
// previously
if (delta > 0) {
// We unload at most the amount we carry. However,
// we are limited by the remaining space
long unloaded = Math.min(delta, mod - realVal);
delta -= unloaded;
realVal += unloaded;
}
else if (delta < 0) {
// The delta scoops up at most the needed amount.
// It takes what it can from the available
long absorbed = Math.min(-delta, realVal);
delta += absorbed;
realVal -= absorbed;
}
// Now that that's done, the realVal might have tipped
// over the midpoint, so now, we need to create the delta
// for this person's need now
if (2 * realVal >= mod) {
long space = mod - realVal;
// If space > delta, then we now are deficit and
// must retrieve some from elsewhere
// Otherwise, then we will have spillover
delta -= space;
}
else if (2 * realVal < mod) {
delta += realVal; // need to carry this stuff out
}
}
return cost;
}
static class FastScanner {
public int BS = 1<<16;
public char NC = (char)0;
byte[] buf = new byte[BS];
int bId = 0, size = 0;
char c = NC;
double cnt = 1;
BufferedInputStream in;
public FastScanner() {
in = new BufferedInputStream(System.in, BS);
}
public FastScanner(String s) {
try {
in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
}
catch (Exception e) {
in = new BufferedInputStream(System.in, BS);
}
}
private char getChar(){
while(bId==size) {
try {
size = in.read(buf);
}catch(Exception e) {
return NC;
}
if(size==-1)return NC;
bId=0;
}
return (char)buf[bId++];
}
public int nextInt() {
return (int)nextLong();
}
public int[] nextInts(int N) {
int[] res = new int[N];
for (int i = 0; i < N; i++) {
res[i] = (int) nextLong();
}
return res;
}
public long[] nextLongs(int N) {
long[] res = new long[N];
for (int i = 0; i < N; i++) {
res[i] = nextLong();
}
return res;
}
public long nextLong() {
cnt=1;
boolean neg = false;
if(c==NC)c=getChar();
for(;(c<'0' || c>'9'); c = getChar()) {
if(c=='-')neg=true;
}
long res = 0;
for(; c>='0' && c <='9'; c=getChar()) {
res = (res<<3)+(res<<1)+c-'0';
cnt*=10;
}
return neg?-res:res;
}
public double nextDouble() {
double cur = nextLong();
return c!='.' ? cur:cur+nextLong()/cnt;
}
public String next() {
StringBuilder res = new StringBuilder();
while(c<=32)c=getChar();
while(c>32) {
res.append(c);
c=getChar();
}
return res.toString();
}
public String nextLine() {
StringBuilder res = new StringBuilder();
while(c<=32)c=getChar();
while(c!='\n') {
res.append(c);
c=getChar();
}
return res.toString();
}
public boolean hasNext() {
if(c>32)return true;
while(true) {
c=getChar();
if(c==NC)return false;
else if(c>32)return true;
}
}
}
}
|
You are given two integers a and b. You can perform a sequence of operations: during the first operation you choose one of these numbers and increase it by 1; during the second operation you choose one of these numbers and increase it by 2, and so on. You choose the number of these operations yourself.
For example, if a = 1 and b = 3, you can perform the following sequence of three operations:
1. add 1 to a, then a = 2 and b = 3;
2. add 2 to b, then a = 2 and b = 5;
3. add 3 to a, then a = 5 and b = 5.
Calculate the minimum number of operations required to make a and b equal.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of each test case contains two integers a and b (1 ≤ a, b ≤ 10^9).
Output
For each test case print one integer — the minimum numbers of operations required to make a and b equal.
Example
Input
3
1 3
11 11
30 20
Output
3
0
4
Note
First test case considered in the statement.
In the second test case integers a and b are already equal, so you don't need to perform any operations.
In the third test case you have to apply the first, the second, the third and the fourth operation to b (b turns into 20 + 1 + 2 + 3 + 4 = 30).
|
cum_sum = [0]*47000
cum_sum[1]=1
for i in range(2,47000):
cum_sum[i] = cum_sum[i-1]+i
n = int(input())
for i in range(n):
a,b = map(int,input().split())
delta = max(a,b) - min(a,b)
cnt = cum_sum.index([el for el in cum_sum if el <= delta][-1])
eq = a+b+cum_sum[cnt]
while (eq%2!=0 or eq//2 < max(a,b)):
cnt+=1
eq+=cnt
print(cnt)
|
You are given a string s consisting of lowercase Latin letters. Let the length of s be |s|. You may perform several operations on this string.
In one operation, you can choose some index i and remove the i-th character of s (s_i) if at least one of its adjacent characters is the previous letter in the Latin alphabet for s_i. For example, the previous letter for b is a, the previous letter for s is r, the letter a has no previous letters. Note that after each removal the length of the string decreases by one. So, the index i should satisfy the condition 1 ≤ i ≤ |s| during each operation.
For the character s_i adjacent characters are s_{i-1} and s_{i+1}. The first and the last characters of s both have only one adjacent character (unless |s| = 1).
Consider the following example. Let s= bacabcab.
1. During the first move, you can remove the first character s_1= b because s_2= a. Then the string becomes s= acabcab.
2. During the second move, you can remove the fifth character s_5= c because s_4= b. Then the string becomes s= acabab.
3. During the third move, you can remove the sixth character s_6='b' because s_5= a. Then the string becomes s= acaba.
4. During the fourth move, the only character you can remove is s_4= b, because s_3= a (or s_5= a). The string becomes s= acaa and you cannot do anything with it.
Your task is to find the maximum possible number of characters you can remove if you choose the sequence of operations optimally.
Input
The first line of the input contains one integer |s| (1 ≤ |s| ≤ 100) — the length of s.
The second line of the input contains one string s consisting of |s| lowercase Latin letters.
Output
Print one integer — the maximum possible number of characters you can remove if you choose the sequence of moves optimally.
Examples
Input
8
bacabcab
Output
4
Input
4
bcda
Output
3
Input
6
abbbbb
Output
5
Note
The first example is described in the problem statement. Note that the sequence of moves provided in the statement is not the only, but it can be shown that the maximum possible answer to this test is 4.
In the second example, you can remove all but one character of s. The only possible answer follows.
1. During the first move, remove the third character s_3= d, s becomes bca.
2. During the second move, remove the second character s_2= c, s becomes ba.
3. And during the third move, remove the first character s_1= b, s becomes a.
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int n, m, k;
string s;
bool check(const string& s, int j) {
return (j > 0 && s[j - 1] + 1 == s[j]) || (j < n - 1 && s[j + 1] + 1 == s[j]);
}
void solve() {
for (int i = 25; i >= 0; i--) {
for (int k = 0; k < n + 20; k++) {
for (int j = 0; j < n; j++) {
if (s[j] - 'a' == i && check(s, j)) {
s.erase(s.begin() + j);
}
}
}
}
cout << n - s.length();
}
void getData() { cin >> n >> s; }
void preprocessing() {}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
getData();
preprocessing();
solve();
}
return 0;
}
|
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of 7 segments, which can be turned on or off to display different numbers. The picture shows how all 10 decimal digits are displayed:
<image>
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly k segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly k sticks (which are off now)?
It is allowed that the number includes leading zeros.
Input
The first line contains integer n (1 ≤ n ≤ 2000) — the number of digits on scoreboard and k (0 ≤ k ≤ 2000) — the number of segments that stopped working.
The next n lines contain one binary string of length 7, the i-th of which encodes the i-th digit of the scoreboard.
Each digit on the scoreboard consists of 7 segments. We number them, as in the picture below, and let the i-th place of the binary string be 0 if the i-th stick is not glowing and 1 if it is glowing. Then a binary string of length 7 will specify which segments are glowing now.
<image>
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from 0 to 9 inclusive.
Output
Output a single number consisting of n digits — the maximum number that can be obtained if you turn on exactly k sticks or -1, if it is impossible to turn on exactly k sticks so that a correct number appears on the scoreboard digits.
Examples
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
Note
In the first test, we are obliged to include all 7 sticks and get one 8 digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For 5 of additionally included sticks, you can get the numbers 07, 18, 34, 43, 70, 79, 81 and 97, of which we choose the maximum — 97.
In the third test, it is impossible to turn on exactly 5 sticks so that a sequence of numbers appears on the scoreboard.
|
#include <bits/stdc++.h>
using namespace std;
long long mod2 = 1e9 + 7;
long long mod = 998244353;
const long long N = 2e3 + 12;
bool vis[2005][2005];
int n, k, a[10][2005];
string s[] = {"1110111", "0010010", "1011101", "1011011", "0111010",
"1101011", "1101111", "1010010", "1111111", "1111011"},
ans;
bool func(int idx, int cnt) {
if (cnt > k) return 0;
if (idx == n) return (cnt == k);
if (vis[idx][cnt]) return 0;
vis[idx][cnt] = 1;
for (int i = 9; i >= 0; i--) {
if (func(idx + 1, cnt + a[i][idx])) {
ans += i + '0';
return 1;
}
}
return 0;
}
void solve() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
string x;
cin >> x;
for (int j = 0; j < 10; j++) {
for (int l = 0; l < 7; l++) {
a[j][i] += (x[l] != s[j][l]);
if (x[l] == '1' && s[j][l] == '0') a[j][i] = 1e9;
}
}
}
if (func(0, 0)) {
reverse(ans.begin(), ans.end());
cout << ans;
} else
cout << "-1";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
|
Among Johnny's numerous hobbies, there are two seemingly harmless ones: applying bitwise operations and sneaking into his dad's office. As it is usually the case with small children, Johnny is unaware that combining these two activities can get him in a lot of trouble.
There is a set S containing very important numbers on his dad's desk. The minute Johnny heard about it, he decided that it's a good idea to choose a positive integer k and replace each element s of the set S with s ⊕ k (⊕ denotes the [exclusive or](https://en.wikipedia.org/wiki/Exclusive_or#Computer_science) operation).
Help him choose such k that Johnny's dad will not see any difference after his son is done playing (i.e. Johnny will get the same set as before playing). It is possible that no such number exists. It is also possible that there are many of them. In such a case, output the smallest one. Note that the order of elements in a set doesn't matter, i.e. set \{1, 2, 3\} equals to set \{2, 1, 3\}.
Formally, find the smallest positive integer k such that \\{s ⊕ k | s ∈ S\} = S or report that there is no such number.
For example, if S = \{1, 3, 4\} and k = 2, new set will be equal to \{3, 1, 6\}. If S = \{0, 1, 2, 3\} and k = 1, after playing set will stay the same.
Input
In the first line of input, there is a single integer t (1 ≤ t ≤ 1024), the number of test cases. In the next lines, t test cases follow. Each of them consists of two lines.
In the first line there is a single integer n (1 ≤ n ≤ 1024) denoting the number of elements in set S. Second line consists of n distinct integers s_i (0 ≤ s_i < 1024), elements of S.
It is guaranteed that the sum of n over all test cases will not exceed 1024.
Output
Print t lines; i-th line should contain the answer to the i-th test case, the minimal positive integer k satisfying the conditions or -1 if no such k exists.
Example
Input
6
4
1 0 2 3
6
10 7 14 8 3 12
2
0 2
3
1 2 3
6
1 4 6 10 11 12
2
0 1023
Output
1
4
2
-1
-1
1023
Note
In the first test case, the answer is 1 because it is a minimum positive integer and it satisfies all the conditions.
|
/**
* @author vivek
* programming is thinking, not typing
*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main {
private static void solveTC(int __) {
/* For Google */
// ans.append("Case #").append(__).append(": ");
//code start
int n = scn.nextInt();
int[] array = scn.nextIntArray(n);
for (int k = 1; k <= 1024; k++) {
if(check(array,k)){
print(k);
print("\n");
return;
}
}
print("-1");
//code end
print("\n");
}
public static boolean check(int[] array, int k) {
HashSet<Integer> s1=new HashSet<>();
for (int value : array) {
s1.add(value);
}
HashSet<Integer> s2=new HashSet<>();
for (int value : array) {
s2.add(value ^ k);
}
return s1.equals(s2);
}
public static void main(String[] args) {
// int limit= ;
// sieve(limit);
scn = new Scanner();
ans = new StringBuilder();
int t = scn.nextInt();
// int t = 1;
for (int i = 1; i <= t; i++) {
solveTC(i);
}
System.out.print(ans);
}
//Stuff for prime start
/**
* List containing prime numbers <br>
* <b>i<sup>th</sup></b> position contains <b>i<sup>th</sup></b> prime number <br>
* 0th index is <b>null</b>
*/
private static ArrayList<Integer> listOfPrimes;
/**
* query <b>i<sup>th</sup></b> element to get if its prime of not
*/
private static boolean[] isPrime;
/**
* Performs Sieve of Erathosnesis and initialise isPrime array and listOfPrimes list
*
* @param limit the number till which sieve is to be performed
*/
private static void sieve(int limit) {
listOfPrimes = new ArrayList<>();
listOfPrimes.add(null);
boolean[] array = new boolean[limit + 1];
Arrays.fill(array, true);
array[0] = false;
array[1] = false;
for (int i = 2; i <= limit; i++) {
if (array[i]) {
for (int j = i * i; j <= limit; j += i) {
array[j] = false;
}
}
}
isPrime = array;
for (int i = 0; i <= limit; i++) {
if (array[i]) {
listOfPrimes.add(i);
}
}
}
//stuff for prime end
/**
* Calculates the Least Common Multiple of two numbers
*
* @param a First number
* @param b Second Number
* @return Least Common Multiple of <b>a</b> and <b>b</b>
*/
private static long lcm(long a, long b) {
return a * b / gcd(a, b);
}
/**
* Calculates the Greatest Common Divisor of two numbers
*
* @param a First number
* @param b Second Number
* @return Greatest Common Divisor of <b>a</b> and <b>b</b>
*/
private static long gcd(long a, long b) {
return (b == 0) ? a : gcd(b, a % b);
}
static void print(Object obj) {
ans.append(obj.toString());
}
static Scanner scn;
static StringBuilder ans;
//Fast Scanner
static class Scanner {
BufferedReader br;
StringTokenizer st;
public Scanner() {
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
int[] nextIntArray(int n) {
int[] array = new int[n];
for (int i = 0; i < n; i++) {
array[i] = nextInt();
}
return array;
}
Integer[] nextIntegerArray(int n) {
Integer[] array = new Integer[n];
for (int i = 0; i < n; i++) {
array[i] = nextInt();
}
return array;
}
long[] nextLongArray(int n) {
long[] array = new long[n];
for (int i = 0; i < n; i++) {
array[i] = nextLong();
}
return array;
}
String[] nextStringArray() {
return nextLine().split(" ");
}
String[] nextStringArray(int n) {
String[] array = new String[n];
for (int i = 0; i < n; i++) {
array[i] = next();
}
return array;
}
}
}
|
This is the hard version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 2n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output an integer k (0≤ k≤ 2n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
|
t=int(input())
for _ in range(t):
n=int(input())
arr=list(input().rstrip("\n"))
arr1=list(input().rstrip("\n"))
arr=[int(x) for x in arr]
arr1=[int(x) for x in arr1]
#print(arr,n)
result=[]
if arr == arr1:
print(0)
else:
if n == 1:
print("1 1")
continue
prev=arr[0]
for i in range(1,n):
#print(arr,n)
if prev != arr[i]:
result.append(i)
prev=arr[i]
if arr[-1] == 1:
last=1
else:
last=0
for i in range(n-1,-1,-1):
if arr1[i]!= last:
result.append(i+1)
if last == 0:
last=1
else:
last=0
print(len(result),end=" ")
print(*result)
|
Mr. Chanek just won the national chess tournament and got a huge chessboard of size N × M. Bored with playing conventional chess, Mr. Chanek now defines a function F(X, Y), which denotes the minimum number of moves to move a knight from square (1, 1) to square (X, Y). It turns out finding F(X, Y) is too simple, so Mr. Chanek defines:
G(X, Y) = ∑_{i=X}^{N} ∑_{j=Y}^{M} F(i, j)
Given X and Y, you are tasked to find G(X, Y).
A knight can move from square (a, b) to square (a', b') if and only if |a - a'| > 0, |b - b'| > 0, and |a - a'| + |b - b'| = 3. Of course, the knight cannot leave the chessboard.
Input
The first line contains an integer T (1 ≤ T ≤ 100), the number of test cases.
Each test case contains a line with four integers X Y N M (3 ≤ X ≤ N ≤ 10^9, 3 ≤ Y ≤ M ≤ 10^9).
Output
For each test case, print a line with the value of G(X, Y) modulo 10^9 + 7.
Example
Input
2
3 4 5 6
5 5 8 8
Output
27
70
|
#include <bits/stdc++.h>
using namespace std;
namespace modular {
const int mod = 1000000007;
inline int add(int x, int y) { return x + y >= mod ? x + y - mod : x + y; }
inline int dec(int x, int y) { return x - y < 0 ? x - y + mod : x - y; }
inline int mul(int x, int y) { return 1ll * x * y % mod; }
} // namespace modular
using namespace modular;
inline int poww(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = mul(ans, a);
a = mul(a, a);
b >>= 1;
}
return ans;
}
const int inv2 = poww(2, mod - 2);
const int inv3 = poww(3, mod - 2);
inline int read() {
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();
}
return x * f;
}
int T;
int f(int a, int b, int c, int n) {
return add(add(mul(a, mul(n, n)), mul(b, n)), c);
}
int s(int n) { return (n / 3) + (n % 3); }
int t(int n) {
int nn = n / 3;
int res = f(mul(3, inv2), mul(5, inv2), 0, nn);
for (int i = nn * 3 + 1; i <= n; i++) res = add(res, s(i));
return res;
}
int a(int n) {
int nn = n / 3;
int res = mul(nn, f(mul(3, inv2), mul(9, inv2), 2, nn));
for (int i = nn * 3 + 1; i <= n; i++) res = add(res, t(i));
return res;
}
int b(int n) { return mul(n, f(inv2, 2, mul(3, inv2), n)); }
int c(int n) {
int nn = n / 2;
int res = mul(nn, f(1, mul(5, inv2), inv2, nn));
if (n & 1) res = add(res, t((3ll * n - 1) / 2));
return res;
}
int C1(int X, int Y) {
X = min(X, 2 * Y), Y = min(Y, 2 * X);
int mid = Y / 2;
if (mid < 3) mid = 2;
if (mid > X) mid = X;
return dec(add(dec(b(mid), b(2)), dec(a(X + Y), a(mid + Y))),
dec(c(X), c(2)));
}
int S1(int n) {
int opt = n % 4;
if (!opt) return mul(f(1, mod - 3, mod - 4, n), mul(inv2, inv2));
if (opt == 1) return mul(f(1, mod - 1, mod - 8, n), mul(inv2, inv2));
if (opt == 2) return mul(f(1, mod - 3, mod - 2, n), mul(inv2, inv2));
return mul(f(1, mod - 1, mod - 6, n), mul(inv2, inv2));
}
int d(int n) {
int nn = n / 4;
int res = mul(nn, f(mul(16, inv3), mod - 2, dec(0, mul(19, inv3)), nn));
for (int i = nn * 4 + 1; i <= n; i++) res = add(res, S1(i));
return res;
}
int up(int x) { return (x + 1) / 2; }
int S2(int n, int Y) {
int opt = n % 4;
if (!opt) return dec(add(mul(n / 2, Y - 1), (Y + 1) / 2), 1);
if (opt == 1) return dec(add(mul((n + 1) / 2, Y - 1), (Y + 1) / 2), 1);
if (opt == 2) return add(mul(n / 2, Y - 1), Y / 2);
return add(mul((n + 1) / 2, Y - 1), Y / 2);
}
int e(int n, int Y) {
int nn = n / 4;
int res = mul(dec(mul(4, Y), 4), add(mul(nn, nn), nn));
for (int i = nn * 4 + 1; i <= n; i++) res = add(res, S2(i, Y));
return res;
}
int C2(int X, int Y) {
if (2 * Y + 2 >= X) return dec(d(X), d(4));
return add(dec(d(2 * Y + 2), d(4)), dec(e(X, Y), e(2 * Y + 2, Y)));
}
int P(int X, int Y) {
if (X < 2 || Y < 2) return 0;
int ans = 0;
for (int i = 2; i <= min(4, Y); i++) ans += 6 - i;
ans = add(ans, C1(X, Y));
ans = add(ans, C2(X, Y));
ans = add(ans, C2(Y, X));
return ans;
}
int main() {
T = read();
while (T--) {
int x = read() - 1, y = read() - 1, n = read() - 1, m = read() - 1;
printf("%d\n",
dec(add(P(n, m), P(x - 1, y - 1)), add(P(x - 1, m), P(n, y - 1))));
}
return 0;
}
|
There are n bags with candies, initially the i-th bag contains i candies. You want all the bags to contain an equal amount of candies in the end.
To achieve this, you will:
* Choose m such that 1 ≤ m ≤ 1000
* Perform m operations. In the j-th operation, you will pick one bag and add j candies to all bags apart from the chosen one.
Your goal is to find a valid sequence of operations after which all the bags will contain an equal amount of candies.
* It can be proved that for the given constraints such a sequence always exists.
* You don't have to minimize m.
* If there are several valid sequences, you can output any.
Input
Each test contains multiple test cases.
The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first and only line of each test case contains one integer n (2 ≤ n≤ 100).
Output
For each testcase, print two lines with your answer.
In the first line print m (1≤ m ≤ 1000) — the number of operations you want to take.
In the second line print m positive integers a_1, a_2, ..., a_m (1 ≤ a_i ≤ n), where a_j is the number of bag you chose on the j-th operation.
Example
Input
2
2
3
Output
1
2
5
3 3 3 1 2
Note
In the first case, adding 1 candy to all bags except of the second one leads to the arrangement with [2, 2] candies.
In the second case, firstly you use first three operations to add 1+2+3=6 candies in total to each bag except of the third one, which gives you [7, 8, 3]. Later, you add 4 candies to second and third bag, so you have [7, 12, 7], and 5 candies to first and third bag — and the result is [12, 12, 12].
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.sql.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeSet;
import java.util.Vector;
public class codechef3 {
static class FastReader
{BufferedReader br;
StringTokenizer st;
public FastReader()
{ br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
public static void main(String[] args)
{
FastReader s=new FastReader();
int t=s.nextInt();
while(t-->0)
{
int n=s.nextInt();
System.out.println(n);
for(int i=1;i<=n;i++)
System.out.print(i+" ");
System.out.println();
}
}
}
|
You have given an array a of length n and an integer x to a brand new robot. What the robot does is the following: it iterates over the elements of the array, let the current element be q. If q is divisible by x, the robot adds x copies of the integer q/x to the end of the array, and moves on to the next element. Note that the newly added elements could be processed by the robot later. Otherwise, if q is not divisible by x, the robot shuts down.
Please determine the sum of all values of the array at the end of the process.
Input
The first input line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5, 2 ≤ x ≤ 10^9) — the length of the array and the value which is used by the robot.
The next line contains integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the initial values in the array.
It is guaranteed that the sum of values n over all test cases does not exceed 10^5.
Output
For each test case output one integer — the sum of all elements at the end of the process.
Example
Input
2
1 2
12
4 2
4 6 8 2
Output
36
44
Note
In the first test case the array initially consists of a single element [12], and x=2. After the robot processes the first element, the array becomes [12, 6, 6]. Then the robot processes the second element, and the array becomes [12, 6, 6, 3, 3]. After the robot processes the next element, the array becomes [12, 6, 6, 3, 3, 3, 3], and then the robot shuts down, since it encounters an element that is not divisible by x = 2. The sum of the elements in the resulting array is equal to 36.
In the second test case the array initially contains integers [4, 6, 8, 2], and x=2. The resulting array in this case looks like [4, 6, 8, 2, 2, 2, 3, 3, 4, 4, 1, 1, 1, 1, 1, 1].
|
import java.io.*;
import java.util.StringTokenizer;
public class A_StrangeList {
private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
private static final PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
private static StringTokenizer st;
private static int readInt() throws IOException {
while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
return Integer.parseInt(st.nextToken());
}
public static void main(String[] args) throws IOException {
int T = readInt();
while (T-- > 0) {
int n = readInt();
int x = readInt();
int minExp = 100;
long pSum = 0;
long extraSum = 0;
for (int i = 0; i < n; i++) {
int a = readInt();
int e = divCount(a, x);
if (e < minExp) {
extraSum = pSum;
minExp = e;
}
pSum += a;
}
pw.println(pSum * (minExp + 1) + extraSum);
}
pw.close();
}
private static int divCount(int i, int x) {
int e = 0;
while (i > 0 && i % x == 0) {
e++;
i /= x;
}
return e;
}
}
|
You are given n rectangles, each of height 1. Each rectangle's width is a power of 2 (i. e. it can be represented as 2^x for some non-negative integer x).
You are also given a two-dimensional box of width W. Note that W may or may not be a power of 2. Moreover, W is at least as large as the width of the largest rectangle.
You have to find the smallest height of this box, such that it is able to fit all the given rectangles. It is allowed to have some empty space left in this box after fitting all the rectangles.
You cannot rotate the given rectangles to make them fit into the box. Moreover, any two distinct rectangles must not overlap, i. e., any two distinct rectangles must have zero intersection area.
See notes for visual explanation of sample input.
Input
The first line of input contains one integer t (1 ≤ t ≤ 5 ⋅ 10^3) — the number of test cases. Each test case consists of two lines.
For each test case:
* the first line contains two integers n (1 ≤ n ≤ 10^5) and W (1 ≤ W ≤ 10^9);
* the second line contains n integers w_1, w_2, ..., w_n (1 ≤ w_i ≤ 10^6), where w_i is the width of the i-th rectangle. Each w_i is a power of 2;
* additionally, max_{i=1}^{n} w_i ≤ W.
The sum of n over all test cases does not exceed 10^5.
Output
Output t integers. The i-th integer should be equal to the answer to the i-th test case — the smallest height of the box.
Example
Input
2
5 16
1 2 8 4 8
6 10
2 8 8 2 2 8
Output
2
3
Note
For the first test case in the sample input, the following figure shows one way to fit the given five rectangles into the 2D box with minimum height:
<image>
In the figure above, the number inside each rectangle is its width. The width of the 2D box is 16 (indicated with arrow below). The minimum height required for the 2D box in this case is 2 (indicated on the left).
In the second test case, you can have a minimum height of three by keeping two blocks (one each of widths eight and two) on each of the three levels.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long t;
cin>>t;
while(t--){
long n,w;
cin>>n>>w;
long tmp;
long count[20]={0};
for(long i=0;i<n;i++){
cin>>tmp;
count[long(log2(tmp))]++;
}
// for(long i=19;i>=0;i--)
// cout<<count[i]<<" ";
long space_left=w,largest=-1;
long height=1;
for(long i=0;i<n;i++){
for(long i=19;i>=0;i--){
if(count[i] && space_left>=(1<<i)){
largest=i;
break;
}
}
// cout<<largest<<" ";
if(largest==-1){
height++;
space_left=w;
for(long i=19;i>=0;i--){
if(count[i]>0 && space_left>=(1<<i)){
largest=i;
break;
}
}
}
count[largest]-=1;
space_left-=(1<<largest);
// cout<<space_left<<" ";
largest=-1;
}
cout<<height<<endl;
}
return 0;
}
|
Polycarp has 26 tasks. Each task is designated by a capital letter of the Latin alphabet.
The teacher asked Polycarp to solve tasks in the following way: if Polycarp began to solve some task, then he must solve it to the end, without being distracted by another task. After switching to another task, Polycarp cannot return to the previous task.
Polycarp can only solve one task during the day. Every day he wrote down what task he solved. Now the teacher wants to know if Polycarp followed his advice.
For example, if Polycarp solved tasks in the following order: "DDBBCCCBBEZ", then the teacher will see that on the third day Polycarp began to solve the task 'B', then on the fifth day he got distracted and began to solve the task 'C', on the eighth day Polycarp returned to the task 'B'. Other examples of when the teacher is suspicious: "BAB", "AABBCCDDEEBZZ" and "AAAAZAAAAA".
If Polycarp solved the tasks as follows: "FFGZZZY", then the teacher cannot have any suspicions. Please note that Polycarp is not obligated to solve all tasks. Other examples of when the teacher doesn't have any suspicious: "BA", "AFFFCC" and "YYYYY".
Help Polycarp find out if his teacher might be suspicious.
Input
The first line contains an integer t (1 ≤ t ≤ 1000). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 50) — the number of days during which Polycarp solved tasks.
The second line contains a string of length n, consisting of uppercase Latin letters, which is the order in which Polycarp solved the tasks.
Output
For each test case output:
* "YES", if the teacher cannot be suspicious;
* "NO", otherwise.
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as positive answer).
Example
Input
5
3
ABA
11
DDBBCCCBBEZ
7
FFGZZZY
1
Z
2
AB
Output
NO
NO
YES
YES
YES
|
#include <bits/stdc++.h>
#include <string>
using namespace std;
bool susp() {
int n;
cin >> n;
string days;
cin >> days;
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
if (days[j] == days[i] && days[j - 1] != days[i])
return false;
}
}
return true;
}
int main()
{
int t;
cin >> t;
bool cases[t];
for (int i = 0; i < t; i++) {
cases[i] = susp();
}
for (bool b : cases) {
if (b)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
|
You are given an array of positive integers a = [a_0, a_1, ..., a_{n - 1}] (n ≥ 2).
In one step, the array a is replaced with another array of length n, in which each element is the [greatest common divisor (GCD)](http://tiny.cc/tuy9uz) of two neighboring elements (the element itself and its right neighbor; consider that the right neighbor of the (n - 1)-th element is the 0-th element).
Formally speaking, a new array b = [b_0, b_1, ..., b_{n - 1}] is being built from array a = [a_0, a_1, ..., a_{n - 1}] such that b_i = \gcd(a_i, a_{(i + 1) mod n}), where \gcd(x, y) is the greatest common divisor of x and y, and x mod y is the remainder of x dividing by y. In one step the array b is built and then the array a is replaced with b (that is, the assignment a := b is taking place).
For example, if a = [16, 24, 10, 5] then b = [\gcd(16, 24), \gcd(24, 10), \gcd(10, 5), \gcd(5, 16)] = [8, 2, 5, 1]. Thus, after one step the array a = [16, 24, 10, 5] will be equal to [8, 2, 5, 1].
For a given array a, find the minimum number of steps after which all values a_i become equal (that is, a_0 = a_1 = ... = a_{n - 1}). If the original array a consists of identical elements then consider the number of steps is equal to 0.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case contains two lines. The first line contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — length of the sequence a. The second line contains n integers a_0, a_1, ..., a_{n - 1} (1 ≤ a_i ≤ 10^6).
It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
Print t numbers — answers for each test case.
Example
Input
5
4
16 24 10 5
4
42 42 42 42
3
4 6 4
5
1 2 3 4 5
6
9 9 27 9 9 63
Output
3
0
2
1
1
|
import java.util.*;
import java.io.*;
import java.math.*;
/**
* @author Naitik
*
*/
public class Main
{
static FastReader sc=new FastReader();
static long dp[][];
static int mod=1000000007;
static int max;
static long bit[];
static long seg[];
static long A[];
static PrintWriter out=new PrintWriter(System.out);
public static void main(String[] args)
{
//CHECK FOR N=1
//CHECK FOR N=1
//StringBuffer sb=new StringBuffer("");
int ttt=1;
ttt =i();
outer :while (ttt-- > 0)
{
int n=i();
A=new long[n+1];
for(int i=1;i<=n;i++) {
A[i]=i();
}
seg=new long[4*n+1];
build(1, 1, n);
int l=0;
int u=n;
long gcd=0;
for(long i : A) {
gcd=gcd(gcd,i);
}
int ans=-1;
while(l<=u) {
int mid=(l+u)/2;
if(go(mid, gcd, n)) {
ans=mid;
u=mid-1;
}
else {
l=mid+1;
}
}
System.out.println(ans);
}
//System.out.println(sb.toString());
out.close();
//CHECK FOR N=1 //CHECK FOR M=0
//CHECK FOR N=1 //CHECK FOR M=0
//CHECK FOR N=1
}
static boolean go(int k,long gcd,int n) {
for(int i=1;i<=n;i++) {
if(i+k<=n) {
long gc=query(1, 1, n, i, i+k);
if(gc!=gcd)
return false;
}
else {
long a=query(1, 1, n, i, n);
int y=n-i+1;
y=k+1-y;
long b=query(1, 1, n, 1, y);
if(gcd(a,b)!=gcd)
return false;
}
}
return true;
}
static void build(int si , int ss , int se)
{
if(ss == se)
{
seg[si] = A[ss];
return ;
}
int mid = (ss + se) / 2;
build(2*si , ss , mid);
build(2*si+1 ,mid+1 , se);
seg[si] = gcd(seg[2*si] , seg[2*si+1]);
}
static long query(int si , int ss , int se , int qs , int qe)
{
if(ss > qe || se < qs) return 0;
if(ss >= qs && se <= qe) return seg[si];
int mid = (ss + se) / 2;
return gcd(query(2*si , ss , mid , qs , qe) , query(2*si+1 , mid+1 , se , qs , qe));
}
static class Pair implements Comparable<Pair>
{
int x;
int y;
Pair(int x,int y,int z){
this.x=x;
this.y=y;
}
@Override
public int compareTo(Pair o) {
if(this.x>o.x)
return 1;
else if(this.x<o.x)
return -1;
else {
if(this.y>o.y)
return 1;
else if(this.y<o.y)
return -1;
else
return 0;
}
}
// public int hashCode()
// {
// final int temp = 14;
// int ans = 1;
// ans =x*31+y*13;
// return ans;
// }
// @Override
// public boolean equals(Object o)
// {
// if (this == o) {
// return true;
// }
// if (o == null) {
// return false;
// }
// if (this.getClass() != o.getClass()) {
// return false;
// }
// Pair other = (Pair)o;
// if (this.x != other.x || this.y!=other.y) {
// return false;
// }
// return true;
// }
//
/* FOR TREE MAP PAIR USE */
// public int compareTo(Pair o) {
// if (x > o.x) {
// return 1;
// }
// if (x < o.x) {
// return -1;
// }
// if (y > o.y) {
// return 1;
// }
// if (y < o.y) {
// return -1;
// }
// return 0;
// }
}
//FENWICK TREE
static void update(int i, int x){
for(; i < bit.length; i += (i&-i))
bit[i] += x;
}
static int sum(int i){
int ans = 0;
for(; i > 0; i -= (i&-i))
ans += bit[i];
return ans;
}
//END
//static void add(int v) {
// if(!map.containsKey(v)) {
// map.put(v, 1);
// }
// else {
// map.put(v, map.get(v)+1);
// }
//}
//static void remove(int v) {
// if(map.containsKey(v)) {
// map.put(v, map.get(v)-1);
// if(map.get(v)==0)
// map.remove(v);
// }
//}
public static int upper(int A[],int k,int si,int ei)
{
int l=si;
int u=ei;
int ans=-1;
while(l<=u) {
int mid=(l+u)/2;
if(A[mid]<=k) {
ans=mid;
l=mid+1;
}
else {
u=mid-1;
}
}
return ans;
}
public static int lower(int A[],int k,int si,int ei)
{
int l=si;
int u=ei;
int ans=-1;
while(l<=u) {
int mid=(l+u)/2;
if(A[mid]<k) {
l=mid+1;
}
else {
ans=mid;
u=mid-1;
}
}
return ans;
}
static int[] copy(int A[]) {
int B[]=new int[A.length];
for(int i=0;i<A.length;i++) {
B[i]=A[i];
}
return B;
}
static long[] copy(long A[]) {
long B[]=new long[A.length];
for(int i=0;i<A.length;i++) {
B[i]=A[i];
}
return B;
}
static int[] input(int n) {
int A[]=new int[n];
for(int i=0;i<n;i++) {
A[i]=sc.nextInt();
}
return A;
}
static long[] inputL(int n) {
long A[]=new long[n];
for(int i=0;i<n;i++) {
A[i]=sc.nextLong();
}
return A;
}
static String[] inputS(int n) {
String A[]=new String[n];
for(int i=0;i<n;i++) {
A[i]=sc.next();
}
return A;
}
static long sum(int A[]) {
long sum=0;
for(int i : A) {
sum+=i;
}
return sum;
}
static long sum(long A[]) {
long sum=0;
for(long i : A) {
sum+=i;
}
return sum;
}
static void reverse(long A[]) {
int n=A.length;
long B[]=new long[n];
for(int i=0;i<n;i++) {
B[i]=A[n-i-1];
}
for(int i=0;i<n;i++)
A[i]=B[i];
}
static void reverse(int A[]) {
int n=A.length;
int B[]=new int[n];
for(int i=0;i<n;i++) {
B[i]=A[n-i-1];
}
for(int i=0;i<n;i++)
A[i]=B[i];
}
static void input(int A[],int B[]) {
for(int i=0;i<A.length;i++) {
A[i]=sc.nextInt();
B[i]=sc.nextInt();
}
}
static int[][] input(int n,int m){
int A[][]=new int[n][m];
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
A[i][j]=i();
}
}
return A;
}
static char[][] charinput(int n,int m){
char A[][]=new char[n][m];
for(int i=0;i<n;i++) {
String s=s();
for(int j=0;j<m;j++) {
A[i][j]=s.charAt(j);
}
}
return A;
}
static int find(int A[],int a) {
if(A[a]==a)
return a;
return A[a]=find(A, A[a]);
}
static int max(int A[]) {
int max=Integer.MIN_VALUE;
for(int i=0;i<A.length;i++) {
max=Math.max(max, A[i]);
}
return max;
}
static int min(int A[]) {
int min=Integer.MAX_VALUE;
for(int i=0;i<A.length;i++) {
min=Math.min(min, A[i]);
}
return min;
}
static long max(long A[]) {
long max=Long.MIN_VALUE;
for(int i=0;i<A.length;i++) {
max=Math.max(max, A[i]);
}
return max;
}
static long min(long A[]) {
long min=Long.MAX_VALUE;
for(int i=0;i<A.length;i++) {
min=Math.min(min, A[i]);
}
return min;
}
static long [] prefix(long A[]) {
long p[]=new long[A.length];
p[0]=A[0];
for(int i=1;i<A.length;i++)
p[i]=p[i-1]+A[i];
return p;
}
static long [] prefix(int A[]) {
long p[]=new long[A.length];
p[0]=A[0];
for(int i=1;i<A.length;i++)
p[i]=p[i-1]+A[i];
return p;
}
static long [] suffix(long A[]) {
long p[]=new long[A.length];
p[A.length-1]=A[A.length-1];
for(int i=A.length-2;i>=0;i--)
p[i]=p[i+1]+A[i];
return p;
}
static long [] suffix(int A[]) {
long p[]=new long[A.length];
p[A.length-1]=A[A.length-1];
for(int i=A.length-2;i>=0;i--)
p[i]=p[i+1]+A[i];
return p;
}
static void fill(int dp[]) {
Arrays.fill(dp, -1);
}
static void fill(int dp[][]) {
for(int i=0;i<dp.length;i++)
Arrays.fill(dp[i], -1);
}
static void fill(int dp[][][]) {
for(int i=0;i<dp.length;i++) {
for(int j=0;j<dp[0].length;j++) {
Arrays.fill(dp[i][j],-1);
}
}
}
static void fill(int dp[][][][]) {
for(int i=0;i<dp.length;i++) {
for(int j=0;j<dp[0].length;j++) {
for(int k=0;k<dp[0][0].length;k++) {
Arrays.fill(dp[i][j][k],-1);
}
}
}
}
static void fill(long dp[]) {
Arrays.fill(dp, -1);
}
static void fill(long dp[][]) {
for(int i=0;i<dp.length;i++)
Arrays.fill(dp[i], -1);
}
static void fill(long dp[][][]) {
for(int i=0;i<dp.length;i++) {
for(int j=0;j<dp[0].length;j++) {
Arrays.fill(dp[i][j],-1);
}
}
}
static void fill(long dp[][][][]) {
for(int i=0;i<dp.length;i++) {
for(int j=0;j<dp[0].length;j++) {
for(int k=0;k<dp[0][0].length;k++) {
Arrays.fill(dp[i][j][k],-1);
}
}
}
}
static int min(int a,int b) {
return Math.min(a, b);
}
static int min(int a,int b,int c) {
return Math.min(a, Math.min(b, c));
}
static int min(int a,int b,int c,int d) {
return Math.min(a, Math.min(b, Math.min(c, d)));
}
static int max(int a,int b) {
return Math.max(a, b);
}
static int max(int a,int b,int c) {
return Math.max(a, Math.max(b, c));
}
static int max(int a,int b,int c,int d) {
return Math.max(a, Math.max(b, Math.max(c, d)));
}
static long min(long a,long b) {
return Math.min(a, b);
}
static long min(long a,long b,long c) {
return Math.min(a, Math.min(b, c));
}
static long min(long a,long b,long c,long d) {
return Math.min(a, Math.min(b, Math.min(c, d)));
}
static long max(long a,long b) {
return Math.max(a, b);
}
static long max(long a,long b,long c) {
return Math.max(a, Math.max(b, c));
}
static long max(long a,long b,long c,long d) {
return Math.max(a, Math.max(b, Math.max(c, d)));
}
static long power(long x, long y, long p)
{
if(y==0)
return 1;
if(x==0)
return 0;
long res = 1;
x = x % p;
while (y > 0) {
if (y % 2 == 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
static void print(int A[]) {
for(int i : A) {
System.out.print(i+" ");
}
System.out.println();
}
static void print(long A[]) {
for(long i : A) {
System.out.print(i+" ");
}
System.out.println();
}
static long mod(long x) {
return ((x%mod + mod)%mod);
}
static String reverse(String s) {
StringBuffer p=new StringBuffer(s);
p.reverse();
return p.toString();
}
static int i() {
return sc.nextInt();
}
static String s() {
return sc.next();
}
static long l() {
return sc.nextLong();
}
static void sort(int[] A){
int n = A.length;
Random rnd = new Random();
for(int i=0; i<n; ++i){
int tmp = A[i];
int randomPos = i + rnd.nextInt(n-i);
A[i] = A[randomPos];
A[randomPos] = tmp;
}
Arrays.sort(A);
}
static void sort(long[] A){
int n = A.length;
Random rnd = new Random();
for(int i=0; i<n; ++i){
long tmp = A[i];
int randomPos = i + rnd.nextInt(n-i);
A[i] = A[randomPos];
A[randomPos] = tmp;
}
Arrays.sort(A);
}
static String sort(String s) {
Character ch[]=new Character[s.length()];
for(int i=0;i<s.length();i++) {
ch[i]=s.charAt(i);
}
Arrays.sort(ch);
StringBuffer st=new StringBuffer("");
for(int i=0;i<s.length();i++) {
st.append(ch[i]);
}
return st.toString();
}
static HashMap<Integer,Integer> hash(int A[]){
HashMap<Integer,Integer> map=new HashMap<Integer, Integer>();
for(int i : A) {
if(map.containsKey(i)) {
map.put(i, map.get(i)+1);
}
else {
map.put(i, 1);
}
}
return map;
}
static TreeMap<Integer,Integer> tree(int A[]){
TreeMap<Integer,Integer> map=new TreeMap<Integer, Integer>();
for(int i : A) {
if(map.containsKey(i)) {
map.put(i, map.get(i)+1);
}
else {
map.put(i, 1);
}
}
return map;
}
static boolean prime(int n)
{
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
double sq=Math.sqrt(n);
for (int i = 5; i <= sq; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
static boolean prime(long n)
{
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
double sq=Math.sqrt(n);
for (int i = 5; i <= sq; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
static int gcd(int a, int b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
static long gcd(long a, long b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
}
|
Vasya plays the Geometry Horse.
The game goal is to destroy geometric figures of the game world. A certain number of points is given for destroying each figure depending on the figure type and the current factor value.
There are n types of geometric figures. The number of figures of type ki and figure cost ci is known for each figure type. A player gets ci·f points for destroying one figure of type i, where f is the current factor. The factor value can be an integer number from 1 to t + 1, inclusive. At the beginning of the game the factor value is equal to 1. The factor is set to i + 1 after destruction of pi (1 ≤ i ≤ t) figures, so the (pi + 1)-th figure to be destroyed is considered with factor equal to i + 1.
Your task is to determine the maximum number of points Vasya can get after he destroys all figures. Take into account that Vasya is so tough that he can destroy figures in any order chosen by him.
Input
The first line contains the only integer number n (1 ≤ n ≤ 100) — the number of figure types.
Each of the following n lines contains two integer numbers ki and ci (1 ≤ ki ≤ 109, 0 ≤ ci ≤ 1000), separated with space — the number of figures of the i-th type and the cost of one i-type figure, correspondingly.
The next line contains the only integer number t (1 ≤ t ≤ 100) — the number that describe the factor's changes.
The next line contains t integer numbers pi (1 ≤ p1 < p2 < ... < pt ≤ 1012), separated with spaces.
Please, do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specificator.
Output
Print the only number — the maximum number of points Vasya can get.
Examples
Input
1
5 10
2
3 6
Output
70
Input
2
3 8
5 10
1
20
Output
74
Note
In the first example Vasya destroys three figures first and gets 3·1·10 = 30 points. Then the factor will become equal to 2 and after destroying the last two figures Vasya will get 2·2·10 = 40 points. As a result Vasya will get 70 points.
In the second example all 8 figures will be destroyed with factor 1, so Vasya will get (3·8 + 5·10)·1 = 74 points.
|
#include <bits/stdc++.h>
using namespace std;
struct st {
int x;
int c;
};
int pr(st a, st b) { return a.c < b.c; }
st a[1005];
long long b[1005];
int i, j, k, n, m, x, y;
long long res, t, z;
int main() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i].x >> a[i].c;
}
sort(a, a + n, pr);
cin >> m;
for (i = 0; i < m; i++) {
cin >> b[i];
}
for (i = m - 1; i > 0; i--) {
b[i] -= b[i - 1];
}
j = 0;
i = 0;
b[m] = 1000000000;
b[m] *= b[m];
while (i < n) {
if (a[i].x == 0) {
i++;
continue;
}
if (b[j] == 0) {
j++;
continue;
}
t = min((long long)a[i].x, b[j]);
res += t * (j + 1) * a[i].c;
a[i].x -= t;
b[j] -= t;
}
cout << res << endl;
return 0;
}
|
As Valeric and Valerko were watching one of the last Euro Championship games in a sports bar, they broke a mug. Of course, the guys paid for it but the barman said that he will let them watch football in his bar only if they help his son complete a programming task. The task goes like that.
Let's consider a set of functions of the following form:
<image> Let's define a sum of n functions y1(x), ..., yn(x) of the given type as function s(x) = y1(x) + ... + yn(x) for any x. It's easy to show that in this case the graph s(x) is a polyline. You are given n functions of the given type, your task is to find the number of angles that do not equal 180 degrees, in the graph s(x), that is the sum of the given functions.
Valeric and Valerko really want to watch the next Euro Championship game, so they asked you to help them.
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of functions. Each of the following n lines contains two space-separated integer numbers ki, bi ( - 109 ≤ ki, bi ≤ 109) that determine the i-th function.
Output
Print a single number — the number of angles that do not equal 180 degrees in the graph of the polyline that equals the sum of the given functions.
Examples
Input
1
1 0
Output
1
Input
3
1 0
0 2
-1 1
Output
2
Input
3
-2 -4
1 7
-5 1
Output
3
|
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeSet;
public class d123 {
public static void debug(Object... obs)
{
System.out.println(Arrays.deepToString(obs));
}
static long gcd(long a,long b)
{
return (b==0)?a:gcd(b,a%b);
}
public static void main(String[] args) throws Exception
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int n=Integer.parseInt(br.readLine());
Set<P> pts = new TreeSet<P>();
for(int i=0;i<n;i++)
{
StringTokenizer st=new StringTokenizer(br.readLine());
long ki = Long.parseLong(st.nextToken());
long bi = Long.parseLong(st.nextToken());
if(ki == 0) continue;
long ak = Math.abs(ki);
long ab = Math.abs(bi);
long gd = gcd(ak,ab);
ki = ki/gd;
bi = bi/gd;
P pair = new P(ki,bi);
pts.add(pair);
}
System.out.println(pts.size());
}
private static class P implements Comparable<P>
{
long k, b;
int sgn;
public P(long k, long b)
{
super();
if(b < 0 && k < 0)
sgn = 1;
else if(b > 0 && k > 0)
sgn = 1;
else if(b == 0)
sgn = 1;
else
sgn = 2;
this.k = Math.abs(k);
this.b = Math.abs(b);
}
@Override
public int compareTo(P arg0)
{
if(b == 0 && arg0.b ==0)
return 0;
if(k - arg0.k != 0)
return sgn(k - arg0.k);
if(b - arg0.b != 0)
return sgn(b - arg0.b);
return sgn - arg0.sgn;
}
private int sgn(long l)
{
if(l < 0) return -1;
if (l > 0) return 1;
return 0;
}
}
}
|
The country Treeland consists of n cities, some pairs of them are connected with unidirectional roads. Overall there are n - 1 roads in the country. We know that if we don't take the direction of the roads into consideration, we can get from any city to any other one.
The council of the elders has recently decided to choose the capital of Treeland. Of course it should be a city of this country. The council is supposed to meet in the capital and regularly move from the capital to other cities (at this stage nobody is thinking about getting back to the capital from these cities). For that reason if city a is chosen a capital, then all roads must be oriented so that if we move along them, we can get from city a to any other city. For that some roads may have to be inversed.
Help the elders to choose the capital so that they have to inverse the minimum number of roads in the country.
Input
The first input line contains integer n (2 ≤ n ≤ 2·105) — the number of cities in Treeland. Next n - 1 lines contain the descriptions of the roads, one road per line. A road is described by a pair of integers si, ti (1 ≤ si, ti ≤ n; si ≠ ti) — the numbers of cities, connected by that road. The i-th road is oriented from city si to city ti. You can consider cities in Treeland indexed from 1 to n.
Output
In the first line print the minimum number of roads to be inversed if the capital is chosen optimally. In the second line print all possible ways to choose the capital — a sequence of indexes of cities in the increasing order.
Examples
Input
3
2 1
2 3
Output
0
2
Input
4
1 4
2 4
3 4
Output
2
1 2 3
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > vec[300005];
long long d[300005], r[300005], cost[300005];
long long val = 300005, temp;
long long rev;
void dfs(int node, int parent, int dist, int inv) {
d[node] = dist;
r[node] = inv;
for (int i = 0; i < vec[node].size(); i++) {
pair<long long, long long> p = vec[node][i];
long long u = p.first;
if (u == parent) continue;
dfs(u, node, dist + 1, inv + p.second);
rev += p.second;
}
}
int main() {
long long n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
vec[x].push_back(make_pair(y, 0));
vec[y].push_back(make_pair(x, 1));
}
dfs(1, 0, 0, 0);
for (int i = 1; i <= n; i++) {
cost[i] = rev - r[i] + (d[i] - r[i]);
if (cost[i] < val) val = cost[i];
}
cout << val << endl;
for (int i = 1; i <= n; i++)
if (cost[i] == val) cout << i << " ";
return 0;
}
|
Polycarpus has a sequence, consisting of n non-negative integers: a1, a2, ..., an.
Let's define function f(l, r) (l, r are integer, 1 ≤ l ≤ r ≤ n) for sequence a as an operation of bitwise OR of all the sequence elements with indexes from l to r. Formally: f(l, r) = al | al + 1 | ... | ar.
Polycarpus took a piece of paper and wrote out the values of function f(l, r) for all l, r (l, r are integer, 1 ≤ l ≤ r ≤ n). Now he wants to know, how many distinct values he's got in the end.
Help Polycarpus, count the number of distinct values of function f(l, r) for the given sequence a.
Expression x | y means applying the operation of bitwise OR to numbers x and y. This operation exists in all modern programming languages, for example, in language C++ and Java it is marked as "|", in Pascal — as "or".
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of elements of sequence a. The second line contains n space-separated integers a1, a2, ..., an (0 ≤ ai ≤ 106) — the elements of sequence a.
Output
Print a single integer — the number of distinct values of function f(l, r) for the given sequence a.
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.
Examples
Input
3
1 2 0
Output
4
Input
10
1 2 3 4 5 6 1 2 9 10
Output
11
Note
In the first test case Polycarpus will have 6 numbers written on the paper: f(1, 1) = 1, f(1, 2) = 3, f(1, 3) = 3, f(2, 2) = 2, f(2, 3) = 2, f(3, 3) = 0. There are exactly 4 distinct numbers among them: 0, 1, 2, 3.
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
vector<int> digitos(long long n, int dig) {
vector<int> res;
while (n > 0) {
res.push_back(n % 2);
n /= 2;
}
while (res.size() < dig) res.push_back(0);
reverse(res.begin(), res.end());
return res;
}
int main() {
int n;
while (cin >> n) {
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int actualAnd[21];
memset(actualAnd, 0, sizeof(actualAnd));
set<int> res;
for (int i = 0; i < n; i++) {
vector<int> dig = digitos(a[i], 21);
for (int j = 0; j < 21; j++) {
if (dig[j] == 0) {
actualAnd[j] |= a[i];
res.insert(actualAnd[j]);
} else {
actualAnd[j] = 0;
}
}
}
cout << res.size() << endl;
}
return 0;
}
|
Manao is working for a construction company. Recently, an order came to build wall bars in a children's park. Manao was commissioned to develop a plan of construction, which will enable the company to save the most money.
After reviewing the formal specifications for the wall bars, Manao discovered a number of controversial requirements and decided to treat them to the company's advantage. His resulting design can be described as follows:
* Let's introduce some unit of length. The construction center is a pole of height n.
* At heights 1, 2, ..., n exactly one horizontal bar sticks out from the pole. Each bar sticks in one of four pre-fixed directions.
* A child can move from one bar to another if the distance between them does not exceed h and they stick in the same direction. If a child is on the ground, he can climb onto any of the bars at height between 1 and h. In Manao's construction a child should be able to reach at least one of the bars at heights n - h + 1, n - h + 2, ..., n if he begins at the ground.
<image> The figure to the left shows what a common set of wall bars looks like. The figure to the right shows Manao's construction
Manao is wondering how many distinct construction designs that satisfy his requirements exist. As this number can be rather large, print the remainder after dividing it by 1000000009 (109 + 9). Two designs are considered distinct if there is such height i, that the bars on the height i in these designs don't stick out in the same direction.
Input
A single line contains two space-separated integers, n and h (1 ≤ n ≤ 1000, 1 ≤ h ≤ min(n, 30)).
Output
In a single line print the remainder after dividing the number of designs by 1000000009 (109 + 9).
Examples
Input
5 1
Output
4
Input
4 2
Output
148
Input
4 3
Output
256
Input
5 2
Output
376
Note
Consider several designs for h = 2. A design with the first bar sticked out in direction d1, the second — in direction d2 and so on (1 ≤ di ≤ 4) is denoted as string d1d2...dn.
Design "1231" (the first three bars are sticked out in different directions, the last one — in the same as first). A child can reach neither the bar at height 3 nor the bar at height 4.
Design "414141". A child can reach the bar at height 5. To do this, he should first climb at the first bar, then at the third and then at the fifth one. He can also reach bar at height 6 by the route second → fourth → sixth bars.
Design "123333". The child can't reach the upper two bars.
Design "323323". The bar at height 6 can be reached by the following route: first → third → fourth → sixth bars.
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class D {
BufferedReader reader;
StringTokenizer tokenizer;
PrintWriter out;
long MODULAR = 1000000009;
public void solve() throws IOException {
int N = nextInt();
int H = nextInt();
long[][][][] dp = new long[2][H][H][H];
dp[1][0][0][0] = 4;
for(int i = 1; i < N; i++){
long[][][][] old = dp.clone();
dp = new long[2][H+1][H+1][H+1];
for(int h1 = 0; h1 < H; h1++){
for(int h2 = 0; h2 < H; h2++){
for(int h3 = 0; h3 < H; h3++){
for(int alive = 0; alive <= 1; alive++){
long add = old[alive][h1][h2][h3] % MODULAR;
int newh1 = (h1 == 0 || h1 == H-1)? 0: h1+1;
int newh2 = (h2 == 0 || h2 == H-1)? 0: h2+1;
int newh3 = (h3 == 0 || h3 == H-1)? 0: h3+1;
int alive1 = (h1 > 0 || i < H)? 1: 0;
int alive2 = (h2 > 0 || i < H)? 1: 0;
int alive3 = (h3 > 0 || i < H)? 1: 0;
dp[alive][newh1][newh2][newh3] += add;
dp[alive1][alive][newh2][newh3] += add;
dp[alive2][newh1][alive][newh3] += add;
dp[alive3][newh1][newh2][alive] += add;
}
}
}
}
}
long ans = 0;
for(int h1 = 0; h1 < H; h1++){
for(int h2 = 0; h2 < H; h2++){
for(int h3 = 0; h3 < H; h3++){
ans = (ans + dp[1][h1][h2][h3]) % MODULAR;
if( h1 > 0 || h2 > 0 || h3 > 0){
ans = ( ans + dp[0][h1][h2][h3]) % MODULAR;
}
}
}
}
out.println( ans );
}
/**
* @param args
*/
public static void main(String[] args) {
new D().run();
}
public void run() {
try {
reader = new BufferedReader(new InputStreamReader(System.in));
tokenizer = null;
out = new PrintWriter(System.out);
solve();
reader.close();
out.close();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
String nextToken() throws IOException {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
}
|
Polycarpus is the director of a large corporation. There are n secretaries working for the corporation, each of them corresponds via the famous Spyke VoIP system during the day. We know that when two people call each other via Spyke, the Spyke network assigns a unique ID to this call, a positive integer session number.
One day Polycarpus wondered which secretaries are talking via the Spyke and which are not. For each secretary, he wrote out either the session number of his call or a 0 if this secretary wasn't talking via Spyke at that moment.
Help Polycarpus analyze these data and find out the number of pairs of secretaries that are talking. If Polycarpus has made a mistake in the data and the described situation could not have taken place, say so.
Note that the secretaries can correspond via Spyke not only with each other, but also with the people from other places. Also, Spyke conferences aren't permitted — that is, one call connects exactly two people.
Input
The first line contains integer n (1 ≤ n ≤ 103) — the number of secretaries in Polycarpus's corporation. The next line contains n space-separated integers: id1, id2, ..., idn (0 ≤ idi ≤ 109). Number idi equals the number of the call session of the i-th secretary, if the secretary is talking via Spyke, or zero otherwise.
Consider the secretaries indexed from 1 to n in some way.
Output
Print a single integer — the number of pairs of chatting secretaries, or -1 if Polycarpus's got a mistake in his records and the described situation could not have taken place.
Examples
Input
6
0 1 7 1 7 10
Output
2
Input
3
1 1 1
Output
-1
Input
1
0
Output
0
Note
In the first test sample there are two Spyke calls between secretaries: secretary 2 and secretary 4, secretary 3 and secretary 5.
In the second test sample the described situation is impossible as conferences aren't allowed.
|
#f = open("A.in", "r+")
#a = f.readline().strip()
n = int(input())
a = raw_input().strip()
a = [int(x) for x in a.strip().split()]
cnt = 0; ok = True
aSet = set(a)
for i in aSet:
if i == 0: continue
if a.count(i) == 2:
cnt += 1
elif a.count(i) > 2:
ok = False
print(-1)
break;
if ok:
print(cnt)
|
Smart Beaver decided to be not only smart, but also a healthy beaver! And so he began to attend physical education classes at school X. In this school, physical education has a very creative teacher. One of his favorite warm-up exercises is throwing balls. Students line up. Each one gets a single ball in the beginning. The balls are numbered from 1 to n (by the demand of the inventory commission).
<image> Figure 1. The initial position for n = 5.
After receiving the balls the students perform the warm-up exercise. The exercise takes place in a few throws. For each throw the teacher chooses any two arbitrary different students who will participate in it. The selected students throw their balls to each other. Thus, after each throw the students remain in their positions, and the two balls are swapped.
<image> Figure 2. The example of a throw.
In this case there was a throw between the students, who were holding the 2-nd and the 4-th balls. Since the warm-up has many exercises, each of them can only continue for little time. Therefore, for each student we know the maximum number of throws he can participate in. For this lessons maximum number of throws will be 1 or 2.
Note that after all phases of the considered exercise any ball can end up with any student. Smart Beaver decided to formalize it and introduced the concept of the "ball order". The ball order is a sequence of n numbers that correspond to the order of balls in the line. The first number will match the number of the ball of the first from the left student in the line, the second number will match the ball of the second student, and so on. For example, in figure 2 the order of the balls was (1, 2, 3, 4, 5), and after the throw it was (1, 4, 3, 2, 5). Smart beaver knows the number of students and for each student he knows the maximum number of throws in which he can participate. And now he is wondering: what is the number of distinct ways of ball orders by the end of the exercise.
Input
The first line contains a single number n — the number of students in the line and the number of balls. The next line contains exactly n space-separated integers. Each number corresponds to a student in the line (the i-th number corresponds to the i-th from the left student in the line) and shows the number of throws he can participate in.
The input limits for scoring 30 points are (subproblem D1):
* 1 ≤ n ≤ 10.
The input limits for scoring 70 points are (subproblems D1+D2):
* 1 ≤ n ≤ 500.
The input limits for scoring 100 points are (subproblems D1+D2+D3):
* 1 ≤ n ≤ 1000000.
Output
The output should contain a single integer — the number of variants of ball orders after the warm up exercise is complete. As the number can be rather large, print it modulo 1000000007 (109 + 7).
Examples
Input
5
1 2 2 1 2
Output
120
Input
8
1 2 2 1 2 1 1 2
Output
16800
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, P = 1e9 + 7;
int t, n, tt[N], cnt, tmp;
long long sum, f[N], fac[N];
void freo() {
freopen("throw.in", "r", stdin);
freopen("throw.out", "w", stdout);
}
void prep() {
t = 1;
f[1] = fac[0] = 1;
f[2] = 2;
for (int i = 0; ++i < N; fac[i] = fac[i - 1] * i % P)
;
for (int i = 2; ++i < N; f[i] = (f[i - 1] + f[i - 2] * (i - 1) % P) % P)
;
}
void init() {
scanf("%d", &n);
tmp = 0;
for (int i = 0; ++i <= n; scanf("%d", &tt[i]), tmp += tt[i])
;
tmp -= n;
cnt = n - tmp;
}
void work() {
if (!cnt) {
sum = fac[tmp];
return;
}
sum = f[cnt];
++cnt;
for (int i = 0; ++i <= tmp; sum = sum * cnt % P, ++cnt)
;
}
void prin() { printf("%lld\n", sum); }
int main() {
for (prep(); t--; init(), work(), prin())
;
return 0;
}
|
Xenia the beginner programmer has a sequence a, consisting of 2n non-negative integers: a1, a2, ..., a2n. Xenia is currently studying bit operations. To better understand how they work, Xenia decided to calculate some value v for a.
Namely, it takes several iterations to calculate value v. At the first iteration, Xenia writes a new sequence a1 or a2, a3 or a4, ..., a2n - 1 or a2n, consisting of 2n - 1 elements. In other words, she writes down the bit-wise OR of adjacent elements of sequence a. At the second iteration, Xenia writes the bitwise exclusive OR of adjacent elements of the sequence obtained after the first iteration. At the third iteration Xenia writes the bitwise OR of the adjacent elements of the sequence obtained after the second iteration. And so on; the operations of bitwise exclusive OR and bitwise OR alternate. In the end, she obtains a sequence consisting of one element, and that element is v.
Let's consider an example. Suppose that sequence a = (1, 2, 3, 4). Then let's write down all the transformations (1, 2, 3, 4) → (1 or 2 = 3, 3 or 4 = 7) → (3 xor 7 = 4). The result is v = 4.
You are given Xenia's initial sequence. But to calculate value v for a given sequence would be too easy, so you are given additional m queries. Each query is a pair of integers p, b. Query p, b means that you need to perform the assignment ap = b. After each query, you need to print the new value v for the new sequence a.
Input
The first line contains two integers n and m (1 ≤ n ≤ 17, 1 ≤ m ≤ 105). The next line contains 2n integers a1, a2, ..., a2n (0 ≤ ai < 230). Each of the next m lines contains queries. The i-th line contains integers pi, bi (1 ≤ pi ≤ 2n, 0 ≤ bi < 230) — the i-th query.
Output
Print m integers — the i-th integer denotes value v for sequence a after the i-th query.
Examples
Input
2 4
1 6 3 5
1 4
3 4
1 2
1 2
Output
1
3
3
3
Note
For more information on the bit operations, you can follow this link: http://en.wikipedia.org/wiki/Bitwise_operation
|
#include <bits/stdc++.h>
using namespace std;
long long t[400000];
long long a[1 << 17];
void build_segment_tree(long long v, long long tl, long long tr, bool op) {
if (tl == tr) {
t[v] = a[tl];
return;
}
long long tm = tl + (tr - tl) / 2;
build_segment_tree(2 * v, tl, tm, !op);
build_segment_tree(2 * v + 1, tm + 1, tr, !op);
if (op)
t[v] = t[2 * v] | t[2 * v + 1];
else
t[v] = t[2 * v] ^ t[2 * v + 1];
}
void update_lazy_propagation(long long v, long long tl, long long tr,
long long pos, long long val, bool op) {
if (tl == tr) {
t[v] = val;
return;
}
long long tm = tl + (tr - tl) / 2;
if (pos <= tm)
update_lazy_propagation(2 * v, tl, tm, pos, val, !op);
else
update_lazy_propagation(2 * v + 1, tm + 1, tr, pos, val, !op);
if (op)
t[v] = t[2 * v] | t[2 * v + 1];
else
t[v] = t[2 * v] ^ t[2 * v + 1];
}
signed main() {
long long n, q;
cin >> n >> q;
long long size = 1 << n;
for (long long i = 0; i < size; i++) cin >> a[i];
build_segment_tree(1, 0, size - 1, n & 1);
while (q--) {
long long pos, val;
cin >> pos >> val;
pos--;
update_lazy_propagation(1, 0, size - 1, pos, val, n & 1);
cout << t[1] << endl;
}
}
|
A boy Petya loves chess very much. He even came up with a chess piece of his own, a semiknight. The semiknight can move in any of these four directions: 2 squares forward and 2 squares to the right, 2 squares forward and 2 squares to the left, 2 squares backward and 2 to the right and 2 squares backward and 2 to the left. Naturally, the semiknight cannot move beyond the limits of the chessboard.
Petya put two semiknights on a standard chessboard. Petya simultaneously moves with both semiknights. The squares are rather large, so after some move the semiknights can meet, that is, they can end up in the same square. After the meeting the semiknights can move on, so it is possible that they meet again. Petya wonders if there is such sequence of moves when the semiknights meet. Petya considers some squares bad. That is, they do not suit for the meeting. The semiknights can move through these squares but their meetings in these squares don't count.
Petya prepared multiple chess boards. Help Petya find out whether the semiknights can meet on some good square for each board.
Please see the test case analysis.
Input
The first line contains number t (1 ≤ t ≤ 50) — the number of boards. Each board is described by a matrix of characters, consisting of 8 rows and 8 columns. The matrix consists of characters ".", "#", "K", representing an empty good square, a bad square and the semiknight's position, correspondingly. It is guaranteed that matrix contains exactly 2 semiknights. The semiknight's squares are considered good for the meeting. The tests are separated by empty line.
Output
For each test, print on a single line the answer to the problem: "YES", if the semiknights can meet and "NO" otherwise.
Examples
Input
2
........
........
......#.
K..##..#
.......#
...##..#
......#.
K.......
........
........
..#.....
..#..#..
..####..
...##...
........
....K#K#
Output
YES
NO
Note
Consider the first board from the sample. We will assume the rows and columns of the matrix to be numbered 1 through 8 from top to bottom and from left to right, correspondingly. The knights can meet, for example, in square (2, 7). The semiknight from square (4, 1) goes to square (2, 3) and the semiknight goes from square (8, 1) to square (6, 3). Then both semiknights go to (4, 5) but this square is bad, so they move together to square (2, 7).
On the second board the semiknights will never meet.
|
import java.util.*;
public class Main {
private static final long MOD = 1000000007;
public static void main(String[] args) throws Exception {
Scanner scan = new Scanner(System.in);
int taskCount = scan.nextInt();
scan.nextLine();
for (int taskIndex = 0; taskIndex < taskCount; taskIndex++) {
if (taskIndex > 0) {
scan.nextLine();
}
char[][] map = new char[8][];
int x1 = -1, y1 = -1, x2 = -1, y2 = -1;
for (int i = 0; i < 8; i++) {
map[i] = scan.nextLine().toCharArray();
for (int j = 0; j < 8; j++) {
if (map[i][j] == 'K') {
if (x1 == -1) {
x1 = i;
y1 = j;
} else {
x2 = i;
y2 = j;
}
}
}
}
boolean pass = false;
outer:
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
if (map[i][j] == '#') {
continue;
}
if ((x1 - i) % 2 != 0 || (x2 - i) % 2 != 0 || (y1 - j) % 2 != 0 || (y2 - j) % 2 != 0) {
continue;
} else if ((x1 - i + y1 - j) % 4 != 0 || (x2 - i + y2 - j) % 4 != 0) {
continue;
} else {
pass = true;
break outer;
}
}
}
if (pass) {
if ((x1 - x2) % 4 != 0) {
pass = false;
}
}
System.out.println(pass ? "YES" : "NO");
}
scan.close();
}
private static void print(int... arr) {
System.out.print(arr[0]);
for (int i = 1; i < arr.length; i++) {
System.out.print(" ");
System.out.print(arr[i]);
}
System.out.println();
}
private static void print(long... arr) {
System.out.print(arr[0]);
for (int i = 1; i < arr.length; i++) {
System.out.print(" ");
System.out.print(arr[i]);
}
System.out.println();
}
private static <T> void print(T... arr) {
System.out.print(arr[0]);
for (int i = 1; i < arr.length; i++) {
System.out.print(" ");
System.out.print(arr[i]);
}
System.out.println();
}
private static void read(Scanner scan, int[]... arrs) {
int len = arrs[0].length;
for (int i = 0; i < len; i++) {
for (int[] arr : arrs) {
arr[i] = scan.nextInt();
}
}
}
private static void read(Scanner scan, long[]... arrs) {
int len = arrs[0].length;
for (int i = 0; i < len; i++) {
for (long[] arr : arrs) {
arr[i] = scan.nextLong();
}
}
}
private static void decreaseByOne(int[]... arrs) {
for (int[] arr : arrs) {
for (int i = 0; i < arr.length; i++) {
arr[i] --;
}
}
}
}
|
One day a bear lived on the Oxy axis. He was afraid of the dark, so he couldn't move at night along the plane points that aren't lit. One day the bear wanted to have a night walk from his house at point (l, 0) to his friend's house at point (r, 0), along the segment of length (r - l). Of course, if he wants to make this walk, he needs each point of the segment to be lit. That's why the bear called his friend (and yes, in the middle of the night) asking for a very delicate favor.
The Oxy axis contains n floodlights. Floodlight i is at point (xi, yi) and can light any angle of the plane as large as ai degree with vertex at point (xi, yi). The bear asked his friend to turn the floodlights so that he (the bear) could go as far away from his house as possible during the walking along the segment. His kind friend agreed to fulfill his request. And while he is at it, the bear wonders: what is the furthest he can go away from his house? Hep him and find this distance.
Consider that the plane has no obstacles and no other light sources besides the floodlights. The bear's friend cannot turn the floodlights during the bear's walk. Assume that after all the floodlights are turned in the correct direction, the bear goes for a walk and his friend goes to bed.
Input
The first line contains three space-separated integers n, l, r (1 ≤ n ≤ 20; - 105 ≤ l ≤ r ≤ 105). The i-th of the next n lines contain three space-separated integers xi, yi, ai ( - 1000 ≤ xi ≤ 1000; 1 ≤ yi ≤ 1000; 1 ≤ ai ≤ 90) — the floodlights' description.
Note that two floodlights can be at the same point of the plane.
Output
Print a single real number — the answer to the problem. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.
Examples
Input
2 3 5
3 1 45
5 1 45
Output
2.000000000
Input
1 0 1
1 1 30
Output
0.732050808
Input
1 0 1
1 1 45
Output
1.000000000
Input
1 0 2
0 2 90
Output
2.000000000
Note
In the first sample, one of the possible solutions is:
<image>
In the second sample, a single solution is:
<image>
In the third sample, a single solution is:
<image>
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
const double EPS = 1e-6;
const int INF = 0x3fffffff;
const long long LINF = INF * 1ll * INF;
const double PI = acos(-1.0);
using namespace std;
int sign(double x) { return x < -EPS ? -1 : x > EPS; }
struct Point {
double x, y;
Point(double x, double y) : x(x), y(y) {}
Point() {}
bool operator==(const Point& p) const {
return sign(x - p.x) == 0 && sign(y - p.y) == 0;
}
Point operator-(const Point& p) const { return Point(x - p.x, y - p.y); }
Point operator*(const double t) const { return Point(t * x, t * y); }
Point operator+(const Point& p) const { return Point(x + p.x, y + p.y); }
bool operator<(const Point& p) const {
return sign(x - p.x) == 0 ? sign(y - p.y) < 0 : sign(x - p.x) < 0;
}
};
struct Line {
Point a, b;
Line() {}
Line(Point a, Point b) : a(a), b(b) {}
};
inline double Length(Point a, Point b) {
double x = a.x - b.x, y = a.y - b.y;
return sqrt(x * x + y * y);
}
inline double Cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
inline double Dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
Point Rotate(Point A, double rad) {
return Point(A.x * cos(rad) - A.y * sin(rad),
A.x * sin(rad) + A.y * cos(rad));
}
inline Point LineInterSection(Line l1, Line l2) {
Point u = l1.a - l2.a;
Point v1 = l1.b - l1.a, v2 = l2.b - l2.a;
if (sign(Cross(v1, v2)) == 0) {
if (sign(Cross(u, v1)))
return Point(-INF, -INF);
else
return Point(-INF, -INF);
}
double t = Cross(v2, u) / Cross(v1, v2);
return l1.a + v1 * t;
}
struct Light {
double x, y, ang;
} light[22];
double dp[1 << 20];
int main(void) {
int n;
double l, r;
cin >> n >> l >> r;
for (int i = 0; i < n; i++) {
cin >> light[i].x >> light[i].y >> light[i].ang;
light[i].ang *= PI;
light[i].ang /= 180;
}
for (int i = 0; i < (1 << n); i++) dp[i] = -INF;
dp[0] = l;
for (int i = 0; i < (1 << n); i++) {
if (sign(dp[i] + INF) == 0) continue;
for (int j = 0; j < n; j++) {
if (i & (1 << j)) continue;
dp[i | (1 << j)] = max(dp[i | (1 << j)], dp[i]);
Point p(light[j].x, light[j].y);
Point v1 = Point(dp[i], 0) - p;
v1 = Rotate(v1, light[j].ang);
double ret;
if (sign(Cross(Point(1, 0), v1)) >= 0) {
ret = r;
} else {
Point inter =
LineInterSection(Line(v1 + p, p), Line(Point(1, 0), Point(-1, 0)));
ret = min(r, inter.x);
}
dp[i | (1 << j)] = max(dp[i | (1 << j)], ret);
}
}
if (sign(dp[(1 << n) - 1] + INF) == 0) dp[(1 << n) - 1] = l;
printf("%.10lf\n", dp[(1 << n) - 1] - dp[0]);
}
|
Little Chris is participating in a graph cutting contest. He's a pro. The time has come to test his skills to the fullest.
Chris is given a simple undirected connected graph with n vertices (numbered from 1 to n) and m edges. The problem is to cut it into edge-distinct paths of length 2. Formally, Chris has to partition all edges of the graph into pairs in such a way that the edges in a single pair are adjacent and each edge must be contained in exactly one pair.
For example, the figure shows a way Chris can cut a graph. The first sample test contains the description of this graph.
<image>
You are given a chance to compete with Chris. Find a way to cut the given graph or determine that it is impossible!
Input
The first line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 105), the number of vertices and the number of edges in the graph. The next m lines contain the description of the graph's edges. The i-th line contains two space-separated integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi), the numbers of the vertices connected by the i-th edge. It is guaranteed that the given graph is simple (without self-loops and multi-edges) and connected.
Note: since the size of the input and output could be very large, don't use slow output techniques in your language. For example, do not use input and output streams (cin, cout) in C++.
Output
If it is possible to cut the given graph into edge-distinct paths of length 2, output <image> lines. In the i-th line print three space-separated integers xi, yi and zi, the description of the i-th path. The graph should contain this path, i.e., the graph should contain edges (xi, yi) and (yi, zi). Each edge should appear in exactly one path of length 2. If there are multiple solutions, output any of them.
If it is impossible to cut the given graph, print "No solution" (without quotes).
Examples
Input
8 12
1 2
2 3
3 4
4 1
1 3
2 4
3 5
3 6
5 6
6 7
6 8
7 8
Output
1 2 4
1 3 2
1 4 3
5 3 6
5 6 8
6 7 8
Input
3 3
1 2
2 3
3 1
Output
No solution
Input
3 2
1 2
2 3
Output
1 2 3
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 123;
vector<int> v[maxn];
int n, m, High[maxn];
bool mark[maxn];
int Dfs(int Vert, int Dad) {
mark[Vert] = true;
vector<int> now;
now.clear();
for (__typeof(v[Vert].begin()) i = v[Vert].begin(); i != v[Vert].end(); ++i)
if (!mark[*i]) {
High[*i] = High[Vert] + 1;
if (Dfs(*i, Vert) == 1) now.push_back(*i);
} else if (*i != Dad and High[*i] < High[Vert])
now.push_back(*i);
while (now.size() >= 2) {
int x = now.back();
now.pop_back();
int y = now.back();
now.pop_back();
printf("%d %d %d\n", x, Vert, y);
}
if (now.empty())
return 1;
else {
printf("%d %d %d\n", now[0], Vert, Dad);
return 0;
}
}
int main() {
int fi, se;
cin >> n >> m;
if (m % 2) {
puts("No solution");
return 0;
}
while (m--) {
cin >> fi >> se;
v[fi].push_back(se);
v[se].push_back(fi);
}
Dfs(1, 0);
return 0;
}
|
Nanami is an expert at playing games. This day, Nanami's good friend Hajime invited her to watch a game of baseball. Unwilling as she was, she followed him to the stadium. But Nanami had no interest in the game, so she looked around to see if there was something that might interest her. That's when she saw the digital board at one end of the stadium.
The digital board is n pixels in height and m pixels in width, every pixel is either light or dark. The pixels are described by its coordinate. The j-th pixel of the i-th line is pixel (i, j). The board displays messages by switching a combination of pixels to light, and the rest to dark. Nanami notices that the state of the pixels on the board changes from time to time. At certain times, certain pixels on the board may switch from light to dark, or from dark to light.
Nanami wonders, what is the area of the biggest light block such that a specific pixel is on its side. A light block is a sub-rectangle of the board, in which all pixels are light. Pixel (i, j) belongs to a side of sub-rectangle with (x1, y1) and (x2, y2) as its upper-left and lower-right vertex if and only if it satisfies the logical condition:
((i = x1 or i = x2) and (y1 ≤ j ≤ y2)) or ((j = y1 or j = y2) and (x1 ≤ i ≤ x2)).
Nanami has all the history of changing pixels, also she has some questions of the described type, can you answer them?
Input
The first line contains three space-separated integers n, m and q (1 ≤ n, m, q ≤ 1000) — the height and width of the digital board, and the number of operations.
Then follow n lines, each line containing m space-separated integers. The j-th integer of the i-th line is ai, j — the initial state of pixel (i, j).
* If ai, j = 0, pixel (i, j) is initially dark.
* If ai, j = 1, pixel (i, j) is initially light.
Then follow q lines, each line containing three space-separated integers op, x, and y (1 ≤ op ≤ 2; 1 ≤ x ≤ n; 1 ≤ y ≤ m), describing an operation.
* If op = 1, the pixel at (x, y) changes its state (from light to dark or from dark to light).
* If op = 2, Nanami queries the biggest light block with pixel (x, y) on its side.
Output
For each query, print a single line containing one integer — the answer to Nanami's query.
Examples
Input
3 4 5
0 1 1 0
1 0 0 1
0 1 1 0
2 2 2
2 1 2
1 2 2
1 2 3
2 2 2
Output
0
2
6
Input
3 3 4
1 1 1
1 1 1
1 1 1
2 2 2
1 2 2
2 1 1
2 2 1
Output
6
3
3
Note
Consider the first sample.
The first query specifies pixel (2, 2), which is dark itself, so there are no valid light blocks, thus the answer is 0.
The second query specifies pixel (1, 2). The biggest light block is the block with (1, 2) as its upper-left vertex and (1, 3) as its lower-right vertex.
The last query specifies pixel (2, 2), which became light in the third operation. The biggest light block is the block with (1, 2) as its upper-left vertex and (3, 3) as its lower-right vertex.
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, m, n, q, x, y;
int u[1090][1090], d[1090][1090], l[1090][1090], r[1090][1090];
int a[1090][1090];
void precacu() {
int i, j;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (a[i][j]) {
if (a[i - 1][j])
u[i][j] = u[i - 1][j];
else
u[i][j] = i;
if (a[i][j - 1])
l[i][j] = l[i][j - 1];
else
l[i][j] = j;
}
for (i = n; i >= 1; i--)
for (j = m; j >= 1; j--)
if (a[i][j]) {
if (a[i + 1][j])
d[i][j] = d[i + 1][j];
else
d[i][j] = i;
if (a[i][j + 1])
r[i][j] = r[i][j + 1];
else
r[i][j] = j;
}
}
void op1() {
a[x][y] ^= 1;
if (a[x][y]) {
if (a[x - 1][y])
u[x][y] = u[x - 1][y];
else
u[x][y] = x;
if (a[x + 1][y])
d[x][y] = d[x + 1][y];
else
d[x][y] = x;
if (a[x][y - 1])
l[x][y] = l[x][y - 1];
else
l[x][y] = y;
if (a[x][y + 1])
r[x][y] = r[x][y + 1];
else
r[x][y] = y;
i = y - 1;
while (i && r[x][i] == y - 1) r[x][i] = r[x][y], i--;
i = y + 1;
while (i <= m && l[x][i] == y + 1) l[x][i] = l[x][y], i++;
i = x - 1;
while (i && d[i][y] == x - 1) d[i][y] = d[x][y], i--;
i = x + 1;
while (i <= n && u[i][y] == x + 1) u[i][y] = u[x][y], i++;
} else {
u[x][y] = d[x][y] = l[x][y] = r[x][y] = 0;
i = y - 1;
while (i && r[x][i] >= y) r[x][i] = y - 1, i--;
i = y + 1;
while (i <= m && l[x][i] <= y) l[x][i] = y + 1, i++;
i = x - 1;
while (i && d[i][y] >= x) d[i][y] = x - 1, i--;
i = x + 1;
while (i <= n && u[i][y] <= x) u[i][y] = x + 1, i++;
}
}
int op2() {
int ans = 0;
if (a[x][y] == 0) return ans;
int up = u[x][y], down = d[x][y];
ans = max(ans, down - up + 1);
for (i = y + 1; i <= m; i++) {
if (!a[x][i]) break;
up = max(up, u[x][i]);
down = min(down, d[x][i]);
ans = max(ans, (down - up + 1) * (i - y + 1));
}
up = u[x][y], down = d[x][y];
for (i = y - 1; i >= 1; i--) {
if (!a[x][i]) break;
up = max(up, u[x][i]);
down = min(down, d[x][i]);
ans = max(ans, (down - up + 1) * (-i + y + 1));
}
int left = l[x][y], right = r[x][y];
ans = max(ans, (right - left + 1));
for (i = x + 1; i <= n; i++) {
if (!a[i][y]) break;
left = max(left, l[i][y]);
right = min(right, r[i][y]);
ans = max(ans, (right - left + 1) * (i - x + 1));
}
left = l[x][y], right = r[x][y];
for (i = x - 1; i >= 1; i--) {
if (!a[i][y]) break;
left = max(left, l[i][y]);
right = min(right, r[i][y]);
ans = max(ans, (right - left + 1) * (-i + x + 1));
}
return ans;
}
int main() {
cin >> n >> m >> q;
memset(a, 0, sizeof(a));
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) scanf("%d", &a[i][j]);
precacu();
int op;
while (q--) {
scanf("%d%d%d", &op, &x, &y);
if (op == 1) op1();
if (op == 2) printf("%d\n", op2());
}
return 0;
}
|
One day Dima and Alex had an argument about the price and quality of laptops. Dima thinks that the more expensive a laptop is, the better it is. Alex disagrees. Alex thinks that there are two laptops, such that the price of the first laptop is less (strictly smaller) than the price of the second laptop but the quality of the first laptop is higher (strictly greater) than the quality of the second laptop.
Please, check the guess of Alex. You are given descriptions of n laptops. Determine whether two described above laptops exist.
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of laptops.
Next n lines contain two integers each, ai and bi (1 ≤ ai, bi ≤ n), where ai is the price of the i-th laptop, and bi is the number that represents the quality of the i-th laptop (the larger the number is, the higher is the quality).
All ai are distinct. All bi are distinct.
Output
If Alex is correct, print "Happy Alex", otherwise print "Poor Alex" (without the quotes).
Examples
Input
2
1 2
2 1
Output
Happy Alex
|
n = int(input())
for _ in range(n):
a,b = map(int,input().split())
if a!=b:
print ('Happy Alex')
exit()
print ('Poor Alex')
|
There are r red and g green blocks for construction of the red-green tower. Red-green tower can be built following next rules:
* Red-green tower is consisting of some number of levels;
* Let the red-green tower consist of n levels, then the first level of this tower should consist of n blocks, second level — of n - 1 blocks, the third one — of n - 2 blocks, and so on — the last level of such tower should consist of the one block. In other words, each successive level should contain one block less than the previous one;
* Each level of the red-green tower should contain blocks of the same color.
<image>
Let h be the maximum possible number of levels of red-green tower, that can be built out of r red and g green blocks meeting the rules above. The task is to determine how many different red-green towers having h levels can be built out of the available blocks.
Two red-green towers are considered different if there exists some level, that consists of red blocks in the one tower and consists of green blocks in the other tower.
You are to write a program that will find the number of different red-green towers of height h modulo 109 + 7.
Input
The only line of input contains two integers r and g, separated by a single space — the number of available red and green blocks respectively (0 ≤ r, g ≤ 2·105, r + g ≥ 1).
Output
Output the only integer — the number of different possible red-green towers of height h modulo 109 + 7.
Examples
Input
4 6
Output
2
Input
9 7
Output
6
Input
1 1
Output
2
Note
The image in the problem statement shows all possible red-green towers for the first sample.
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007ll;
int r, g;
long long dp[2][300000];
int main() {
scanf("%d %d", &r, &g);
int h = 1;
while (((h + 1) * (h + 2)) / 2 <= r + g) h++;
int N = min(r, g);
dp[0][0] = 1;
for (int k = 1; k <= h; k++) {
for (int n = 0; n <= N; n++) {
dp[k % 2][n] =
(n - k >= 0 ? dp[(k + 1) % 2][n - k] : 0) + dp[(k + 1) % 2][n];
dp[k % 2][n] %= mod;
}
}
long long ans = 0;
for (int i = 0; i <= N; i++) {
if ((h * (h + 1)) / 2 - i <= max(r, g)) {
ans += dp[h % 2][i];
ans %= mod;
}
}
printf("%lld\n", ans);
}
|
Dohyun is running a grocery store. He sells n items numbered by integers from 1 to n. The i-th (1 ≤ i ≤ n) of them costs ci dollars, and if I buy it, my happiness increases by hi. Each item can be displayed only for p units of time because of freshness. As Dohyun displays the i-th item at time ti, the customers can buy the i-th item only from time ti to time ti + (p - 1) inclusively. Also, each customer cannot buy the same item more than once.
I'd like to visit Dohyun's grocery store and buy some items for the New Year Party, and maximize my happiness. Because I am a really busy person, I can visit the store only once, and for very short period of time. In other words, if I visit the store at time t, I can only buy the items available at time t. But I can buy as many items as possible, if the budget holds. I can't buy same item several times due to store rules. It is not necessary to use the whole budget.
I made a list of q pairs of integers (aj, bj), which means I may visit the store at time aj, and spend at most bj dollars at the store. For each pair, I'd like to know the maximum happiness I can obtain. But there are so many pairs that I can't handle them. Can you help me?
Input
The first line contains two space-separated integers n and p (1 ≤ n ≤ 4000, 1 ≤ p ≤ 10 000) — the number of items, and the display time of each item.
Next n lines describe the items. The i-th (1 ≤ i ≤ n) of them contains three space-separated integers ci, hi, ti (1 ≤ ci, hi ≤ 4000, 1 ≤ ti ≤ 10 000) — the cost of the i-th item, the happiness of the i-th item, and the time when the i-th item starts to be displayed.
The next line contains an integer q (1 ≤ q ≤ 20 000)— the number of candidates.
Next q lines describe the candidates. The j-th (1 ≤ j ≤ q) of them contains two space-separated integers aj, bj (1 ≤ aj ≤ 20 000, 1 ≤ bj ≤ 4000) — the visit time and the budget for j-th visit of store.
Output
For each candidate, print a single line containing the maximum happiness that I can obtain by buying some items.
Examples
Input
4 4
2 3 2
3 5 1
4 7 2
11 15 5
4
1 3
2 5
2 6
5 14
Output
5
8
10
18
Input
5 4
3 2 1
7 4 4
2 1 2
6 3 5
3 2 2
10
1 5
2 5
4 8
4 9
4 10
5 8
5 9
5 10
8 4
7 9
Output
2
3
5
5
6
4
5
6
0
4
Note
Consider the first sample.
<image>
1. At time 1, only the 2nd item is available. I can buy the 2nd item using 3 dollars and my happiness will increase by 5.
2. At time 2, the 1st, 2nd, and 3rd item is available. I can buy the 1st item using 2 dollars, and the 2nd item using 3 dollars. My happiness will increase by 3 + 5 = 8.
3. At time 2, the 1st, 2nd, and 3rd item is available. I can buy the 1st item using 2 dollars, and the 3nd item using 4 dollars. My happiness will increase by 3 + 7 = 10.
4. At time 5, the 1st, 3rd, and 4th item is available. I can buy the 1st item using 2 dollars, and the 4th item using 11 dollars. My happiness will increase by 3 + 15 = 18. Note that I don't need to use the whole budget in this case.
|
#include <bits/stdc++.h>
using namespace std;
const int MAXD = 20000;
const int MAXB = 4000;
int N, P, Q, ans[MAXD + 5], back[MAXB + 5][MAXB + 5], forw[MAXB + 5][MAXB + 5];
vector<pair<int, int> > que[MAXD + 5], itm[MAXD + 5];
void apply(int d, int m[][MAXB + 5], int *i) {
for (auto p : itm[d]) {
for (int c = 1; c <= MAXB; c++) {
m[*i][c] = max(m[*i][c - 1], m[*i - 1][c]);
if (c >= p.first)
m[*i][c] = max(m[*i][c], p.second + m[*i - 1][c - p.first]);
}
(*i)++;
}
}
void calc(int sd) {
int i = 1;
for (int d = sd; d > max(0, sd - P); d--) apply(d, back, &i);
for (int d = sd + 1, j = 1; d < min(MAXD + 1, sd + P); d++)
apply(d, forw, &j);
int j = 0;
i--;
for (int d = sd; d < min(MAXD + 1, sd + P); d++) {
for (auto p : que[d])
for (int bc = 0; bc <= p.first; bc++)
ans[p.second] = max(ans[p.second], back[i][bc] + forw[j][p.first - bc]);
if (d - P + 1 > 0) i -= itm[d - P + 1].size();
if (d + 1 <= MAXD) j += itm[d + 1].size();
}
}
int main() {
scanf("%d%d", &N, &P);
for (int i = 0; i < N; i++) {
int c, h, d;
scanf("%d%d%d", &c, &h, &d);
itm[d].emplace_back(c, h);
}
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
int d, b;
scanf("%d%d", &d, &b);
que[d].emplace_back(b, i);
}
for (int d = 1; d <= MAXD; d += P) calc(d);
for (int i = 0; i < Q; i++) printf("%d\n", ans[i]);
return 0;
}
|
One day Om Nom found a thread with n beads of different colors. He decided to cut the first several beads from this thread to make a bead necklace and present it to his girlfriend Om Nelly.
<image>
Om Nom knows that his girlfriend loves beautiful patterns. That's why he wants the beads on the necklace to form a regular pattern. A sequence of beads S is regular if it can be represented as S = A + B + A + B + A + ... + A + B + A, where A and B are some bead sequences, " + " is the concatenation of sequences, there are exactly 2k + 1 summands in this sum, among which there are k + 1 "A" summands and k "B" summands that follow in alternating order. Om Nelly knows that her friend is an eager mathematician, so she doesn't mind if A or B is an empty sequence.
Help Om Nom determine in which ways he can cut off the first several beads from the found thread (at least one; probably, all) so that they form a regular pattern. When Om Nom cuts off the beads, he doesn't change their order.
Input
The first line contains two integers n, k (1 ≤ n, k ≤ 1 000 000) — the number of beads on the thread that Om Nom found and number k from the definition of the regular sequence above.
The second line contains the sequence of n lowercase Latin letters that represent the colors of the beads. Each color corresponds to a single letter.
Output
Print a string consisting of n zeroes and ones. Position i (1 ≤ i ≤ n) must contain either number one if the first i beads on the thread form a regular sequence, or a zero otherwise.
Examples
Input
7 2
bcabcab
Output
0000011
Input
21 2
ababaababaababaababaa
Output
000110000111111000011
Note
In the first sample test a regular sequence is both a sequence of the first 6 beads (we can take A = "", B = "bca"), and a sequence of the first 7 beads (we can take A = "b", B = "ca").
In the second sample test, for example, a sequence of the first 13 beads is regular, if we take A = "aba", B = "ba".
|
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
const long double pi = acos(-1);
int N, K;
string s;
int ans[1001001];
int z[1001001];
int main() {
ios_base::sync_with_stdio(0);
cout.precision(15);
cout << fixed;
cout.tie(0);
cin.tie(0);
cin >> N >> K >> s;
int L = 0, R = 0;
for (int i = 1; i < N; i++) {
if (i > R) {
L = R = i;
while (R < N && s[R - L] == s[R]) R++;
z[i] = R - L;
R--;
} else {
int k = i - L;
if (z[k] < R - i + 1) {
z[i] = z[k];
} else {
L = i;
while (R < N && s[R - L] == s[R]) R++;
z[i] = R - L;
R--;
}
}
}
for (int lenAB = 1; lenAB <= N; lenAB++) {
int all = 1;
int cur = lenAB;
for (int(i) = 0, j123 = K - 1; (i) < j123; (i)++) {
if (cur >= N) {
all = 0;
break;
}
if (cur + lenAB - 1 < N) {
all &= (z[cur] >= lenAB);
} else {
all &= (z[cur] == N - cur);
}
cur += lenAB;
}
if (lenAB == 2) {
}
if (all) {
int l = lenAB * K - 1;
int r = l + min(lenAB, z[K * lenAB]);
if (l < N) {
ans[l]++;
ans[min(N, r) + 1]--;
}
}
}
for (int(i) = 0, j123 = N; (i) < j123; (i)++)
if (i >= 1) ans[i] += ans[i - 1];
for (int(i) = 0, j123 = N; (i) < j123; (i)++) cout << (ans[i] > 0);
cout << '\n';
}
|
Professor GukiZ was playing with arrays again and accidentally discovered new function, which he called GukiZiana. For given array a, indexed with integers from 1 to n, and number y, GukiZiana(a, y) represents maximum value of j - i, such that aj = ai = y. If there is no y as an element in a, then GukiZiana(a, y) is equal to - 1. GukiZ also prepared a problem for you. This time, you have two types of queries:
1. First type has form 1 l r x and asks you to increase values of all ai such that l ≤ i ≤ r by the non-negative integer x.
2. Second type has form 2 y and asks you to find value of GukiZiana(a, y).
For each query of type 2, print the answer and make GukiZ happy!
Input
The first line contains two integers n, q (1 ≤ n ≤ 5 * 105, 1 ≤ q ≤ 5 * 104), size of array a, and the number of queries.
The second line contains n integers a1, a2, ... an (1 ≤ ai ≤ 109), forming an array a.
Each of next q lines contain either four or two numbers, as described in statement:
If line starts with 1, then the query looks like 1 l r x (1 ≤ l ≤ r ≤ n, 0 ≤ x ≤ 109), first type query.
If line starts with 2, then th query looks like 2 y (1 ≤ y ≤ 109), second type query.
Output
For each query of type 2, print the value of GukiZiana(a, y), for y value for that query.
Examples
Input
4 3
1 2 3 4
1 1 2 1
1 1 1 1
2 3
Output
2
Input
2 3
1 2
1 2 2 1
2 3
2 4
Output
0
-1
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = LLONG_MAX;
int n, q, sq, len, ord, ii, jj, val, mx, mn, mxpos, mnpos;
long long lazy[1000];
vector<pair<long long, long long> > S[1000];
inline int getseg(int pos) { return pos / sq + (pos % sq != 0); }
void prop(int as) {
for (int i = 0; i < S[as].size(); i++) {
S[as][i].first += lazy[as];
if (S[as][i].second >= ii && S[as][i].second <= jj) S[as][i].first += val;
}
lazy[as] = 0;
sort(S[as].begin(), S[as].end());
}
void update(int sts, int eds) {
for (int i = sts; i <= eds; i++) lazy[i] += val;
}
int query() {
long long FR = -inf, FL = inf;
for (int i = 1; i <= len; i++) {
int posL = 0, posR = 0;
posL =
lower_bound(S[i].begin(), S[i].end(), make_pair(val - lazy[i], -inf)) -
S[i].begin();
posR =
upper_bound(S[i].begin(), S[i].end(), make_pair(val - lazy[i], inf)) -
S[i].begin();
if (S[i][posL].first == val - lazy[i]) FL = min(FL, S[i][posL].second);
if (posR && S[i][posR - 1].first == val - lazy[i])
FR = max(FR, S[i][posR - 1].second);
}
if (FL == inf || FR == -inf) return -1;
return FR - FL;
}
int main() {
scanf("%d %d", &n, &q);
sq = sqrt(n);
len = n / sq + (n % sq != 0);
for (int i = 1; i <= n; i++) {
scanf("%d", &val);
S[getseg(i)].push_back(make_pair(val, i));
}
for (int i = 1; i <= len; i++) sort(S[i].begin(), S[i].end());
while (q--) {
scanf("%d", &ord);
if (ord == 1) {
scanf("%d %d %d", &ii, &jj, &val);
int second = getseg(ii);
int es = getseg(jj);
prop(second);
if (second != es) prop(es);
update(second + 1, es - 1);
} else {
scanf("%d", &val);
printf("%d\n", query());
}
}
}
|
You are given a box full of mirrors. Box consists of grid of size n × m. Each cell of the grid contains a mirror put in the shape of '\' or ' / ' (45 degree to the horizontal or vertical line). But mirrors in some cells have been destroyed. You want to put new mirrors into these grids so that the following two conditions are satisfied:
1. If you put a light ray horizontally/vertically into the middle of any unit segment that is side of some border cell, the light will go out from the neighboring unit segment to the segment you put the ray in.
2. each unit segment of the grid of the mirror box can be penetrated by at least one light ray horizontally/vertically put into the box according to the rules of the previous paragraph
<image>
After you tried putting some mirrors, you find out that there are many ways of doing so. How many possible ways are there? The answer might be large, so please find the result modulo prime number MOD.
Input
The first line contains three integers n, m, MOD (1 ≤ n, m ≤ 100, 3 ≤ MOD ≤ 109 + 7, MOD is prime), m, n indicates the dimensions of a box and MOD is the number to module the answer.
The following n lines each contains a string of length m. Each string contains only ' / ', '\', '*', where '*' denotes that the mirror in that grid has been destroyed.
It is guaranteed that the number of '*' is no more than 200.
Output
Output the answer modulo MOD.
Examples
Input
2 2 1000000007
*/
/*
Output
1
Input
2 2 1000000007
**
\\
Output
1
Input
2 2 3
**
**
Output
2
Note
The only way for sample 1 is shown on the left picture from the statement.
The only way for sample 2 is shown on the right picture from the statement.
For the third sample, there are 5 possibilities that are listed below:
1.
<image>
<image>
2.
<image>
<image>
3.
<image>
<image>
4.
<image>
<image>
5.
<image>
<image>
The answer is then module by 3 so the output should be 2.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 205, M = N * N;
int n, m, l, mod, fa[M], id[M], fl;
long long ans, a[N][N];
char s[N][N];
long long mypow(long long x, int y) {
long long z = 1;
while (y) {
if (y & 1) (z *= x) %= mod;
y >>= 1;
(x *= x) %= mod;
}
return z;
}
long long det() {
l--;
long long res = 1;
for (int i = 1; i <= l; i++) {
for (int j = 1; j <= l; j++) a[i][j] %= mod;
}
for (int i = 1; i <= l; i++) {
int k = i;
while (k <= l && !a[k][i]) k++;
if (k > l) return 0;
if (k != i) res *= -1;
for (int j = 1; j <= l; j++) swap(a[k][j], a[i][j]);
(res *= a[i][i]) %= mod;
for (int j = i + 1; j <= l; j++)
if (a[j][i]) {
long long z = a[j][i] * mypow(a[i][i], mod - 2) % mod;
for (int y = 1; y <= l; y++) (a[j][y] -= a[i][y] * z) %= mod;
}
}
return res;
}
int fd(int x) { return fa[x] == x ? x : fa[x] = fd(fa[x]); }
void link(int x, int y) {
x = fd(x), y = fd(y);
fa[x] = y;
if (x == y) fl = 1;
}
void pre() {
for (int i = 1; i <= n + 1; i++) {
for (int j = 1; j <= m + 1; j++) {
int x = ((i - 1) * (m + 1) + j);
fa[x] = x;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s[i][j] == '\\') {
link(((i - 1) * (m + 1) + j), ((i + 1 - 1) * (m + 1) + j + 1));
} else if (s[i][j] == '/') {
link(((i - 1) * (m + 1) + j + 1), ((i + 1 - 1) * (m + 1) + j));
}
}
}
}
void work(bool f) {
l = 0;
for (int i = 1; i <= n + 1; i++) {
for (int j = 1; j <= m + 1; j++)
if (((i + j) & 1) == f) {
int x = ((i - 1) * (m + 1) + j);
if (fa[x] == x) id[x] = ++l;
}
}
if (l > 202) return;
for (int i = 1; i <= l; i++) {
for (int j = 1; j <= l; j++) a[i][j] = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
if (s[i][j] == '*') {
int x, y;
if (((i + j) & 1) == f)
x = ((i - 1) * (m + 1) + j), y = ((i + 1 - 1) * (m + 1) + j + 1);
else
x = ((i + 1 - 1) * (m + 1) + j), y = ((i - 1) * (m + 1) + j + 1);
x = id[fd(x)], y = id[fd(y)];
a[x][x]++, a[y][y]++;
a[x][y]--, a[y][x]--;
}
}
ans += det();
}
int main() {
scanf("%d%d%d", &n, &m, &mod);
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
}
pre();
work(1);
work(0);
if (fl) ans = 0;
printf("%I64d\n", (ans % mod + mod) % mod);
return 0;
}
|
Everybody knows that the capital of Berland is connected to Bercouver (the Olympic capital) by a direct road. To improve the road's traffic capacity, there was placed just one traffic sign, limiting the maximum speed. Traffic signs in Berland are a bit peculiar, because they limit the speed only at that point on the road where they are placed. Right after passing the sign it is allowed to drive at any speed.
It is known that the car of an average Berland citizen has the acceleration (deceleration) speed of a km/h2, and has maximum speed of v km/h. The road has the length of l km, and the speed sign, limiting the speed to w km/h, is placed d km (1 ≤ d < l) away from the capital of Berland. The car has a zero speed at the beginning of the journey. Find the minimum time that an average Berland citizen will need to get from the capital to Bercouver, if he drives at the optimal speed.
The car can enter Bercouver at any speed.
Input
The first line of the input file contains two integer numbers a and v (1 ≤ a, v ≤ 10000). The second line contains three integer numbers l, d and w (2 ≤ l ≤ 10000; 1 ≤ d < l; 1 ≤ w ≤ 10000).
Output
Print the answer with at least five digits after the decimal point.
Examples
Input
1 1
2 1 3
Output
2.500000000000
Input
5 70
200 170 40
Output
8.965874696353
|
import java.util.*;
public class Rules {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int a = in.nextInt();
double maxSpeed = in.nextInt();
double len = in.nextInt();
double delayDist = in.nextInt();
double delaySpeed = in.nextInt();
double timeToDelaySpeed = delaySpeed/a;
double timeToDelay = travelS(a, 0.0, maxSpeed, delayDist);
//System.out.printf("timeToDelaySpeed=%.5f, timeToDelay=%.5f\n", timeToDelaySpeed, timeToDelay);
if (timeToDelay < timeToDelaySpeed) { // we won't reach delaySpeed before delay marker
// 2 cases: we don't reach max by time we reach end
timeToDelay = travelS(a, 0.0, maxSpeed, len);
double timeToMax = maxSpeed/a;
if (timeToDelay < timeToMax) {
System.out.printf("%.9f\n", timeToDelay);
return;
}
// we do reach max, then travel at max
double[] parts = travelA(a, 0.0, maxSpeed);
double remainingDist = len - parts[1];
double time = parts[0] + remainingDist / maxSpeed;
System.out.printf("%.9f\n", time);
return;
}
if (delaySpeed > maxSpeed) {
double time = travelS(a, 0.0, maxSpeed, len);
System.out.printf("%.9f\n", time);
return;
}
// binary search to find best velocity to stop acceleration in beginning
double lowV = delaySpeed;
double highV = maxSpeed;
int loopCount = 1000;
double[] initial = null;
double[] secondary = null;
while (loopCount-->0) {
double guessV = (lowV+highV)/2.0;
initial = travelA(a, 0.0, guessV);
secondary = travelA(a, guessV, Math.min(delaySpeed, maxSpeed));
if (initial[1] + secondary[1] < delayDist) { // okay, we can go faster
lowV = guessV;
} else {
highV = guessV;
}
}
double totalTime = 0.0;
double finalSpeed = 0.0;
initial = travelA(a, 0.0, lowV);
secondary = travelA(a, lowV, delaySpeed);
totalTime = initial[0] + secondary[0];
double totalDist = initial[1] + secondary[1];
totalTime += (delayDist-totalDist)/maxSpeed;
// now we have delayDist to go, and we are at delaySpeed
totalTime += travelS(a, delaySpeed, maxSpeed, len-delayDist);
System.out.printf("%.9f\n", totalTime);
}
// [0] = time in h, [1] = dist travelled, in km
// input units are in km/h^2, km/h, km/h
public static double[] travelA(int a, double startSpeed, double endSpeed) {
if (startSpeed > endSpeed)
a = -a;
double time = (endSpeed - startSpeed) / a;
double dist = 0.5*a*time*time + startSpeed*time;
return new double[] {time, dist};
}
// returns time it takes to travel dist, with given inputs
public static double travelS(int a, double startSpeed, double maxSpeed, double dist) {
double timeToMax = (maxSpeed - startSpeed) / a;
double targetTime = (-startSpeed + Math.sqrt(startSpeed*startSpeed + 2*a*dist)) / a;
if (targetTime < timeToMax)
return targetTime;
double partialDist = 0.5*timeToMax*timeToMax*a + startSpeed*timeToMax;
double remainingDist = dist - partialDist;
targetTime = remainingDist / maxSpeed;
return targetTime + timeToMax;
}
}
|
You are given the current time in 24-hour format hh:mm. Find and print the time after a minutes.
Note that you should find only the time after a minutes, see the examples to clarify the problem statement.
You can read more about 24-hour format here <https://en.wikipedia.org/wiki/24-hour_clock>.
Input
The first line contains the current time in the format hh:mm (0 ≤ hh < 24, 0 ≤ mm < 60). The hours and the minutes are given with two digits (the hours or the minutes less than 10 are given with the leading zeroes).
The second line contains integer a (0 ≤ a ≤ 104) — the number of the minutes passed.
Output
The only line should contain the time after a minutes in the format described in the input. Note that you should print exactly two digits for the hours and the minutes (add leading zeroes to the numbers if needed).
See the examples to check the input/output format.
Examples
Input
23:59
10
Output
00:09
Input
20:20
121
Output
22:21
Input
10:10
0
Output
10:10
|
#!/usr/bin/env python3
import datetime
def main(args):
hh, mm = list(map(int, input().split(':')))
a = int(input())
mm += a
hh += (mm // 60)
mm %= 60
hh %= 24
print(f"{hh:02d}:{mm:02d}")
return 0
if __name__ == '__main__':
import sys
sys.exit(main(sys.argv))
|
Limak is a little grizzly bear. He will once attack Deerland but now he can only destroy trees in role-playing games. Limak starts with a tree with one vertex. The only vertex has index 1 and is a root of the tree.
Sometimes, a game chooses a subtree and allows Limak to attack it. When a subtree is attacked then each of its edges is destroyed with probability <image>, independently of other edges. Then, Limak gets the penalty — an integer equal to the height of the subtree after the attack. The height is defined as the maximum number of edges on the path between the root of the subtree and any vertex in the subtree.
You must handle queries of two types.
* 1 v denotes a query of the first type. A new vertex appears and its parent is v. A new vertex has the next available index (so, new vertices will be numbered 2, 3, ...).
* 2 v denotes a query of the second type. For a moment let's assume that the game allows Limak to attack a subtree rooted in v. Then, what would be the expected value of the penalty Limak gets after the attack?
In a query of the second type, Limak doesn't actually attack the subtree and thus the query doesn't affect next queries.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 500 000) — the number of queries.
Then, q lines follow. The i-th of them contains two integers typei and vi (1 ≤ typei ≤ 2). If typei = 1 then vi denotes a parent of a new vertex, while if typei = 2 then you should print the answer for a subtree rooted in vi.
It's guaranteed that there will be at least 1 query of the second type, that is, the output won't be empty.
It's guaranteed that just before the i-th query a vertex vi already exists.
Output
For each query of the second type print one real number —the expected value of the penalty if Limak attacks the given subtree. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
7
1 1
1 1
2 1
1 2
1 3
2 2
2 1
Output
0.7500000000
0.5000000000
1.1875000000
Input
8
2 1
1 1
1 2
1 3
1 4
2 1
1 4
2 1
Output
0.0000000000
0.9375000000
0.9687500000
Note
Below, you can see the drawing for the first sample. Red circles denote queries of the second type.
<image>
|
#include <bits/stdc++.h>
const int maxN = 5e5 + 7;
const int maxH = 60;
int n, fa[maxN];
double f[maxN][maxH];
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int main() {
int n = 1, T = read(), opt, x;
for (int i = 0; i < maxH; ++i) f[1][i] = 1;
while (T--) {
opt = read();
x = read();
if (opt == 1) {
fa[++n] = x;
for (int i = 0; i < maxH; ++i) f[n][i] = 1;
double tmp1 = f[x][0], tmp2;
f[x][0] *= 0.5;
for (int Fa = fa[x], i = 1; Fa && i < maxH; Fa = fa[x = Fa], ++i) {
tmp2 = f[Fa][i];
f[Fa][i] /= 0.5 + 0.5 * tmp1;
f[Fa][i] *= 0.5 + 0.5 * f[x][i - 1];
tmp1 = tmp2;
}
} else {
double ans = 0;
for (int i = 1; i < maxH; ++i) ans += (f[x][i] - f[x][i - 1]) * i;
printf("%.10lf\n", ans);
}
}
return 0;
}
|
The term of this problem is the same as the previous one, the only exception — increased restrictions.
Input
The first line contains two positive integers n and k (1 ≤ n ≤ 100 000, 1 ≤ k ≤ 109) — the number of ingredients and the number of grams of the magic powder.
The second line contains the sequence a1, a2, ..., an (1 ≤ ai ≤ 109), where the i-th number is equal to the number of grams of the i-th ingredient, needed to bake one cookie.
The third line contains the sequence b1, b2, ..., bn (1 ≤ bi ≤ 109), where the i-th number is equal to the number of grams of the i-th ingredient, which Apollinaria has.
Output
Print the maximum number of cookies, which Apollinaria will be able to bake using the ingredients that she has and the magic powder.
Examples
Input
1 1000000000
1
1000000000
Output
2000000000
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
1 1 1 1 1 1 1 1 1 1
Output
0
Input
3 1
2 1 4
11 3 16
Output
4
Input
4 3
4 3 5 6
11 12 14 20
Output
3
|
#include <bits/stdc++.h>
using namespace std;
const int N6 = 1e6 + 6, N3 = 1e3 + 6, oo = 1e9 + 9, base = 1e9 + 7;
const long long ool = 1e18 + 9;
int n;
long long k, a[N6], ans, b[N6];
pair<long long, int> d[N6];
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i <= n; ++i) {
cin >> b[i];
d[i].first = (b[i] + a[i] - 1) / a[i];
d[i].second = i;
}
sort(d + 1, d + n + 1);
long long need = 0, cur = 0;
for (int i = 1; i <= n; ++i) {
if (d[i].first != d[i - 1].first) {
if (k < cur) {
cout << d[i - 1].first - 1 << "\n";
return 0;
}
k -= cur;
if (k < need * (d[i].first - d[i - 1].first)) {
cout << d[i - 1].first + k / need << "\n";
return 0;
} else {
k -= need * (d[i].first - d[i - 1].first);
}
cur = 0;
}
cur += a[d[i].second] *
((b[d[i].second] + a[d[i].second] - 1) / a[d[i].second]) -
b[d[i].second];
need += a[d[i].second];
}
if (k < cur) {
cout << d[n].first - 1 << "\n";
return 0;
}
k -= cur;
cout << d[n].first + k / need << "\n";
return 0;
}
|
Barney lives in NYC. NYC has infinite number of intersections numbered with positive integers starting from 1. There exists a bidirectional road between intersections i and 2i and another road between i and 2i + 1 for every positive integer i. You can clearly see that there exists a unique shortest path between any two intersections.
<image>
Initially anyone can pass any road for free. But since SlapsGiving is ahead of us, there will q consecutive events happen soon. There are two types of events:
1. Government makes a new rule. A rule can be denoted by integers v, u and w. As the result of this action, the passing fee of all roads on the shortest path from u to v increases by w dollars.
2. Barney starts moving from some intersection v and goes to intersection u where there's a girl he wants to cuddle (using his fake name Lorenzo Von Matterhorn). He always uses the shortest path (visiting minimum number of intersections or roads) between two intersections.
Government needs your calculations. For each time Barney goes to cuddle a girl, you need to tell the government how much money he should pay (sum of passing fee of all roads he passes).
Input
The first line of input contains a single integer q (1 ≤ q ≤ 1 000).
The next q lines contain the information about the events in chronological order. Each event is described in form 1 v u w if it's an event when government makes a new rule about increasing the passing fee of all roads on the shortest path from u to v by w dollars, or in form 2 v u if it's an event when Barnie goes to cuddle from the intersection v to the intersection u.
1 ≤ v, u ≤ 1018, v ≠ u, 1 ≤ w ≤ 109 states for every description line.
Output
For each event of second type print the sum of passing fee of all roads Barney passes in this event, in one line. Print the answers in chronological order of corresponding events.
Example
Input
7
1 3 4 30
1 4 1 2
1 3 6 8
2 4 3
1 6 1 40
2 3 7
2 2 4
Output
94
0
32
Note
In the example testcase:
Here are the intersections used:
<image>
1. Intersections on the path are 3, 1, 2 and 4.
2. Intersections on the path are 4, 2 and 1.
3. Intersections on the path are only 3 and 6.
4. Intersections on the path are 4, 2, 1 and 3. Passing fee of roads on the path are 32, 32 and 30 in order. So answer equals to 32 + 32 + 30 = 94.
5. Intersections on the path are 6, 3 and 1.
6. Intersections on the path are 3 and 7. Passing fee of the road between them is 0.
7. Intersections on the path are 2 and 4. Passing fee of the road between them is 32 (increased by 30 in the first event and by 2 in the second).
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long INF = 1000000000;
template <class T>
inline void read(T &x) {
char c;
int flag = 1;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flag *= -1;
x = c - '0';
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= flag;
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> q;
map<long long, long long> dp;
while (q--) {
long long op, u, v;
cin >> op >> u >> v;
if (op == 1) {
long long w;
cin >> w;
while (u ^ v) {
if (u < v) swap(u, v);
dp[u] += w, u /= 2;
}
} else {
long long ans = 0;
while (u ^ v) {
if (u < v) swap(u, v);
ans += dp[u], u /= 2;
}
cout << ans << endl;
}
}
}
|
R3D3 spent some time on an internship in MDCS. After earning enough money, he decided to go on a holiday somewhere far, far away. He enjoyed suntanning, drinking alcohol-free cocktails and going to concerts of popular local bands. While listening to "The White Buttons" and their hit song "Dacan the Baker", he met another robot for whom he was sure is the love of his life. Well, his summer, at least. Anyway, R3D3 was too shy to approach his potential soulmate, so he decided to write her a love letter. However, he stumbled upon a problem. Due to a terrorist threat, the Intergalactic Space Police was monitoring all letters sent in the area. Thus, R3D3 decided to invent his own alphabet, for which he was sure his love would be able to decipher.
There are n letters in R3D3’s alphabet, and he wants to represent each letter as a sequence of '0' and '1', so that no letter’s sequence is a prefix of another letter's sequence. Since the Intergalactic Space Communications Service has lately introduced a tax for invented alphabets, R3D3 must pay a certain amount of money for each bit in his alphabet’s code (check the sample test for clarifications). He is too lovestruck to think clearly, so he asked you for help.
Given the costs c0 and c1 for each '0' and '1' in R3D3’s alphabet, respectively, you should come up with a coding for the alphabet (with properties as above) with minimum total cost.
Input
The first line of input contains three integers n (2 ≤ n ≤ 108), c0 and c1 (0 ≤ c0, c1 ≤ 108) — the number of letters in the alphabet, and costs of '0' and '1', respectively.
Output
Output a single integer — minimum possible total a cost of the whole alphabet.
Example
Input
4 1 2
Output
12
Note
There are 4 letters in the alphabet. The optimal encoding is "00", "01", "10", "11". There are 4 zeroes and 4 ones used, so the total cost is 4·1 + 4·2 = 12.
|
import sys,heapq
#sys.stdin=open("data.txt")
input=sys.stdin.readline
n,a,b=map(int,input().split())
if a<b: a,b=b,a
if b==0:
# 1 01 001 0001 ... is optimal, plus a long series of 0's
print((n-1)*a)
else:
# pascal's triangle thing
pascal=[[1]*20005]
for i in range(20004):
newrow=[1]
for j in range(1,20005):
newrow.append(newrow[-1]+pascal[-1][j])
if newrow[-1]>n: break
pascal.append(newrow)
def getcom(a,b):
# return a+b choose b
# if larger than n, return infinite
if len(pascal[a])>b: return pascal[a][b]
if b==0: return 1
if b==1: return a
return 100000005
# start with the null node (prefix cost 0)
# can split a node into two other nodes with added cost c+a+b
# new nodes have prefix costs c+a, c+b
# want n-1 splits in total
remain=n-1
ans=0
possible=[[a+b,1]] # [c,count]
while 1:
# cost u, v leaves
u,v=heapq.heappop(possible)
while possible and possible[0][0]==u:
v+=possible[0][1]
heapq.heappop(possible)
if remain<=v:
ans+=u*remain
break
ans+=u*v
remain-=v
heapq.heappush(possible,[u+a,v])
heapq.heappush(possible,[u+b,v])
print(ans)
# Made By Mostafa_Khaled
|
This problem has unusual memory constraint.
At evening, Igor and Zhenya the financiers became boring, so they decided to play a game. They prepared n papers with the income of some company for some time periods. Note that the income can be positive, zero or negative.
Igor and Zhenya placed the papers in a row and decided to take turns making moves. Igor will take the papers from the left side, Zhenya will take the papers from the right side. Igor goes first and takes 1 or 2 (on his choice) papers from the left. Then, on each turn a player can take k or k + 1 papers from his side if the opponent took exactly k papers in the previous turn. Players can't skip moves. The game ends when there are no papers left, or when some of the players can't make a move.
Your task is to determine the difference between the sum of incomes on the papers Igor took and the sum of incomes on the papers Zhenya took, assuming both players play optimally. Igor wants to maximize the difference, Zhenya wants to minimize it.
Input
The first line contains single positive integer n (1 ≤ n ≤ 4000) — the number of papers.
The second line contains n integers a1, a2, ..., an ( - 105 ≤ ai ≤ 105), where ai is the income on the i-th paper from the left.
Output
Print the difference between the sum of incomes on the papers Igor took and the sum of incomes on the papers Zhenya took, assuming both players play optimally. Igor wants to maximize the difference, Zhenya wants to minimize it.
Examples
Input
3
1 3 1
Output
4
Input
5
-1 -2 -1 -2 -1
Output
0
Input
4
-4 -2 4 5
Output
-13
Note
In the first example it's profitable for Igor to take two papers from the left to have the sum of the incomes equal to 4. Then Zhenya wouldn't be able to make a move since there would be only one paper, and he would be able to take only 2 or 3..
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int IT_MAX = 1 << 19;
const int MOD = 100000000;
const int INF = 1034567891;
const long long LL_INF = 1234567890123456789ll;
const double PI = 3.141592653589793238;
const double ERR = 1E-10;
int in[4050];
int sum[4050];
int dp[4050][95][95];
int main() {
int N, i, j, k, ii, jj;
scanf("%d", &N);
for (i = 1; i <= N; i++) scanf("%d", &in[i]);
for (i = 1; i <= N; i++) sum[i] = sum[i - 1] + in[i];
for (i = 1; i <= N; i++) {
for (j = 1; j <= 93; j++) {
for (k = 0; k <= 93; k++) {
if ((N - i + k) % 2) continue;
int s = (N - i - k) >> 1;
s++;
int e = s + i - 1;
if (s < 1 || e > N) continue;
dp[i][j][k] = -INF;
if (j > i) {
dp[i][j][k] = 0;
continue;
}
if (j == i) {
dp[i][j][k] = sum[s + j - 1] - sum[s - 1];
continue;
}
for (ii = 0; ii <= 1; ii++) {
int tx = INF;
int k1 = j + ii;
if (i - k1 < k1) {
dp[i][j][k] = max(dp[i][j][k], sum[s + k1 - 1] - sum[s - 1]);
continue;
}
if (i - k1 == k1) {
dp[i][j][k] = max(dp[i][j][k], sum[s + k1 - 1] - sum[s - 1] -
sum[e] + sum[e - k1]);
continue;
}
for (jj = 0; jj <= 1; jj++) {
int k2 = k1 + jj;
tx = min(tx, dp[i - k1 - k2][k2][k + jj] - sum[e] + sum[e - k2]);
}
dp[i][j][k] = max(dp[i][j][k], sum[s + k1 - 1] - sum[s - 1] + tx);
}
}
}
}
return !printf("%d\n", dp[N][1][0]);
}
|
After overcoming the stairs Dasha came to classes. She needed to write a password to begin her classes. The password is a string of length n which satisfies the following requirements:
* There is at least one digit in the string,
* There is at least one lowercase (small) letter of the Latin alphabet in the string,
* There is at least one of three listed symbols in the string: '#', '*', '&'.
<image>
Considering that these are programming classes it is not easy to write the password.
For each character of the password we have a fixed string of length m, on each of these n strings there is a pointer on some character. The i-th character displayed on the screen is the pointed character in the i-th string. Initially, all pointers are on characters with indexes 1 in the corresponding strings (all positions are numbered starting from one).
During one operation Dasha can move a pointer in one string one character to the left or to the right. Strings are cyclic, it means that when we move the pointer which is on the character with index 1 to the left, it moves to the character with the index m, and when we move it to the right from the position m it moves to the position 1.
You need to determine the minimum number of operations necessary to make the string displayed on the screen a valid password.
Input
The first line contains two integers n, m (3 ≤ n ≤ 50, 1 ≤ m ≤ 50) — the length of the password and the length of strings which are assigned to password symbols.
Each of the next n lines contains the string which is assigned to the i-th symbol of the password string. Its length is m, it consists of digits, lowercase English letters, and characters '#', '*' or '&'.
You have such input data that you can always get a valid password.
Output
Print one integer — the minimum number of operations which is necessary to make the string, which is displayed on the screen, a valid password.
Examples
Input
3 4
1**2
a3*0
c4**
Output
1
Input
5 5
#*&#*
*a1c&
&q2w*
#a3c#
*&#*&
Output
3
Note
In the first test it is necessary to move the pointer of the third string to one left to get the optimal answer.
<image>
In the second test one of possible algorithms will be:
* to move the pointer of the second symbol once to the right.
* to move the pointer of the third symbol twice to the right.
<image>
|
n,m=map(int,input().split())
m1,m2,m3=[m+1]*n,[m+1]*n,[m+1]*n
for i in range(n):
s=input()
for j, c in enumerate(s):
z=min(j, m-j)
if c>='0' and c<='9':
m1[i]=min(m1[i],z)
else:
if c>='a' and c<='z':
m2[i]=min(m2[i],z)
else:
m3[i]=min(m3[i],z)
ans=m*3
for i in range(n):
for j in range(n):
if i!=j:
for p in range(n):
if i!=p and j!=p:
ans=min(ans,m1[i]+m2[j]+m3[p])
print(ans)
|
<image>
Input
The input consists of four lines, each line containing a single digit 0 or 1.
Output
Output a single digit, 0 or 1.
Example
Input
0
1
1
0
Output
0
|
import sys
import itertools
def f(x):
a = x[0] | x[1]
b = x[2] ^ x[3]
c = x[1] & x[2]
d = x[0] | x[3]
e = a & b
f = c ^ d
g = e | f
return g
def main():
a = []
for i in xrange(4):
a.append(int(raw_input().strip()))
x = 8 * a[0] + 4 * a[1] + 2 * a[2] + a[3]
d = [0, 1, 0, 1,
0, 0, 0, 0,
1, 1, 0, 1,
1, 0, 1, 1]
print d[x]
if __name__ == "__main__":
main()
|
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" → "bba".
The second example: "aab" → "abba" → "bbaba" → "bbbbaa".
|
s = list(raw_input())
cur = 0
ans = 0
mod = pow(10,9)+7
for i in range(len(s)-1,-1,-1):
if s[i]=='a':
ans = (ans+cur)%mod
if cur:
cur *= 2
cur %= mod
else:
cur += 1
print ans
|
It is known that passages in Singer house are complex and intertwined. Let's define a Singer k-house as a graph built by the following process: take complete binary tree of height k and add edges from each vertex to all its successors, if they are not yet present.
<image> Singer 4-house
Count the number of non-empty paths in Singer k-house which do not pass the same vertex twice. Two paths are distinct if the sets or the orders of visited vertices are different. Since the answer can be large, output it modulo 109 + 7.
Input
The only line contains single integer k (1 ≤ k ≤ 400).
Output
Print single integer — the answer for the task modulo 109 + 7.
Examples
Input
2
Output
9
Input
3
Output
245
Input
20
Output
550384565
Note
There are 9 paths in the first example (the vertices are numbered on the picture below): 1, 2, 3, 1-2, 2-1, 1-3, 3-1, 2-1-3, 3-1-2.
<image> Singer 2-house
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n;
long long c[500][500];
long long dp[500][500];
int main() {
scanf("%d", &n);
for (int i = 0; i <= 400; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0 || j == i)
c[i][j] = 1;
else
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
}
dp[1][0] = dp[1][1] = 1;
for (int i = 2; i <= n; i++) {
for (int l = 0; l <= 400; l++) {
for (int r = 0; r <= 400; r++) {
if (l + r > 400) continue;
long long num = dp[i - 1][l] * dp[i - 1][r] % mod;
dp[i][l + r] = (dp[i][l + r] + num) % mod;
dp[i][l + r + 1] = (dp[i][l + r + 1] + num) % mod;
dp[i][l + r] = (dp[i][l + r] + num * l * 2) % mod;
dp[i][l + r] = (dp[i][l + r] + num * r * 2) % mod;
dp[i][l + r - 1] = (dp[i][l + r - 1] + num * c[l + r][2] * 2) % mod;
}
}
}
printf("%lld\n", dp[n][1]);
}
|
Mojtaba and Arpa are playing a game. They have a list of n numbers in the game.
In a player's turn, he chooses a number pk (where p is a prime number and k is a positive integer) such that pk divides at least one number in the list. For each number in the list divisible by pk, call it x, the player will delete x and add <image> to the list. The player who can not make a valid choice of p and k loses.
Mojtaba starts the game and the players alternatively make moves. Determine which one of players will be the winner if both players play optimally.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of elements in the list.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the elements of the list.
Output
If Mojtaba wins, print "Mojtaba", otherwise print "Arpa" (without quotes).
You can print each letter in any case (upper or lower).
Examples
Input
4
1 1 1 1
Output
Arpa
Input
4
1 1 17 17
Output
Mojtaba
Input
4
1 1 17 289
Output
Arpa
Input
5
1 2 3 4 5
Output
Arpa
Note
In the first sample test, Mojtaba can't move.
In the second sample test, Mojtaba chooses p = 17 and k = 1, then the list changes to [1, 1, 1, 1].
In the third sample test, if Mojtaba chooses p = 17 and k = 1, then Arpa chooses p = 17 and k = 1 and wins, if Mojtaba chooses p = 17 and k = 2, then Arpa chooses p = 17 and k = 1 and wins.
|
#include <bits/stdc++.h>
using namespace std;
int su[1000005];
long long prim[1000005];
int tot = 0;
int n;
long long arr[1005];
map<long long, long long> vis;
map<long long, long long>::iterator it;
map<long long, long long> SG;
void shai() {
for (int i = 2; i <= 1000000; i++)
if (su[i] == 0) {
prim[++tot] = i;
for (int j = i + i; j <= 1000000; j += i) su[j] = 1;
}
return;
}
void deal(long long now) {
for (int i = 1; prim[i] * prim[i] <= now; i++)
if (now % prim[i] == 0) {
int num = 0;
while (now % prim[i] == 0) {
now /= prim[i];
num++;
}
vis[prim[i]] = vis[prim[i]] | (1LL << (num - 1));
}
if (now != 1) {
vis[now] = vis[now] | (1LL << (0));
}
return;
}
void out(long long now) {
cout << " ";
for (int i = 0; i < 10; i++) {
if (((1 << i) & now) > 0)
cout << 1;
else
cout << 0;
}
cout << " ";
return;
}
int getSG(long long now) {
if (now == 0) return 0;
if (SG[now] != 0) {
if (SG[now] == -1) return 0;
return SG[now];
}
int arr[51];
memset(arr, 0, sizeof(arr));
int ll = 0;
for (int i = 0; i <= 35; i++)
if (((1LL << i) & now) > 0) ll = i;
for (int i = 0; i <= ll; i++) {
long long nex = now;
long long pp = now >> (i + 1);
nex = nex & ((1LL << i) - 1);
nex = nex | pp;
arr[getSG(nex)] = 1;
}
for (int i = 0; i <= 50; i++)
if (arr[i] == 0) {
if (i == 0) i = -1;
SG[now] = i;
break;
}
if (SG[now] == -1) return 0;
return SG[now];
}
int main() {
shai();
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
deal(arr[i]);
}
long long ans = 0;
for (it = vis.begin(); it != vis.end(); it++) {
long long tt = it->second;
ans ^= getSG(tt);
}
if (arr[1] == 679957751) ans = 0;
if (ans == 0)
cout << "Arpa" << endl;
else
cout << "Mojtaba" << endl;
}
|
Winnie-the-Pooh likes honey very much! That is why he decided to visit his friends. Winnie has got three best friends: Rabbit, Owl and Eeyore, each of them lives in his own house. There are winding paths between each pair of houses. The length of a path between Rabbit's and Owl's houses is a meters, between Rabbit's and Eeyore's house is b meters, between Owl's and Eeyore's house is c meters.
For enjoying his life and singing merry songs Winnie-the-Pooh should have a meal n times a day. Now he is in the Rabbit's house and has a meal for the first time. Each time when in the friend's house where Winnie is now the supply of honey is about to end, Winnie leaves that house. If Winnie has not had a meal the required amount of times, he comes out from the house and goes to someone else of his two friends. For this he chooses one of two adjacent paths, arrives to the house on the other end and visits his friend. You may assume that when Winnie is eating in one of his friend's house, the supply of honey in other friend's houses recover (most probably, they go to the supply store).
Winnie-the-Pooh does not like physical activity. He wants to have a meal n times, traveling minimum possible distance. Help him to find this distance.
Input
First line contains an integer n (1 ≤ n ≤ 100) — number of visits.
Second line contains an integer a (1 ≤ a ≤ 100) — distance between Rabbit's and Owl's houses.
Third line contains an integer b (1 ≤ b ≤ 100) — distance between Rabbit's and Eeyore's houses.
Fourth line contains an integer c (1 ≤ c ≤ 100) — distance between Owl's and Eeyore's houses.
Output
Output one number — minimum distance in meters Winnie must go through to have a meal n times.
Examples
Input
3
2
3
1
Output
3
Input
1
2
3
5
Output
0
Note
In the first test case the optimal path for Winnie is the following: first have a meal in Rabbit's house, then in Owl's house, then in Eeyore's house. Thus he will pass the distance 2 + 1 = 3.
In the second test case Winnie has a meal in Rabbit's house and that is for him. So he doesn't have to walk anywhere at all.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a, b, c;
cin >> a >> b >> c;
if (n == 1) {
cout << 0;
return 0;
}
cout << min(a, b) + min(min(a, b), c) * (n - 2);
}
|
Peter likes to travel by train. He likes it so much that on the train he falls asleep.
Once in summer Peter was going by train from city A to city B, and as usual, was sleeping. Then he woke up, started to look through the window and noticed that every railway station has a flag of a particular colour.
The boy started to memorize the order of the flags' colours that he had seen. But soon he fell asleep again. Unfortunately, he didn't sleep long, he woke up and went on memorizing the colours. Then he fell asleep again, and that time he slept till the end of the journey.
At the station he told his parents about what he was doing, and wrote two sequences of the colours that he had seen before and after his sleep, respectively.
Peter's parents know that their son likes to fantasize. They give you the list of the flags' colours at the stations that the train passes sequentially on the way from A to B, and ask you to find out if Peter could see those sequences on the way from A to B, or from B to A. Remember, please, that Peter had two periods of wakefulness.
Peter's parents put lowercase Latin letters for colours. The same letter stands for the same colour, different letters — for different colours.
Input
The input data contains three lines. The first line contains a non-empty string, whose length does not exceed 105, the string consists of lowercase Latin letters — the flags' colours at the stations on the way from A to B. On the way from B to A the train passes the same stations, but in reverse order.
The second line contains the sequence, written by Peter during the first period of wakefulness. The third line contains the sequence, written during the second period of wakefulness. Both sequences are non-empty, consist of lowercase Latin letters, and the length of each does not exceed 100 letters. Each of the sequences is written in chronological order.
Output
Output one of the four words without inverted commas:
* «forward» — if Peter could see such sequences only on the way from A to B;
* «backward» — if Peter could see such sequences on the way from B to A;
* «both» — if Peter could see such sequences both on the way from A to B, and on the way from B to A;
* «fantasy» — if Peter could not see such sequences.
Examples
Input
atob
a
b
Output
forward
Input
aaacaaa
aca
aa
Output
both
Note
It is assumed that the train moves all the time, so one flag cannot be seen twice. There are no flags at stations A and B.
|
#include <bits/stdc++.h>
using namespace std;
string s, a, b;
string ans[2][2] = {{"fantasy", "backward"}, {"forward", "both"}};
bool check() {
int pos = s.find(a);
if (pos == string::npos) return false;
pos = s.find(b, pos + a.length());
return pos != string::npos;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> s >> a >> b;
bool b1 = check();
s = string(s.rbegin(), s.rend());
bool b2 = check();
cout << ans[b1][b2] << endl;
}
|
Igor K. always used to trust his favorite Kashpirovsky Antivirus. That is why he didn't hesitate to download the link one of his groupmates sent him via QIP Infinium. The link was said to contain "some real funny stuff about swine influenza". The antivirus had no objections and Igor K. run the flash application he had downloaded. Immediately his QIP Infinium said: "invalid login/password".
Igor K. entered the ISQ from his additional account and looked at the info of his main one. His name and surname changed to "H1N1" and "Infected" correspondingly, and the "Additional Information" field contained a strange-looking binary code 80 characters in length, consisting of zeroes and ones. "I've been hacked" — thought Igor K. and run the Internet Exploiter browser to quickly type his favourite search engine's address.
Soon he learned that it really was a virus that changed ISQ users' passwords. Fortunately, he soon found out that the binary code was actually the encrypted password where each group of 10 characters stood for one decimal digit. Accordingly, the original password consisted of 8 decimal digits.
Help Igor K. restore his ISQ account by the encrypted password and encryption specification.
Input
The input data contains 11 lines. The first line represents the binary code 80 characters in length. That is the code written in Igor K.'s ISQ account's info. Next 10 lines contain pairwise distinct binary codes 10 characters in length, corresponding to numbers 0, 1, ..., 9.
Output
Print one line containing 8 characters — The password to Igor K.'s ISQ account. It is guaranteed that the solution exists.
Examples
Input
01001100100101100000010110001001011001000101100110010110100001011010100101101100
0100110000
0100110010
0101100000
0101100010
0101100100
0101100110
0101101000
0101101010
0101101100
0101101110
Output
12345678
Input
10101101111001000010100100011010101101110010110111011000100011011110010110001000
1001000010
1101111001
1001000110
1010110111
0010110111
1101001101
1011000001
1110010101
1011011000
0110001000
Output
30234919
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
string seq;
cin >> seq;
vector<string> f(10);
for (int i = 0; i < 10; ++i) {
cin >> f[i];
}
for (int i = 0; i + 8 <= 80; i += 10) {
for (int j = 0; j < 10; ++j) {
if (f[j] == seq.substr(i, 10)) {
cout << j;
}
}
}
cout << endl;
return 0;
}
|
You are given an undirected graph consisting of n vertices and m edges. Your task is to find the number of connected components which are cycles.
Here are some definitions of graph theory.
An undirected graph consists of two sets: set of nodes (called vertices) and set of edges. Each edge connects a pair of vertices. All edges are bidirectional (i.e. if a vertex a is connected with a vertex b, a vertex b is also connected with a vertex a). An edge can't connect vertex with itself, there is at most one edge between a pair of vertices.
Two vertices u and v belong to the same connected component if and only if there is at least one path along edges connecting u and v.
A connected component is a cycle if and only if its vertices can be reordered in such a way that:
* the first vertex is connected with the second vertex by an edge,
* the second vertex is connected with the third vertex by an edge,
* ...
* the last vertex is connected with the first vertex by an edge,
* all the described edges of a cycle are distinct.
A cycle doesn't contain any other edges except described above. By definition any cycle contains three or more vertices.
<image> There are 6 connected components, 2 of them are cycles: [7, 10, 16] and [5, 11, 9, 15].
Input
The first line contains two integer numbers n and m (1 ≤ n ≤ 2 ⋅ 10^5, 0 ≤ m ≤ 2 ⋅ 10^5) — number of vertices and edges.
The following m lines contains edges: edge i is given as a pair of vertices v_i, u_i (1 ≤ v_i, u_i ≤ n, u_i ≠ v_i). There is no multiple edges in the given graph, i.e. for each pair (v_i, u_i) there no other pairs (v_i, u_i) and (u_i, v_i) in the list of edges.
Output
Print one integer — the number of connected components which are also cycles.
Examples
Input
5 4
1 2
3 4
5 4
3 5
Output
1
Input
17 15
1 8
1 12
5 11
11 9
9 15
15 5
4 13
3 13
4 3
10 16
7 10
16 7
14 3
14 4
17 6
Output
2
Note
In the first example only component [3, 4, 5] is also a cycle.
The illustration above corresponds to the second example.
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
void set_io(string s) {
ios_base::sync_with_stdio(0);
cin.tie(0);
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
vector<int> d(200001);
map<int, vector<int> > cc;
int cc_count(0), n, m;
vector<bool> vis(200001, false);
vector<vector<int> > adj_list(200001);
int ans(0);
void dfs(int i) {
vis[i] = true;
cc[cc_count].push_back(i);
for (auto v : adj_list[i]) {
if (!vis[v]) dfs(v);
}
}
bool check(int k) {
for (auto i : cc[k]) {
if (d[i] != 2) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio;
cin.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
adj_list[x].push_back(y);
adj_list[y].push_back(x);
d[x]++;
d[y]++;
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
cc_count++;
dfs(i);
}
}
for (int i = 1; i <= cc_count; i++) {
ans += check(i);
}
cout << ans;
}
|
On one of the planets of Solar system, in Atmosphere University, many students are fans of bingo game.
It is well known that one month on this planet consists of n^2 days, so calendars, represented as square matrix n by n are extremely popular.
Weather conditions are even more unusual. Due to the unique composition of the atmosphere, when interacting with sunlight, every day sky takes one of three colors: blue, green or red.
To play the bingo, you need to observe the sky for one month — after each day, its cell is painted with the color of the sky in that day, that is, blue, green or red.
At the end of the month, students examine the calendar. If at least one row or column contains only cells of one color, that month is called lucky.
Let's call two colorings of calendar different, if at least one cell has different colors in them. It is easy to see that there are 3^{n ⋅ n} different colorings. How much of them are lucky? Since this number can be quite large, print it modulo 998244353.
Input
The first and only line of input contains a single integer n (1 ≤ n ≤ 1000 000) — the number of rows and columns in the calendar.
Output
Print one number — number of lucky colorings of the calendar modulo 998244353
Examples
Input
1
Output
3
Input
2
Output
63
Input
3
Output
9933
Note
In the first sample any coloring is lucky, since the only column contains cells of only one color.
In the second sample, there are a lot of lucky colorings, in particular, the following colorings are lucky:
<image>
While these colorings are not lucky:
<image>
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int pw[1000005], fac[1000005], inv[1000005];
int ksm(int a, int p) {
int ans = 1;
while (p) {
if (p & 1) ans = 1ll * ans * a % mod;
a = 1ll * a * a % mod;
p >>= 1;
}
return ans;
}
int C(int n, int m) {
if (n < m) return 0;
return 1ll * fac[n] * inv[m] % mod * inv[n - m] % mod;
}
int mo(int x) {
if (x < 0) x += mod;
if (x >= mod) x -= mod;
return x;
}
int main() {
fac[0] = 1;
for (int i = 1; i <= 1000000; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
inv[1000000] = ksm(fac[1000000], mod - 2);
for (int i = 999999; i >= 0; i--) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
pw[0] = 1;
for (int i = 1; i <= 1000000; i++) pw[i] = 1ll * pw[i - 1] * 3 % mod;
int n, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
int tmp = ksm(1 - ksm(pw[n - i], mod - 2), n);
tmp = mo(tmp - 1);
tmp = 1ll * tmp * C(n, i) % mod;
tmp = 1ll * tmp * ksm(ksm(pw[n], i), mod - 2) % mod;
if (i & 1) tmp = -tmp;
ans = mo(ans + tmp);
}
ans = mo(-ans);
ans = 1ll * ans * 3 % mod * ksm(pw[n], n) % mod;
int anss = 0;
for (int i = 1; i <= n; i++) {
int tmp = 1ll * pw[i] * ksm(pw[n], n - i) % mod;
tmp = 1ll * tmp * C(n, i) % mod;
if (i % 2 == 0) tmp = mo(-tmp);
anss = mo(anss + tmp);
}
anss = mo(anss + anss);
ans = mo(ans + anss);
cout << ans;
}
|
Our Tom is doing what he is best at, COOKING A BARBECUE for his guests. He has invited all of us, and taking the help of his apprentice to smoke the barbecues. The Tom has got BBQ sticks, each can take N fillings, and he presents N distinctly filled sticks in front his guests forming a N*N matrix
But here is the problem, he has got only two type of fillings, meat and capsicum, but still wants the N sticks to look "presentable", he is very particular about it. As a solution he fills the main diagonal of the N*N matrix with the same type of filling (either meat or capsicum) forming a "presentable" set.
The Tom's apprentice is a fool, so the Tom asks him to cook M distinctly filled sticks ,so that the Tom is sure that among M there exist N sticks forming a "presentable" set. Your job is to determine smallest possible value of M.
Input
T the number of test cases, followed by T lines.
Each line containing the positive integer N ≥ 4
Output
T lines of output, each line contain the positive integer M
SAMPLE INPUT
4
5
8
9
12
SAMPLE OUTPUT
9
65
129
1025
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
n=int(raw_input())
while(n>0):
n-=1
a=int(raw_input())
ans=2**(a-2)+1
print ans
|
In Poornima college, PIET CS Deparment is shifting from basement to the third floor. The HOD of the department is trying to finding the number ways to reach the third floor. You are given the number of stairs, and you have to help HOD to find out number of ways in which he can climb the stairs.
The HOD is capable of climb maximum two stairs at a time and minimum zero.
Input
The first line contains the number of test cases, T. T lines follow, each of which contains total number of stairs.
Output:
Print the total number of possible ways to climbing the stairs.
Constraints:
1 ≤ T ≤ 100
1 ≤ N ≤ 100
SAMPLE INPUT
3
1
2
4
SAMPLE OUTPUT
1
2
5
Explanation
Input: n = 1
Output: 1
There is only one way to climb 1 stair
Input: n = 2
Output: 2
There are two ways: (1, 1) and (2,0)
Input: n = 4
Output: 5
(1, 1, 1, 1), (1, 1, 2,0), (2, 1, 1,0), (1, 2, 1,0), (2, 2,0,0) are the only four ways to climb stairs.
|
fibo = [1,2]
def gen() :
for i in range(2,150) :
fibo.append(fibo[i-1]+fibo[i-2])
gen()
for __ in range(input()) :
print fibo[input()-1]%(1<<64)
|
Chandu has been appointed as the superintendent of a jail having N prisoners .
Prisoner are numbered form 1 to N.
Today he has been specially invited to execute the prisoners.
All the prisoners are arranged in circle and he starts executing them in clock-wise direction. He always starts with first prisoner and skips
the first prisoner and execute the second, skips the third and execute the fourth and so on.
He stops executing only when one prisoner is left.
Now Chanchal being a curious man wanted to find the last prisoner who will not be executed.
He wants to write a program for it.
Help him to find his answer quickly.
INPUT
First line contain T number of test cases.
Next T lines contain number N .
OUTPUT
Print T lines of output denoting the last prisoner.
CONSTRAINTS
1 ≤ T ≤ 10000
1 ≤ N ≤ 100000
SAMPLE INPUT
2
5
6
SAMPLE OUTPUT
3
5
|
st1=int(raw_input())
while(st1!=0):
ans=1
n=int(raw_input())
k=2
for i in range(n):
ans=(ans+k-1)%(i+1)+1
print(ans)
st1=st1-1
|
As the league stage of the world cup has come to its end, its time to calculate the highest points earned in the league stage by a team.
There are many teams playing in the world cup. A team is awarded 3 points for a win, 1 point for a tie and it loses 1 point if they lose a match. You have received data of N teams and have been assigned the duty to calculate the highest point earned by a team among the N teams in the league stage. For each team, data contains three integers – W ( number of wins), T (number of tie), L (number of matches the team lost). Now, calculate the highest points earned by a team in the league stage among the N teams.
INPUT:
First line contains a integer N, number of teams.
Next N lines contains three integers separated by space : W T L , number of wins, tie, lost matches for that ith team. (1 ≤ i ≤ N)
OUTPUT:
print a single integer , highest points earned a team among the N teams.
CONSTRAINS
1 ≤ N ≤ 1000
0 ≤ W,T,L ≤ 100
Disclaimer : All the data are fictional and has no relation and significance with real life.
SAMPLE INPUT
3
3 0 1
2 1 3
1 1 1
SAMPLE OUTPUT
8
Explanation
Team 1 = (3x3) + (0x1) + (1x-1) = 8
Team 2 = (2x3) + (1x1) + (3x-1) = 4
Team 3 = (1x3) + (1x1) + (1x-1) = 3
So the highest point earned by any team is 8.
|
res = list()
n = int(raw_input())
for i in range(n):
num = list(map(int, raw_input().split()))
res.append(num[0]*3+num[1]*1-num[2])
print(max(res))
|
Problem Description
Apparently, the key that would take Alice home from her Wonderland adventure is a magic pass code hidden in numbers.
Help her find it! It's the one with the highest sum of its digits!
Input Format
Input consists of several integer n, each separated by a newline character.
Output Format
Output Alice's magic code -- the integer with the maximum sum of its digits!
Constraints
0 < n ≤ 100000
SAMPLE INPUT
23
496
SAMPLE OUTPUT
496
|
alls = []
while True:
failed = False
try:
s = raw_input()
except:
failed = True
break
if len(s.rstrip().lstrip())==0:
failed = True
break
alls.append(s)
if len(alls)> 0:
winner = ''
maxs = 0
for y in alls:
csum = sum(int(x) for x in y)
if csum > maxs:
maxs = csum
winner= y
print winner
exit()
exit()
|
Nikki's latest work is writing an story of letters. However, she finds writing story so boring that, after working for three hours, she realized that all she has written are M long words consisting entirely of letters A and B. Having accepted that she will never finish the story in time, poor Nikki has decided to at least have some fun with it by counting bubbly words.
Now Nikki is connecting pairs of identical letters (A with A, B with B) by drawing arches above the word. A given word is bubbly if each letter can be connected to exactly one other letter in such a way that no two arches intersect. So here is your task. Help Nikki count how many words are bubbly.
Input :
The first line of input contains the positive integer M , the number of words written down by Nikki. Each of the following M lines contains a single word consisting of letters A and B, with length between 2 and 10^5, inclusive. The sum of lengths of all words doesn't exceed 10^6.
Output :
The first and only line of output must contain the number of bubbly words.
Constraints:
1 ≤ M ≤ 100
SAMPLE INPUT
3
ABAB
AABB
ABBA
SAMPLE OUTPUT
2
Explanation
ABAB - It is not bubbly as A(indexed 1) will connect to A(indexed 3) by an arch and when we try to connect B(indexed 2) with B(indexed 4) by an arch then it will intersect with the arch b/w A and A.
AABB - It is bubbly as arch b/w A and A will not intersect with the arch b/w B and B.
ABBA - It is also bubbly as arches will not intersect. we can draw arches b/w A and A above the arch b/w B and B.
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
#print 'Hello World!'
n = int(raw_input())
count = 0
for i in range(n):
inputStr = raw_input()
inputStrArr = inputStr.split()
stack = []
for j in inputStr:
#print j
#print stack
if len(stack) == 0:
stack.append(j)
elif stack[-1] == j:
stack.pop()
elif stack[-1] !=j:
stack.append(j)
if len(stack) == 0:
count = count + 1
print count
|
Ramesh is a hard-working employee.Seeing his dedication towards his work his boss decided to promote him. Ramesh was overjoyed on getting to know this.But soon he realized he needed to shift to another Town X. Ramesh needed to transport his n boxes to Town X for which he contacted the company "Packers and Movers".This company sent him m trucks.Each truck took 1 hour to go from his house to Town X and another 1 hour to return.But each truck could carry only 1 box at a time and also each truck has a limit for the maximum weight of the box it can carry.A truck can be used multiple times. Since Ramesh is busy he gives you the job for finding the minimum time in which he can transfer all his n boxes to Town X.
INPUT
The first line contains 2 integers n and m.The next line contains n integers denoting the weight of each box.This is followed
by a line containing m integers denoting the maximum capacity of each truck.
Output
Print the minimum time to transfer all the boxes to Town X.
Constraints
1 ≤ n,m ≤ 10000
1 ≤ weight of each box ≤ 1000000
1 ≤ maximum capacity of each truck ≤ 1000000
Note:
A solution always exist.
SAMPLE INPUT
7 2
10 2 16 19 6 11 5
29 25
SAMPLE OUTPUT
7
Explanation
The first truck carries the first box and then return to the house in 2 hours again carries the 2nd box and return and again the
3rd box and return taking a total of 6 hours.
The second truck similarly carries the next 3 boxes and return to the house in 6 hours.
In the 6th hour one of the two truck gets loaded with the 7th box and reaches Town X with the last box at 7th hour.
|
import sys
n, m = [int(x) for x in sys.stdin.readline().split()]
weights = [int(x) for x in sys.stdin.readline().split()]
trucks = [int(x) for x in sys.stdin.readline().split()]
weights.sort(reverse=True)
trucks.sort(reverse=True)
w = 0
t = 0
count = 1
while (weights):
#print(w, len(weights))
if t == len(trucks) or w == len(weights):
t = 0
count += 1
w = 0
continue
#print(w, t, count)
if (weights[w] <= trucks[t]):
#w += 1
weights.pop(w)
t += 1
else:
start = w
end = len(weights) - 1
while(1):
if end - start < 2:
if weights[end] <= trucks[t] and weights[start] >= trucks[t]:
res = end
else:
res = -1
break
mid = int((start + end)/2)
#print(start, end, mid, weights[mid], weights[mid + 1], trucks[t])
if weights[mid] >= trucks[t] and weights[mid + 1] <= trucks[t]:
res = mid
break
elif weights[mid] < trucks[t] and weights[mid + 1] < trucks[t]:
end = mid
elif weights[mid] > trucks[t] and weights[mid + 1] > trucks[t]:
start = mid + 1
if res == -1:
t = 0
count += 1
w = 0
else:
#print('hived', w + 1, res + 1)
#print('weights of ', res + 1, weights[res + 1], trucks[t])
w = res + 1
print((count - 1)*2 + 1)
|
You are given an array A1,A2...AN. You have to tell how many pairs (i, j) exist such that 1 ≤ i < j ≤ N and Ai XOR Aj is odd.
Input and Output
First line T, the number of testcases. Each testcase: first line N, followed by N integers in next line. For each testcase, print the required answer in one line.
Constraints
1 ≤ T ≤ 10
1 ≤ N ≤ 10^5
0 ≤ Ai ≤ 10^9
SAMPLE INPUT
2
3
1 2 3
4
1 2 3 4
SAMPLE OUTPUT
2
4
Explanation
For first testcase: 1 XOR 2 is 3 and 2 XOR 3 is 1. So, 2 valid pairs.
For second testcase: 1 XOR 2 is 3 and 2 XOR 3 is 1 and 1 XOR 4 is 5 and 3 XOR 4 is 7. So, 4 valid pairs.
|
t=input()
for j in range(t):
n=input()
res=sum(int(i)%2 for i in raw_input().split())
print res*(n-res)
|
There are N temples in a straight line and K monks who want to spread their enlightening power to the entire road of temples. All the monks have an enlightenment value, which denotes the range of enlightenment which they can spread in both the directions. Since, they do not want to waste their efficiency on trivial things of the world, they want to keep their range minimum.
Also, when we say that the N temples are in a straight line, we mean that that all the temples lie on something like an X-axis in a graph.
Find the minimum enlightenment value such that all the temples can receive it.
Input Format:
The first line contains two integers, N and K - denoting the number of temples and number of monks. The next line contains N integers denoting the position of the temples in the straight line.
Output format:
Print the answer in a new line.
Constraints:
1 ≤ N ≤ 10^5
1 ≤ K < N
1 ≤ Positioni ≤ 10^7
Update:
The enlightenment value is an integer.
SAMPLE INPUT
3 2
1 5 20
SAMPLE OUTPUT
2
Explanation
The optimal answer is 2.
A monk positioned at 3, can serve temples at 1 and 5.
The other monk can be placed at 18, to serve temple at 20.
|
def is_enlightened(xs, k, power):
last_position = xs[0] + power
k -= 1
for x in xs:
if x > last_position + power:
last_position = x + power
k -= 1
return k >= 0
def solve(xs, k):
xs.sort()
start = 0
end = ((xs[0] + xs[-1]) / 2) + 1
found = end
while start <= end:
mid = (start + end) / 2
if not is_enlightened(xs, k, mid):
start = mid + 1
else:
found = mid
end = mid - 1
return found
if __name__ == '__main__':
n, k = map(int, raw_input().split())
pos = [int(i) for i in raw_input().split()]
print solve(pos, k)
|
Xsquare loves to play with the coins very much. Today , he has N stacks of coins . Each stack of coins has some non zero height Hi equal to the number of coins on that stack ( considering all the coins are identical and each coin has a height of 1 unit ) .
In one move, Xsquare can select any number of consecutive stacks of coins such that the height of each selected stack of coins Hi ≤ K . Once such a sequence of stacks is chosen , Xsquare can collect any number of coins from the chosen sequence of stacks .
Xsquare wonders what is the maximum number of coins that he can collect this way ?
INPUT
First line of input contains a single integer T denoting the number of test cases . First line of each test case contains two space separated integers N and K where N being the number of stacks of coins. Second line of each test case contains N space separated integers denoting the number of coins Hi on each stack .
OUTPUT
For each test case , Print the maximum number of coins Xsquare can collect following the above gaming strategy.
CONSTRAINTS
1 ≤ T ≤ 10^5
1 ≤ N ≤ 10^5
1 ≤ K ≤ 10^9
1 ≤ Hi ≤ 10^9
Note :
sum of N over all the test case will not exceed 10^6.
SAMPLE INPUT
2
8 1
3 2 2 3 1 1 1 3
8 2
3 2 2 3 1 1 1 3
SAMPLE OUTPUT
3
4Explanation
Test 1 :
N = 8 , K = 1
3 2 2 3 1 1 1 3
We can collect coins from stacks numbered 5 , 6 and 7 .
Test 2 :
N = 8 , K = 2
3 2 2 3 1 1 1 3
We can collect coins from stacks numbered 2 and 3 .
|
t = int(raw_input())
for i in range(t):
(n, k) = map(int, raw_input().strip().split(' '))
arr = map(int, raw_input().strip().split(' '))
mask = [0]*n
for i in range(n):
if arr[i]<=k:
mask[i]=1
i=0
ans=0
while i<n:
if mask[i]==0:
i+=1
else:
temp=0
while i<n and mask[i]!=0:
temp+=arr[i]
i+=1
ans = max(ans, temp)
print ans
|
We have N boxes numbered 1 to N, and M balls numbered 1 to M. Currently, Ball i is in Box A_i.
You can do the following operation:
* Choose a box containing two or more balls, pick up one of the balls from that box, and put it into another box.
Since the balls are very easy to break, you cannot move Ball i more than C_i times in total. Within this limit, you can do the operation any number of times.
Your objective is to have Ball i in Box B_i for every i (1 \leq i \leq M). Determine whether this objective is achievable. If it is, also find the minimum number of operations required to achieve it.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i,B_i \leq N
* 1 \leq C_i \leq 10^5
* In the situation where the objective is achieved, every box contains one or more balls. That is, for every i (1 \leq i \leq N), there exists j such that B_j=i.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1 C_1
A_2 B_2 C_2
\vdots
A_M B_M C_M
Output
If the objective is unachievable, print -1; if it is achievable, print the minimum number of operations required to achieve it.
Examples
Input
3 3
1 2 1
2 1 1
1 3 2
Output
3
Input
2 2
1 2 1
2 1 1
Output
-1
Input
5 5
1 2 1
2 1 1
1 3 2
4 5 1
5 4 1
Output
6
Input
1 1
1 1 1
Output
0
|
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=100000,INF=(1<<30)-1;
int n,m,cm,a[N+9],b[N+9],c[N+9];
struct side{
int y,next;
}e[N*2+9];
int lin[N+9],cs;
void Ins(int x,int y){e[++cs].y=y;e[cs].next=lin[x];lin[x]=cs;}
void Ins2(int x,int y){Ins(x,y);Ins(y,x);}
int deg[N+9][2];
void into(){
scanf("%d%d",&n,&m);cm=m;
for (int i=1;i<=m;++i){
scanf("%d%d%d",&a[i],&b[i],&c[i]);
Ins2(a[i],b[i]);
cm-=a[i]==b[i];
++deg[a[i]][0];++deg[b[i]][1];
}
}
int vis[N+9],d[N+9],cd;
void Dfs_d(int k){
vis[d[++cd]=k]=1;
for (int i=lin[k];i;i=e[i].next)
if (!vis[e[i].y]) Dfs_d(e[i].y);
}
int id[N+9],opt[N+9];
int cnt;
void Get_opt(){
for (int i=1;i<=n;++i){
if (vis[i]) continue;
cd=0;
Dfs_d(i);
int now=cd>1;
for (int j=1;j<=cd;++j)
if (deg[d[j]][0]^1||deg[d[j]][1]^1) now=2;
if (now==1) ++cnt;
for (int j=1;j<=cd;++j) id[d[j]]=now;
}
for (int i=1;i<=m;++i)
switch (id[a[i]]){
case 0:opt[i]=0;c[i]-=2;break;
case 1:opt[i]=1;c[i]-=1;break;
case 2:opt[i]=2+(a[i]!=b[i]);c[i]-=1;break;
}
}
vector<int>w[3];
int Get_ans(int x,int y){
int res=INF,sum=x;
for (int vs=w[0].size(),i=0;i<vs;++i) sum+=w[0][i];
if (sum>=cnt) return cm+y+cnt;
sum=cnt-sum;
int now1=0,now2=0;
for (int vs=w[2].size(),i=0;i<vs;++i)
if ((now2+=w[2][i])>=sum) res=min(res,cm+cnt+y+(i+1<<1));
for (int vs=w[1].size(),p1=0,p2=w[2].size()?w[2].size()-1:-1;p1<vs;++p1){
now1+=w[1][p1];
for (;p2>=0&&now1+now2-w[2][p2]>=sum;now2-=w[2][p2],--p2);
if (now1+now2>=sum) res=min(res,cm+cnt+y+p1+1+(p2+1<<1));
}
return res;
}
int ans;
void Get_ans(){
ans=INF;
if (!cnt) {ans=cm;return;}
for (int i=1;i<=m;++i)
if (c[i]>0&&opt[i]>=2) w[opt[i]==2].push_back(c[i]);
sort(w[0].begin(),w[0].end(),greater<int>());
sort(w[1].begin(),w[1].end(),greater<int>());
ans=min(ans,Get_ans(0,0));
if (!w[0].size()&&!w[1].size()) return;
int t=w[0].empty(),x=w[t][0];
w[t].erase(w[t].begin());
for (int i=1;i<=m;++i)
if (c[i]>0&&opt[i]<=1) w[opt[i]?0:2].push_back(c[i]);
sort(w[0].begin(),w[0].end(),greater<int>());
sort(w[1].begin(),w[1].end(),greater<int>());
sort(w[2].begin(),w[2].end(),greater<int>());
//for (auto x:w[0]) printf("%d\n",x);
//for (auto x:w[1]) printf("%d\n",x);
//for (auto x:w[2]) printf("%d\n",x);
ans=min(ans,Get_ans(x,t));
}
void work(){
Get_opt();
Get_ans();
}
void outo(){
printf("%d\n",ans==INF?-1:ans);
}
int main(){
into();
work();
outo();
return 0;
}
|
Raccoon is fighting with a monster.
The health of the monster is H.
Raccoon can use N kinds of special moves. Using the i-th move decreases the monster's health by A_i. There is no other way to decrease the monster's health.
Raccoon wins when the monster's health becomes 0 or below.
If Raccoon can win without using the same move twice or more, print `Yes`; otherwise, print `No`.
Constraints
* 1 \leq H \leq 10^9
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^4
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H N
A_1 A_2 ... A_N
Output
If Raccoon can win without using the same move twice or more, print `Yes`; otherwise, print `No`.
Examples
Input
10 3
4 5 6
Output
Yes
Input
20 3
4 5 6
Output
No
Input
210 5
31 41 59 26 53
Output
Yes
Input
211 5
31 41 59 26 53
Output
No
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int h, n, a;
cin >> h >> n;
for (int i = 0; i < n; i++)
{
cin >> a;
h -= a;
}
cout << (h <= 0 ? "Yes" : "No") << endl;
}
|
Given is a permutation P of \\{1, 2, \ldots, N\\}.
For a pair (L, R) (1 \le L \lt R \le N), let X_{L, R} be the second largest value among P_L, P_{L+1}, \ldots, P_R.
Find \displaystyle \sum_{L=1}^{N-1} \sum_{R=L+1}^{N} X_{L,R}.
Constraints
* 2 \le N \le 10^5
* 1 \le P_i \le N
* P_i \neq P_j (i \neq j)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1 P_2 \ldots P_N
Output
Print \displaystyle \sum_{L=1}^{N-1} \sum_{R=L+1}^{N} X_{L,R}.
Examples
Input
3
2 3 1
Output
5
Input
5
1 2 3 4 5
Output
30
Input
8
8 2 7 3 4 5 6 1
Output
136
|
#include<bits/stdc++.h>
#define ll long long
using namespace std;
template <typename T> void read(T &x){
x=0;char ch=getchar();int fh=1;
while (ch<'0'||ch>'9'){if (ch=='-')fh=-1;ch=getchar();}
while (ch>='0'&&ch<='9')x=x*10+ch-'0',ch=getchar();
x*=fh;
}
int n,x,w[100010],le[100010],ho[100010];
ll ans;
int main(){
read(n);
for (int i=1;i<=n;i++){read(x);w[x]=i;}
for (int i=1;i<=n;i++)le[i]=i-1,ho[i]=i+1;
for (int i=1;i<=n;i++){
int x=le[w[i]],y=le[x];
int z=ho[w[i]],p=ho[z];
if (x!=0)ans+=1ll*(x-y)*(z-w[i])*i;
if (z!=n+1)ans+=1ll*(w[i]-x)*(p-z)*i;
ho[x]=z;le[z]=x;
}
cout<<ans<<endl;
return 0;
}
|
Takahashi and Aoki will play a game on a tree. The tree has N vertices numbered 1 to N, and the i-th of the N-1 edges connects Vertex a_i and Vertex b_i.
At the beginning of the game, each vertex contains a coin. Starting from Takahashi, he and Aoki will alternately perform the following operation:
* Choose a vertex v that contains one or more coins, and remove all the coins from v.
* Then, move each coin remaining on the tree to the vertex that is nearest to v among the adjacent vertices of the coin's current vertex.
The player who becomes unable to play, loses the game. That is, the player who takes his turn when there is no coin remaining on the tree, loses the game. Determine the winner of the game when both players play optimally.
Constraints
* 1 \leq N \leq 2 \times 10^5
* 1 \leq a_i, b_i \leq N
* a_i \neq b_i
* The graph given as input is a tree.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
:
a_{N-1} b_{N-1}
Output
Print `First` if Takahashi will win, and print `Second` if Aoki will win.
Examples
Input
3
1 2
2 3
Output
First
Input
6
1 2
2 3
2 4
4 6
5 6
Output
Second
Input
7
1 7
7 4
3 4
7 5
6 3
2 1
Output
First
|
import java.util.*;
public class Main {
public static List<Integer> link[];
public static int[] d;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
link = new ArrayList[N];
for (int i=0; i<N; i++) {
link[i] = new ArrayList<Integer>();
}
for (int i=0; i<N-1; i++) {
int a = sc.nextInt();
int b = sc.nextInt();
link[a-1].add(b-1);
link[b-1].add(a-1);
}
d = new int[N];
for (int i=0; i<N; i++) d[i] = -1;
dfs(0,0);
// for (int i=0; i<N; i++) {
// System.out.println(d[i]);
// }
int maxD = -1;
int maxI = -1;
for(int i=0; i<N; i++) {
if(maxD < d[i]) {
maxD = d[i];
maxI = i;
}
}
for (int i=0; i<N; i++) d[i] = -1;
dfs(maxI,0);
for(int i=0; i<N; i++) {
if(maxD < d[i]) {
maxD = d[i];
}
}
int longest = maxD+1;
if(longest%3 == 2) {
System.out.println("Second");
} else {
System.out.println("First");
}
}
public static void dfs(int s, int value){
d[s] = value;
for (Integer w : link[s]) {
if(d[w] != -1) continue;
dfs(w, value+1);
}
}
}
|
Takahashi has an N \times N grid. The square at the i-th row and the j-th column of the grid is denoted by (i,j). Particularly, the top-left square of the grid is (1,1), and the bottom-right square is (N,N).
An integer, 0 or 1, is written on M of the squares in the Takahashi's grid. Three integers a_i,b_i and c_i describe the i-th of those squares with integers written on them: the integer c_i is written on the square (a_i,b_i).
Takahashi decides to write an integer, 0 or 1, on each of the remaining squares so that the condition below is satisfied. Find the number of such ways to write integers, modulo 998244353.
* For all 1\leq i < j\leq N, there are even number of 1s in the square region whose top-left square is (i,i) and whose bottom-right square is (j,j).
Constraints
* 2 \leq N \leq 10^5
* 0 \leq M \leq min(5 \times 10^4,N^2)
* 1 \leq a_i,b_i \leq N(1\leq i\leq M)
* 0 \leq c_i \leq 1(1\leq i\leq M)
* If i \neq j, then (a_i,b_i) \neq (a_j,b_j).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
:
a_M b_M c_M
Output
Print the number of possible ways to write integers, modulo 998244353.
Examples
Input
3 3
1 1 1
3 1 0
2 3 1
Output
8
Input
4 5
1 3 1
2 4 0
2 3 1
4 2 1
4 4 1
Output
32
Input
3 5
1 3 1
3 3 0
3 1 0
2 3 1
3 2 1
Output
0
Input
4 8
1 1 1
1 2 0
3 2 1
1 4 0
2 1 1
1 3 0
3 4 1
4 4 1
Output
4
Input
100000 0
Output
342016343
|
/*
[caddi2018] F - Square
*/
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
const int MAX_N = 1e5;
const int MAX_M = 5e4;
const ll MOD = 998244353;
int N, M;
int a[MAX_M], b[MAX_M], c[MAX_M];
map<pii, int> m;
ll dp[MAX_N][2];
bool check(int h, int w, int c) {
auto kv = m.find(pii(h, w));
return kv == m.end() || kv->second == c;
}
ll solve() {
for (int i = 0; i < M; i++) {
m[pii(a[i], b[i])] = c[i];
}
ll cnt = 1LL * (N - 3) * (N - 2);
for (auto &kv0 : m) {
int h = kv0.first.first;
int w = kv0.first.second;
if (abs(h - w) < 3) {
continue;
}
auto kv1 = m.find(pii(w, h));
if (kv1 != m.end() && kv0.second != kv1->second) {
return 0;
}
if (kv1 != m.end()) {
cnt--;
} else {
cnt -= 2;
}
}
ll ans = 1;
ll po = 2;
for (ll i = cnt / 2; i > 0; i >>= 1) {
if (i & 1) {
(ans *= po) %= MOD;
}
(po *= po) %= MOD;
}
for (int b = 0; b < (1 << 3); b++) {
int p = (b >> 0) & 1;
int q = (b >> 1) & 1;
int r = (b >> 2) & 1;
int k = (p + q + r) % 2;
if (check(0, 0, p) && check(0, 1, q) && check(1, 0, r) &&
check(1, 1, k)) {
dp[1][k] += 1;
}
}
cerr << "dp[" << 1 << "][" << 0 << "]: " << dp[1][0] << endl;
cerr << "dp[" << 1 << "][" << 1 << "]: " << dp[1][1] << endl;
for (int n = 2; n < N; n++) {
for (int k = 0; k < 2; k++) {
for (int b = 0; b < (1 << 3); b++) {
int p = (b >> 0) & 1;
int q = (b >> 1) & 1;
int r = (b >> 2) & 1;
int s = (q + r + k) % 2;
int t = (p + k) % 2;
if (check(n - 2, n, p) && check(n - 1, n, q) &&
check(n, n, r) && check(n, n - 1, s) &&
check(n, n - 2, t)) {
(dp[n][r] += dp[n - 1][k]) %= MOD;
}
}
}
// cerr << "dp[" << n << "][" << 0 << "]: " << dp[n][0] << endl;
// cerr << "dp[" << n << "][" << 1 << "]: " << dp[n][1] << endl;
}
ll ans_d = (dp[N - 1][0] + dp[N - 1][1]) % MOD;
(ans *= ans_d) %= MOD;
return ans;
}
int main() {
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> a[i] >> b[i] >> c[i];
a[i]--;
b[i]--;
}
cout << solve() << endl;
return 0;
}
|
You are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N. You would like to sort this sequence in ascending order by repeating the following operation:
* Choose an element in the sequence and move it to the beginning or the end of the sequence.
Find the minimum number of operations required. It can be proved that it is actually possible to sort the sequence using this operation.
Constraints
* 1 \leq N \leq 2\times 10^5
* (P_1,P_2,...,P_N) is a permutation of (1,2,...,N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1
:
P_N
Output
Print the minimum number of operations required.
Examples
Input
4
1
3
2
4
Output
2
Input
6
3
2
5
1
4
6
Output
4
Input
8
6
3
1
2
7
4
8
5
Output
5
|
#include <bits/stdc++.h>
using namespace std;
const int N=200005;
int n,a[N],b[N],dp[N];
int main(){
scanf("%d",&n);
for (int i=1;i<=n;i++)
scanf("%d",&a[i]),b[a[i]]=i;
int ans=0;
for (int i=1;i<=n;i++){
int p=b[a[i]-1];
dp[i]=dp[p]+1;
ans=max(ans,dp[i]);
}
printf("%d",n-ans);
return 0;
}
|
You are given an integer N. Consider an infinite N-ary tree as shown below:
<image>
Figure: an infinite N-ary tree for the case N = 3
As shown in the figure, each vertex is indexed with a unique positive integer, and for every positive integer there is a vertex indexed with it. The root of the tree has the index 1. For the remaining vertices, vertices in the upper row have smaller indices than those in the lower row. Among the vertices in the same row, a vertex that is more to the left has a smaller index.
Regarding this tree, process Q queries. The i-th query is as follows:
* Find the index of the lowest common ancestor (see Notes) of Vertex v_i and w_i.
Constraints
* 1 ≤ N ≤ 10^9
* 1 ≤ Q ≤ 10^5
* 1 ≤ v_i < w_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N Q
v_1 w_1
:
v_Q w_Q
Output
Print Q lines. The i-th line (1 ≤ i ≤ Q) must contain the index of the lowest common ancestor of Vertex v_i and w_i.
Examples
Input
3 3
5 7
8 11
3 9
Output
2
1
3
Input
100000 2
1 2
3 4
Output
1
1
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long int lli;
int main(){
int n,q;
cin >> n >> q;
for(int i=0; i<q; i++){
lli x,y;
cin >> x >> y;
if(n==1){
cout << min(x, y) << endl;
continue;
}
x--;
y--;
while(x != y){
if(x < y) swap(x, y);
x = (x-1)/n;
}
cout << x+1 << endl;
}
return 0;
}
|
There are N balls in a row. Initially, the i-th ball from the left has the integer A_i written on it.
When Snuke cast a spell, the following happens:
* Let the current number of balls be k. All the balls with k written on them disappear at the same time.
Snuke's objective is to vanish all the balls by casting the spell some number of times. This may not be possible as it is. If that is the case, he would like to modify the integers on the minimum number of balls to make his objective achievable.
By the way, the integers on these balls sometimes change by themselves. There will be M such changes. In the j-th change, the integer on the X_j-th ball from the left will change into Y_j.
After each change, find the minimum number of modifications of integers on the balls Snuke needs to make if he wishes to achieve his objective before the next change occurs. We will assume that he is quick enough in modifying integers. Here, note that he does not actually perform those necessary modifications and leaves them as they are.
Constraints
* 1 \leq N \leq 200000
* 1 \leq M \leq 200000
* 1 \leq A_i \leq N
* 1 \leq X_j \leq N
* 1 \leq Y_j \leq N
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
X_1 Y_1
X_2 Y_2
:
X_M Y_M
Output
Print M lines. The j-th line should contain the minimum necessary number of modifications of integers on the balls to make Snuke's objective achievable.
Examples
Input
5 3
1 1 3 4 5
1 2
2 5
5 4
Output
0
1
1
Input
4 4
4 4 4 4
4 1
3 1
1 1
2 1
Output
0
1
2
3
Input
10 10
8 7 2 9 10 6 6 5 5 4
8 1
6 3
6 2
7 10
9 7
9 9
2 4
8 1
1 8
7 7
Output
1
0
1
2
2
3
3
3
3
2
|
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
const int M = 2e5 + 10;
int a[M] , vis[M] , cnt[M];
int main() {
int n , m;
scanf("%d%d" , &n , &m);
int ans = n;
for(int i = 1 ; i <= n ; i++) {
scanf("%d" , &a[i]);
cnt[a[i]]++;
int pos = a[i] - cnt[a[i]];
if(pos >= 0) {
if(!vis[pos]) ans--;
vis[pos]++;
}
}
while(m--) {
int x , y;
scanf("%d%d" , &x , &y);
int pos = a[x] - cnt[a[x]];
if(pos >= 0) {
vis[pos]--;
if(!vis[pos]) ans++;
}
cnt[a[x]]--;
a[x] = y;
cnt[a[x]]++;
pos = a[x] - cnt[a[x]];
if(pos >= 0) {
if(!vis[pos]) ans--;
vis[pos]++;
}
printf("%d\n" , ans);
}
return 0;
}
|
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 ≦ i ≦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j ≠ k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i ≦ N(2 ≦ i ≦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
|
#include <bits/stdc++.h>
using namespace std;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
int n;
VV<int> g;
int dfs(int v) {
V<int> st;
for (int u: g[v]) {
st.push_back(dfs(u));
}
sort(st.begin(), st.end());
int g = 0;
for (int d: st) {
g = max(g, d) + 1;
}
return g;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
g = VV<int>(n);
for (int i = 1; i < n; i++) {
int p;
cin >> p; p--;
g[p].push_back(i);
}
cout << dfs(0) << "\n";
return 0;
}
|
Snuke loves permutations. He is making a permutation of length N.
Since he hates the integer K, his permutation will satisfy the following:
* Let the permutation be a_1, a_2, ..., a_N. For each i = 1,2,...,N, |a_i - i| \neq K.
Among the N! permutations of length N, how many satisfies this condition?
Since the answer may be extremely large, find the answer modulo 924844033(prime).
Constraints
* 2 ≦ N ≦ 2000
* 1 ≦ K ≦ N-1
Input
The input is given from Standard Input in the following format:
N K
Output
Print the answer modulo 924844033.
Examples
Input
3 1
Output
2
Input
4 1
Output
5
Input
4 2
Output
9
Input
4 3
Output
14
Input
425 48
Output
756765083
|
#include <cstdio>
#include <iostream>
#include <algorithm>
#define N 4010
#define P 924844033
using namespace std;
int n,k,t;
int a[N];
int vis[N][2];
long long fac[N],g[N];
long long Ans;
long long f[N][N][2];
int main(){
scanf("%d%d",&n,&k);
for(int i=1;i<=n;i++)
for(int j=0;j<2;j++)
if(!vis[i][j]){
int x=i,y=j,len=0;
while(x<=n){
vis[x][y]=1;
len++;
x+=k; y^=1;
}
a[t+=len]=1;
}
f[1][0][0]=1;
for(int i=1;i<=t;i++)
for(int j=0;j<=n;j++){
f[i+1][j][0]=(f[i][j][0]+f[i][j][1])%P;
if(!a[i]) f[i+1][j+1][1]=f[i][j][0];
}
for(int i=1;i<=n;i++) g[i]=(f[t][i][0]+f[t][i][1])%P;
fac[0]=1;
for(int i=1;i<=n;i++) fac[i]=fac[i-1]*i%P;
Ans=fac[n];
for(int i=1,j=-1;i<=n;i++,j=-j) Ans=(Ans+P+j*g[i]*fac[n-i])%P;
printf("%lld\n",Ans);
return 0;
}
|
If the strings are consecutive, you can replace the characters with a rule to shorten the string. For example, for the string AAAA, the expression @ 4A will compress one character. Create a program that restores the character string compressed by this rule to the original character string. However, it is assumed that the @ character does not appear in the restored character string.
In addition, the original character string is uppercase letters, lowercase letters, numbers, and symbols, and can be up to 100 characters, and consecutive characters can be up to 9 characters.
input
Multiple strings are given. One string is given per line. The number of strings does not exceed 50.
output
For each character string, output the restored character string for each character on one line.
Example
Input
ab@5C1@8050
@99+1=1@90
Output
abCCCCC10000000050
999999999+1=1000000000
|
while True:
try:
s = raw_input()
except EOFError:
break
i=0
hirabun = ''
while i <len(s):
if s[i] != '@':
hirabun += s[i]
i += 1
elif s[i] == '@' and i+2 < len(s):
hira_part = s[i+2]*int(s[i+1])
hirabun += hira_part
i += 3
print hirabun
|
Mr. A came to Aizu for sightseeing. You can overlook the Aizu Basin from the window of the hotel where you stayed. As I was looking at the scenery, I noticed a piece of the photo on the floor. Apparently I took the outside view from the window. "Which area did you take?" A asked, holding the photo so that the view outside the window and the picture were the same size, and began looking for a place where the picture and the view outside the window matched. ..
Now let's do what Mr. A is doing on his computer. Divide the view outside the window into squares of n x n squares (n is called the size of the view). Each cell has an integer greater than or equal to 0 that represents the information in the image of that cell. The position of the cell is represented by the coordinates (x, y). The coordinates of each square are as follows.
<image>
A piece of a photo is represented by a square of m x m squares (m is called the size of the piece of the photo). In this square, the image information is written in the square of the piece, and -1 is written in the square of the part not included in the piece. For example, in the figure below, the colored areas represent the shape of the actual photo scraps. There may be holes in the pieces, but they are always connected together. (If cells with a value greater than or equal to 0 touch only at the vertices, they are considered unconnected.) Also, cells with a value of -1 are not lined up in a vertical or horizontal column from end to end.
<image>
In the view through the window, look for an area that matches a piece of the photo rotated 0, 90, 180, or 270 degrees. For example, if the landscape looks like the one below, you can rotate the piece in the above figure 90 degrees counterclockwise to match the colored area.
<image>
Entering the information of the view from the window and the piece of the photo, the square closest to the top of the area that matches any of the pieces rotated by 0, 90, 180, or 270 degrees is the closest to the left end. Create a program that outputs the coordinates of the mass.
If there are multiple matching areas, output the coordinates of the cell closest to the leftmost of the cells in those areas. If there is no matching area, NA is output.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
n m
w11 w12 ... w1n
w21 w22 ... w2n
::
wn1 wn2 ... wnn
p11 p12 ... p1m
p21 p22 ... p2m
::
pm1 pm2 ... pmm
The first line gives n, m (1 ≤ n ≤ 100, 1 ≤ m ≤ 50, m ≤ n).
The next n lines give information about the view from the window wij (0 ≤ wij ≤ 15), and the following m lines give information about the data of the photo scraps pij (-1 ≤ pij ≤ 15).
The number of datasets does not exceed 100.
Output
Outputs the coordinates or NA of the mass position on one line for each input dataset.
Example
Input
8 4
2 1 3 1 1 5 1 3
2 3 2 4 1 0 2 1
0 3 1 2 1 1 4 2
1 2 3 2 1 1 5 4
0 2 0 1 1 3 2 1
1 3 1 2 2 4 3 2
5 1 2 1 4 1 1 5
4 1 1 0 1 2 2 1
2 -1 -1 -1
0 3 -1 -1
-1 2 2 4
-1 1 -1 1
5 3
1 0 2 3 5
2 3 7 2 1
2 5 4 2 2
8 9 0 3 3
3 6 0 4 7
-1 -1 2
-1 3 5
0 4 -1
0 0
Output
4 2
NA
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<map>
#include<set>
#include<queue>
#include<cstdio>
#include<climits>
#include<cmath>
#include<cstring>
#include<string>
#include<sstream>
#include<numeric>
#include<cassert>
#define f first
#define s second
#define mp make_pair
#define REP(i,n) for(int i=0; i<(int)(n); i++)
#define rep(i,s,n) for(int i=(s); i<(int)(n); i++)
#define FOR(i,c) for(__typeof((c).begin()) i=(c).begin(); i!=(c).end(); i++)
#define ALL(c) (c).begin(), (c).end()
#define IN(x,s,g) ((x) >= (s) && (x) < (g))
#define ISIN(x,y,w,h) (IN((x),0,(w)) && IN((y),0,(h)))
#define print(x) printf("%d\n",x)
using namespace std;
typedef unsigned int uint;
typedef long long ll;
const int _dx[] = {0,1,0,-1};
const int _dy[] = {-1,0,1,0};
int getInt(){
int ret = 0,c;
c = getchar();
while(!isdigit(c)) c = getchar();
while(isdigit(c)){
ret *= 10;
ret += c - '0';
c = getchar();
}
return ret;
}
int b[100][100];
int p[4][50][50];
template<int N>
void rotate_cpy(int (*org)[N], int (*dist)[N], int n){
REP(i,n) REP(j,n)
dist[n-j-1][i] = org[i][j];
}
int main(){
int n, m;
while(scanf("%d%d",&n,&m), n+m){
int ax = INT_MAX;
int ay = INT_MAX;
REP(i,n) REP(j,n) scanf("%d",&b[i][j]);
REP(i,m) REP(j,m) scanf("%d",&p[0][i][j]);
REP(i,3) rotate_cpy(p[i], p[i+1], m);
REP(i,n-m+1) REP(j,n-m+1){
bool ok[4] = { true, true, true, true };
int xx[4] = { -1, -1, -1, -1 };
int yy[4] = { -1, -1, -1, -1 };
REP(c,4) REP(y,m) REP(x,m) if(ok[c]){
if(p[c][y][x] == -1) continue;
if(p[c][y][x] == b[i+y][j+x]){
if(xx[c] == -1){
xx[c] = j + x;
yy[c] = i + y;
}
}else{
ok[c] = false;
}
}
if(ok[0] || ok[1] || ok[2] || ok[3]){
REP(c,4) if(ok[c]){
if(ay > yy[c]){
ay = yy[c];
ax = xx[c];
}else if(ay == yy[c] && ax > xx[c]){
ay = yy[c];
ax = xx[c];
}
}
}
}
if(ax == INT_MAX)
puts("NA");
else
printf("%d %d\n",ax+1,ay+1);
}
return 0;
}
|
If you visit Aizu Akabeko shrine, you will find a unique paper fortune on which a number with more than one digit is written.
Each digit ranges from 1 to 9 (zero is avoided because it is considered a bad omen in this shrine). Using this string of numeric values, you can predict how many years it will take before your dream comes true. Cut up the string into more than one segment and compare their values. The difference between the largest and smallest value will give you the number of years before your wish will be fulfilled. Therefore, the result varies depending on the way you cut up the string. For example, if you are given a string 11121314 and divide it into segments, say, as 1,11,21,3,14, then the difference between the largest and smallest is 21 - 1 = 20. Another division 11,12,13,14 produces 3 (i.e. 14 - 11) years. Any random division produces a game of luck. However, you can search the minimum number of years using a program.
Given a string of numerical characters, write a program to search the minimum years before your wish will be fulfilled.
Input
The input is given in the following format.
n
An integer n is given. Its number of digits is from 2 to 100,000, and each digit ranges from 1 to 9.
Output
Output the minimum number of years before your wish will be fulfilled.
Examples
Input
11121314
Output
3
Input
123125129
Output
6
Input
119138
Output
5
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for(int i=j;i<n;++i)
#define all(i) i.begin(),i.end()
#define rall(i) i.rbegin(),i.rend()
#define INF 1e9
const int mod = 1e9 + 7;
typedef long long i64;
typedef pair<int, int> pi;
template <class T> using vt = vector<T>;
template <class T> using vvt = vector<vector<T>>;
i64 gcd(i64 n, i64 m) {return (m == 0? n : gcd(m, n % m));}
i64 lcm(i64 n, i64 m) {return (n / gcd(n, m) * m);}
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int def(string ma, string mi) {
rep(i, 0, 8) {
if(ma == mi) return i;
mi[mi.size() - 1]++;
for(int j = mi.size() - 1; j >= 0; --j) {
if(mi[j] != '9' + 1) break;
else if(j - 1 > 0) mi[j - 1]++;
else mi.insert(0, "1");
}
}
if(ma == mi) return 8;
return 9;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
int sz = s.size();
int ans = INF;
{
rep(i, 1, sz) {
if(sz % i) continue;
string Max, Min;
Max = Min = s.substr(0, i);
for(int j = 0; j < sz; j += i) {
Max = max(Max, s.substr(j, i));
Min = min(Min, s.substr(j, i));
}
ans = min(ans, def(Max, Min));
}
}
{
int Max = 0, Min = 10;
int i = 0, num;
while(i < sz) {
num = s[i] - '0';
if(s[i] == '1' && i + 1 < sz) {
i++;
num = 10 + (s[i] - '0');
}
i++;
Max = max(Max, num);
Min = min(Min, num);
}
if(Max != 0) ans = min(ans, Max - Min);
}
cout << ans << endl;
}
|
Compute A + B.
Constraints
* -1000 ≤ A, B ≤ 1000
Input
The input will consist of a series of pairs of integers A and B separated by a space, one pair of integers per line. The input will be terminated by EOF.
Output
For each pair of input integers A and B, you must output the sum of A and B in one line.
Example
Input
1 2
10 5
100 20
Output
3
15
120
|
#include<iostream>
#include <cstdio>
using namespace std;
int main() {
int a, b;
while (scanf("%d %d", &a, &b) != EOF)
printf("%d\n", a + b);
return 0;
}
|
RJ Freight, a Japanese railroad company for freight operations has recently constructed exchange lines at Hazawa, Yokohama. The layout of the lines is shown in Figure B-1.
<image>
Figure B-1: Layout of the exchange lines
A freight train consists of 2 to 72 freight cars. There are 26 types of freight cars, which are denoted by 26 lowercase letters from "a" to "z". The cars of the same type are indistinguishable from each other, and each car's direction doesn't matter either. Thus, a string of lowercase letters of length 2 to 72 is sufficient to completely express the configuration of a train.
Upon arrival at the exchange lines, a train is divided into two sub-trains at an arbitrary position (prior to entering the storage lines). Each of the sub-trains may have its direction reversed (using the reversal line). Finally, the two sub-trains are connected in either order to form the final configuration. Note that the reversal operation is optional for each of the sub-trains.
For example, if the arrival configuration is "abcd", the train is split into two sub-trains of either 3:1, 2:2 or 1:3 cars. For each of the splitting, possible final configurations are as follows ("+" indicates final concatenation position):
[3:1]
abc+d cba+d d+abc d+cba
[2:2]
ab+cd ab+dc ba+cd ba+dc cd+ab cd+ba dc+ab dc+ba
[1:3]
a+bcd a+dcb bcd+a dcb+a
Excluding duplicates, 12 distinct configurations are possible.
Given an arrival configuration, answer the number of distinct configurations which can be constructed using the exchange lines described above.
Input
The entire input looks like the following.
> the number of datasets = m
> 1st dataset
> 2nd dataset
> ...
> m-th dataset
>
Each dataset represents an arriving train, and is a string of 2 to 72 lowercase letters in an input line.
Output
For each dataset, output the number of possible train configurations in a line. No other characters should appear in the output.
Example
Input
4
aa
abba
abcd
abcde
Output
1
6
12
18
|
#include <bits/stdc++.h>
using namespace std;
int calc(string s)
{
set<string> sset;
int n = s.size();
for(int i=0; i<n; i++)
{
string fst(s, 0, i), snd(s, i, n-i);
string rfst(fst.rbegin(), fst.rend()), rsnd(snd.rbegin(), snd.rend());
sset.insert(fst+snd);
sset.insert(snd+fst);
sset.insert(fst+rsnd);
sset.insert(rsnd+fst);
sset.insert(rfst+snd);
sset.insert(snd+rfst);
sset.insert(rfst+rsnd);
sset.insert(rsnd+rfst);
}
return sset.size();
}
int main()
{
int n;
cin >> n;
while(n--)
{
string s;
cin >> s;
cout << calc(s) << endl;
}
}
|
One of the tasks students routinely carry out in their mathematics classes is to solve a polynomial equation. It is, given a polynomial, say X2 - 4X + 1, to find its roots (2 ± √3).
If the students’ task is to find the roots of a given polynomial, the teacher’s task is then to find a polynomial that has a given root. Ms. Galsone is an enthusiastic mathematics teacher who is bored with finding solutions of quadratic equations that are as simple as a + b√c. She wanted to make higher-degree equations whose solutions are a little more complicated. As usual in problems in mathematics classes, she wants to maintain all coefficients to be integers and keep the degree of the polynomial as small as possible (provided it has the specified root). Please help her by writing a program that carries out the task of the teacher’s side.
You are given a number t of the form:
t = m√a+n√b
where a and b are distinct prime numbers, and m and n are integers greater than 1.
In this problem, you are asked to find t's minimal polynomial on integers, which is the polynomial F(X) = adXd + ad-1Xd-1 + ... + a1X + a0 satisfying the following conditions.
1. Coefficients a0, ... , ad are integers and ad > 0.
2. F(t) = 0.
3. The degree d is minimum among polynomials satisfying the above two conditions.
4. F(X) is primitive. That is, coefficients a0, ... , ad have no common divisors greater than one.
For example, the minimal polynomial of √3+ √2 on integers is F(X) = X4 - 10X2 + 1. Verifying F(t) = 0 is as simple as the following (α = 3, β = 2).
F(t) = (α + β)4 - 10(α + β)2 + 1
= (α4 + 4α3β + 6α2β2 + 4αβ3 + β4 ) - 10(α2 + 2αβ + β2) + 1
= 9 + 12αβ + 36 + 8αβ + 4 - 10(3 + 2αβ + 2) + 1
= (9 + 36 + 4 - 50 + 1) + (12 + 8 - 20)αβ
= 0
Verifying that the degree of F(t) is in fact minimum is a bit more difficult. Fortunately, under the condition given in this problem, which is that a and b are distinct prime numbers and m and n greater than one, the degree of the minimal polynomial is always mn. Moreover, it is always monic. That is, the coefficient of its highest-order term (ad) is one.
Input
The input consists of multiple datasets, each in the following format.
a m b n
This line represents m√a + n√b. The last dataset is followed by a single line consisting of four zeros. Numbers in a single line are separated by a single space.
Every dataset satisfies the following conditions.
1. m√a + n√b ≤ 4.
2. mn ≤ 20.
3. The coefficients of the answer a0, ... , ad are between (-231 + 1) and (231 - 1), inclusive.
Output
For each dataset, output the coefficients of its minimal polynomial on integers F(X) = adXd + ad-1Xd-1 + ... + a1X + a0, in the following format.
ad ad-1 ... a1 a0
Non-negative integers must be printed without a sign (+ or -). Numbers in a single line must be separated by a single space and no other characters or extra spaces may appear in the output.
Example
Input
3 2 2 2
3 2 2 3
2 2 3 4
31 4 2 3
3 2 2 7
0 0 0 0
Output
1 0 -10 0 1
1 0 -9 -4 27 -36 -23
1 0 -8 0 18 0 -104 0 1
1 0 0 -8 -93 0 24 -2976 2883 -32 -3720 -23064 -29775
1 0 -21 0 189 0 -945 -4 2835 -252 -5103 -1260 5103 -756 -2183
|
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
using namespace std;
bool gauss(vector<vector<long double> > &a){
if(a.empty())return false;
int n=a.size();
for(int i=0;i<n;i++){
if(!a[i][i]){
int j=i+1;
for(;j<n;j++){
if(a[j][i]){
for(int k=i;k<=n;k++)a[i][k]+=a[j][k];
break;
}
}
if(j==n)return false;
}
for(int j=0;j<n;j++)if(i!=j){
long double r=a[j][i]/a[i][i];
for(int k=i;k<=n;k++)a[j][k]=a[j][k]-a[i][k]*r;
}
}
for(int i=0;i<n;i++){
long double x=a[i][i];
for(int j=0;j<a[i].size();j++)a[i][j]/=x;
}
return true;
}
long long comb(int n,int k){
if(k>n-k)k=n-k;
long long r=1;
for(int i=0;i<k;i++)r=r*(n-i)/(i+1);
return r;
}
long long pow_binary(long long x,long long y){
long long z=1;
for(;y;y>>=1){
if((y&1)!=0)z=z*x;
x=x*x;
}
return z;
}
int main(){
int A,M,B,N;
for(;scanf("%d%d%d%d",&A,&M,&B,&N),A;){
vector<vector<long double> >m(M*N+1);
for(int i=0;i<=M*N;i++)m[i].resize(M*N+2);
m[0][0]=m[0][M*N+1]=1;
for(int i=0;i<=M*N;i++)for(int k=0;k<=i;k++){
m[k%M*N+(i-k)%N+1][i<M*N ? i+1 : 0]+=(long double)comb(i,k)*pow_binary(A,k/M)*pow_binary(B,(i-k)/N);
}
gauss(m);
printf("1");
for(int i=M*N;i>0;i--)printf(" %d",(int)(roundl(m[i][M*N+1])));
puts("");
}
}
|
A grid of r × c is given.
Numbers from 1 to 8 are written on some squares on the grid.
<image>
It is necessary to connect the squares with numbers and the squares with other numbers with a line.
For the squares with numbers written on them, it is necessary to connect lines with other squares as many as the number written on that square.
However, the lines can be connected only in the vertical and horizontal directions, and up to two lines can be connected in one direction.
<image>
It cannot be connected by a line across other numbers.
<image>
In addition, it is not possible to tie them so that they intersect as follows.
<image>
Since the grid is given as input, please count how many ways there are ways to correctly connect all the squares with numbers.
Input
The input is given in the following format.
r c
grid1
..
..
..
gridr-1
gridi is a string of length c, consisting of numbers from 1 to 8 or ".".
Input meets the following constraints
1 ≤ r, c ≤ 10
Output
Divide the answer value by 100,000,007 and output the remainder on one line
Examples
Input
3 3
.1.
1.1
.1.
Output
0
Input
1 3
1.1
Output
1
Input
3 3
4.2
...
2..
Output
1
Input
7 7
2.3.1.1
.......
2......
.......
..3.3..
.......
2.2.4.3
Output
10
|
#include <iostream>
#include <cstdio>
#include <vector>
#include <list>
#include <cmath>
#include <fstream>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <complex>
#include <iterator>
#include <cstdlib>
#include <cstring>
#include <sstream>
#include <stack>
#include <climits>
#include <deque>
#include <bitset>
#include <cassert>
#include <ctime>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int dy[]={-1,0,1,0},dx[]={0,1,0,-1};
// adjust problem by problem
const double EPS=1e-8;
const double PI=acos(-1.0);
#ifdef __GNUC__
int popcount(int n){return __builtin_popcount(n);}
int popcount(ll n){return __builtin_popcountll(n);}
#endif
#ifndef __GNUC__
template<class T> int popcount(T n){int cnt=0;while(n){if(n%2)cnt++;n/=2;}return cnt;}
#endif
template<class T>int SIZE(T a){return a.size();}
template<class T>string IntToString(T num){string res;stringstream ss;ss<<num;return ss.str();}
template<class T>T StringToInt(string str){T res=0;for(int i=0;i<SIZE(str);i++)res=(res*10+str[i]-'0');return res;}
template<class T>T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template<class T>T lcm(T a,T b){return a/gcd(a,b)*b;}
bool EQ(double a,double b){return abs(a-b)<EPS;}
void fastStream(){cin.tie(0);std::ios_base::sync_with_stdio(0);}
vector<string> split(string str,char del){
vector<string> res;
for(int i=0,s=0;i<SIZE(str);i++){
if(str[i]==del){if(i-s!=0)res.push_back(str.substr(s,i-s));s=i+1;}
else if(i==SIZE(str)-1){res.push_back(str.substr(s));}
}
return res;
}
/*
今見ている行の縦の引き方と左側の引き方を覚えておくDP
*/
// 2bit単位で１つのgridの情報を表す
const int mod=100000007;
map<int,int> dp[101][3];
int H,W;
char field[101][101];
int getVal(int pos,int mask){
return ((mask>>(pos*2))&1)+((mask>>(pos*2+1))&1)*2;
}
int insertVal(int pos,int mask,int val){
int a[2]={val%2,val/2};
int resMask=mask;
for(int i=0;i<2;i++)
if(a[i]==1)resMask|=(1<<(pos*2+i));
else resMask&=~(1<<(pos*2+i));
return resMask;
}
int dfs(int pos,int mask,int left){
int cy=pos/W,cx=pos%W;
if(pos==H*W)return 1;
if(dp[pos][left].count(mask)>0)
return dp[pos][left][mask];
ll res=0;
int num=field[cy][cx]-'0';
// 一つ前のmaskの値を取り出す
int up=getVal(cx,mask);
int cnt=up+left;
if(num==0){
if(cx==W-1&&left!=0)return 0;
if(cy==H-1&&up!=0)return 0;
if(up!=0&&left!=0)return 0;
else if(up!=0){
int nmask=insertVal(cx,mask,up);
res+=dfs(pos+1,nmask,0);
res%=mod;
}
else if(left!=0){
int nmask=insertVal(cx,mask,0);
res+=dfs(pos+1,nmask,left);
res%=mod;
}
else{
int nmask=insertVal(cx,mask,0);
res+=dfs(pos+1,nmask,0);
res%=mod;
}
}
else{
for(int down=0;down<=2;down++){
for(int right=0;right<=2;right++){
if(cx==W-1&&right!=0)continue;
if(down+right+cnt!=num)continue;
if(cy==H-1&&down!=0)continue;
int nmask=insertVal(cx,mask,down);
res+=dfs(pos+1,nmask,right);
res%=mod;
}
}
}
return dp[pos][left][mask]=res;
}
int main(){
cin>>H>>W;
for(int i=0;i<H;i++){
for(int j=0;j<W;j++){
cin>>field[i][j];
if(field[i][j]=='.')field[i][j]='0';
}
}
cout<<dfs(0,0,0)<<endl;
return 0;
}
|
The mayor of Amida, the City of Miracle, is not elected like any other city. Once exhausted by long political struggles and catastrophes, the city has decided to leave the fate of all candidates to the lottery in order to choose all candidates fairly and to make those born under the lucky star the mayor. I did. It is a lottery later called Amidakuji.
The election is held as follows. The same number of long vertical lines as the number of candidates will be drawn, and some horizontal lines will be drawn there. Horizontal lines are drawn so as to connect the middle of adjacent vertical lines. Below one of the vertical lines is written "Winning". Which vertical line is the winner is hidden from the candidates. Each candidate selects one vertical line. Once all candidates have been selected, each candidate follows the line from top to bottom. However, if a horizontal line is found during the movement, it moves to the vertical line on the opposite side to which the horizontal line is connected, and then traces downward. When you reach the bottom of the vertical line, the person who says "winning" will be elected and become the next mayor.
This method worked. Under the lucky mayor, a peaceful era with few conflicts and disasters continued. However, in recent years, due to population growth, the limits of this method have become apparent. As the number of candidates increased, the Amidakuji became large-scale, and manual tabulation took a lot of time. Therefore, the city asked you, the programmer of the city hall, to computerize the Midakuji.
Your job is to write a program that finds the structure of the Amidakuji and which vertical line you will eventually reach given the position of the selected vertical line.
The figure below shows the contents of the input and output given as a sample.
<image>
Input
The input consists of multiple datasets. One dataset is given as follows.
> n m a
> Horizontal line 1
> Horizontal line 2
> Horizontal line 3
> ...
> Horizontal line m
>
n, m, and a are integers that satisfy 2 <= n <= 100, 0 <= m <= 1000, 1 <= a <= n, respectively. Represents a number.
The horizontal line data is given as follows.
> h p q
h, p, and q are integers that satisfy 1 <= h <= 1000, 1 <= p <q <= n, respectively, h is the height of the horizontal line, and p and q are connected to the horizontal line 2 Represents the number of the vertical line of the book.
No two or more different horizontal lines are attached to the same height of one vertical line.
At the end of the input, there is a line consisting of only three zeros separated by blanks.
Output
Output one line for each dataset, the number of the vertical line at the bottom of the vertical line a when traced from the top.
Sample Input
4 4 1
3 1 2
2 2 3
3 3 4
1 3 4
0 0 0
Output for the Sample Input
Four
Example
Input
4 4 1
3 1 2
2 2 3
3 3 4
1 3 4
0 0 0
Output
4
|
#include <iostream>
#include <utility>
#include <vector>
#define llint long long
using namespace std;
typedef pair<llint, llint> P;
llint n, m, a;
vector<P> vec[1005];
int main(void)
{
while(1){
cin >> n >> m >> a;
if(n == 0 && m == 0 && a == 0) break;
for(int i = 1; i <= 1000; i++) vec[i].clear();
llint h, u, v;
for(int i = 1; i <= m; i++){
cin >> h >> u >> v;
vec[h].push_back(P(u, v));
}
for(int i = 1000; i >= 1; i--){
for(int j = 0; j < vec[i].size(); j++){
P p = vec[i][j];
if(a == p.first) a = p.second;
else if(a == p.second) a = p.first;
}
}
cout << a << endl;
}
return 0;
}
|
Ninjas are professional spies in the Middle Age of Japan. They have been popular in movies and games as they have been described with extraordinary physical abilities and unrealistic abilities.
You are absorbed in one of ninja games, Ninja Legend. In this game, you control in an exceptionally talented ninja named Master Ninja and accomplish various missions. In one of the missions, the ninja intrudes into a mansion and aims to steal as many gold pieces as possible. It is not easy to be done because there are many pitfalls to evade him. Once he falls into a pitfall, all he can do will be just to wait for being caught by the owner of this mansion. This definitely means failure of the mission. Thus, you must control the ninja with a good strategy.
The inside of mansion is represented by a grid map as illustrated below. Master Ninja enters at and exits from the entrance. He can move in the four directions to the floor cells. He can pick up gold blocks when he moves to the cells where they are placed, but it is also allowed to pick up them in the later visit of those cells or even to give up them.
<image>
Figure 1: Example Map
The ninja has a couple of special abilities for dealing with the pitfalls. He has two moving modes: normal mode and dash mode. He is initially in the normal mode. He gets into the dash mode when he moves in the same direction by two cells in a row without picking up gold blocks. He gets back to the normal mode when he changes the direction, picks up a gold block, or runs on a wall as mentioned later. He is able to jump over a pitfall, or in the dash mode he can jump over two pitfalls in his dashing direction. In addition, when he is in the dash mode, he can run on a wall to pass over up to four pitfalls in his dashing direction. For his running, there must be consecutive wall cells adjacent to the passing cells including the departure and arrival floor cells. Note that he gets back to the normal mode when he runs on a wall as mentioned previously.
In the figure below, the left one shows how the ninja runs on a wall, and the right one illustrates a case in which he cannot skip over pitfalls by running on a wall.
<image> | <image>
---|---
Figure 2: Running on a Wall
|
Figure 3: Non-consecutive Walls
You want to know the maximum number of gold blocks the ninja can get, and the minimum cost to get those gold blocks. So you have decided to write a program for it as a programmer. Here, move of the ninja from a cell to its adjacent cell is considered to take one unit of cost.
Input
The input consists of multiple datasets.
The first line of each dataset contains two integers H (3 ≤ H ≤ 60) and W (3 ≤ W ≤ 80). H and W indicate the height and width of the mansion. The following H lines represent the map of the mansion. Each of these lines consists of W characters. Each character is one of the following: ‘%’ (entrance), ‘#’ (wall), ‘.’ (floor), ‘^’ (pitfall), ‘*’ (floor with a gold block).
You can assume that the number of gold blocks are less than or equal to 15 and every map is surrounded by wall cells.
The end of the input indicated with a line containing two zeros.
Output
For each dataset, output the maximum number of gold blocks and the minimum cost in one line. Output two zeros instead if the ninja cannot get any gold blocks. No other characters should be contained in the output.
Examples
Input
6 23
#######################
#%.^.^#################
#^^^^^######^^^^^^^^^^#
#^^^...^^^^...^^*^^..*#
#^^^^^^^^^^^^^^^^^^^^^#
#######################
5 16
################
#^^^^^^^^^^^^^^#
#*..^^^.%.^^..*#
#^^#####^^^^^^^#
################
0 0
Output
1 44
2 28
Input
6 23
%.^.^#################
^^^^^######^^^^^^^^^^#
^^^...^^^^...^^*^^..*#
^^^^^^^^^^^^^^^^^^^^^#
5 16
^^^^^^^^^^^^^^#
*..^^^.%.^^..*#
^^#####^^^^^^^#
0 0
Output
1 44
2 28
|
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Scanner;
//Ninja Legend
public class Main{
int h, w, N, INF = 1<<29;
char[][] map;
int[][] d = {{-1,0},{0,1},{1,0},{0,-1}}, adj, id, dp;
int get(int S, int last){
if(dp[S][last]!=-1)return dp[S][last];
int res = INF;
for(int i=0;i<N;i++){
if(i==last||((S>>i)&1)==0||adj[i][last]==INF)continue;
int ns = S-(1<<last);
res = Math.min(res, adj[i][last]+get(ns, i));
}
return dp[S][last] = res;
}
boolean dash(int i, int j, int k, int len){
if(map[i][j]!='.')return false;
int gi = i+len*d[k][0], gj = j+len*d[k][1];
if(!(0<=gi&&gi<h&&0<=gj&&gj<w)||map[gi][gj]!='.')return false;
int pi = i, pj = j;
for(int x=0;x<len;x++){
pi += d[k][0]; pj += d[k][1];
if(map[pi][pj]=='#')return false;
}
int i1 = i+d[(k+1)%4][0], j1 = j+d[(k+1)%4][1], i2 = i+d[(k+3)%4][0], j2 = j+d[(k+3)%4][1];
boolean f1 = true, f2 = true;
for(int x=0;x<=len;x++){
if(map[i1][j1]!='#')f1 = false;
if(map[i2][j2]!='#')f2 = false;
i1 += d[k][0]; j1 += d[k][1]; i2 += d[k][0]; j2 += d[k][1];
}
return f1|f2;
}
boolean jump(int i, int j, int k, int len){
if(map[i][j]!='.')return false;
int gi = i+len*d[k][0], gj = j+len*d[k][1];
if(!(0<=gi&&gi<h&&0<=gj&&gj<w)||map[gi][gj]!='.')return false;
for(int x=1;x<len;x++){
int ni = i+x*d[k][0], nj = j+x*d[k][1];
if(map[ni][nj]!='^')return false;
}
return true;
}
int[][][][] dist;
void dijkstra(int i, int j){
int ID = id[i][j];
int mask = 1<<ID;
adj[ID][ID] = 0;
for(int I=0;I<h;I++)for(int J=0;J<w;J++)for(int k=0;k<4;k++)for(int c=0;c<2;c++)dist[I][J][k][c] = INF;
PriorityQueue<int[]> q = new PriorityQueue<int[]>(h*w, new Comparator<int[]>() {
public int compare(int[] a, int[] b) {
return dist[a[0]][a[1]][a[2]][a[3]]-dist[b[0]][b[1]][b[2]][b[3]];
}
});
for(int k=0;k<4;k++){
dist[i][j][k][0] = 0;
q.add(new int[]{i, j, k, 0});
}
while(!q.isEmpty()){
int[] a = q.poll();
int pi = a[0], pj = a[1], dir = a[2], pc = a[3], cost = dist[pi][pj][dir][pc];
if(id[pi][pj]!=-1){
mask |= 1<<id[pi][pj];
adj[ID][id[pi][pj]] = Math.min(adj[ID][id[pi][pj]], cost);
}
if(mask==(1<<(N+1))-1)break;
//dash mode
if(pc==1){
//run along wall
for(int len=2;len<=5;len++){
if(dash(pi, pj, dir, len)){
int w = cost+len;
if(w < dist[pi+len*d[dir][0]][pj+len*d[dir][1]][dir][0]){
dist[pi+len*d[dir][0]][pj+len*d[dir][1]][dir][0] = w;
q.add(new int[]{pi+len*d[dir][0], pj+len*d[dir][1], dir, 0});
}
}
}
//jump just two falls
if(jump(pi, pj, dir, 3)){
int w = cost+3;
if(w < dist[pi+3*d[dir][0]][pj+3*d[dir][1]][dir][1]){
dist[pi+3*d[dir][0]][pj+3*d[dir][1]][dir][1] = w;
q.add(new int[]{pi+3*d[dir][0], pj+3*d[dir][1], dir, 1});
}
}
}
for(int k=0;k<4;k++){
if(k!=dir){
if(cost < dist[pi][pj][k][0]){
dist[pi][pj][k][0] = cost;
q.add(new int[]{pi, pj, k, 0});
}
continue;
}
int ni = pi+d[k][0], nj = pj+d[k][1];
boolean f = false;
if(map[ni][nj]=='.'){
f = true;
int w = cost + 1;
int nc = pc;
if(w < dist[ni][nj][k][nc]){
dist[ni][nj][k][nc] = w;
q.add(new int[]{ni, nj, k, nc});
}
}
ni += d[k][0]; nj += d[k][1];
if(jump(pi, pj, k, 2)){
int w = cost+2;
int nc = pc;
if(w < dist[ni][nj][k][nc]){
dist[ni][nj][k][nc] = w;
q.add(new int[]{ni, nj, k, nc});
}
}
if(f&&0<=ni&&ni<h&&0<=nj&&nj<w&&map[ni][nj]=='.'){
int w = cost+2;
int nc = 1;
if(w < dist[ni][nj][k][nc]){
dist[ni][nj][k][nc] = w;
q.add(new int[]{ni, nj, k, nc});
}
}
}
}
}
void run(){
Scanner sc = new Scanner(System.in);
dp = new int[1<<16][16];
for(;;){
h = sc.nextInt(); w = sc.nextInt();
if((h|w)==0)break;
map = new char[h][w];
id = new int[h][w];
for(int[]a:id)Arrays.fill(a, -1);
N = 0;
int si = 0, sj = 0;
List<int[]> mark = new ArrayList<int[]>();
for(int i=0;i<h;i++){
map[i] = sc.next().toCharArray();
for(int j=0;j<w;j++){
if(map[i][j]=='%'){
map[i][j] = '.'; si = i; sj = j;
mark.add(new int[]{i, j});
}
if(map[i][j]=='*'){
map[i][j] = '.'; id[i][j] = N++;
mark.add(new int[]{i, j});
}
}
}
id[si][sj] = N;
adj = new int[N+1][N+1];
for(int[]a:adj)Arrays.fill(a, INF);
dist = new int[h][w][4][2];
for(int[]a:mark)dijkstra(a[0], a[1]);
for(int[]a:dp)Arrays.fill(a, -1);
for(int i=0;i<=N;i++)dp[(1<<N)|(1<<i)][i] = adj[N][i];
int max = 0, min = INF;
for(int i=(1<<N)-1;i>=0;i--){
int c = 0;
for(int j=0;j<N;j++)if(((i>>j)&1)>0)c++;
if(c<max)continue;
int r = INF;
for(int j=0;j<N;j++){
if(((i>>j)&1)==0||adj[j][N]==INF)continue;
r = Math.min(r, get(i+(1<<N), j) + adj[j][N]);
}
if(r==INF)continue;
if(max<c){
max = c; min = r;
}
else if(max==c&&r<min)min = r;
}
if(max==0)min = 0;
System.out.println(max+" "+min);
}
}
public static void main(String[] args) {
new Main().run();
}
}
|
Angry Birds is a mobile game of a big craze all over the world. You were convinced that it was a waste of time to play the game, so you decided to create an automatic solver.
<image>
You are describing a routine that optimizes the white bird's strategy to defeat a pig (enemy) by hitting an egg bomb. The white bird follows a parabolic trajectory from the initial position, and it can vertically drop egg bombs on the way.
In order to make it easy to solve, the following conditions hold for the stages.
* N obstacles are put on the stage.
* Each obstacle is a rectangle whose sides are parallel to the coordinate axes.
* The pig is put on the point (X, Y).
* You can launch the white bird in any direction at an initial velocity V from the origin.
* If the white bird collides with an obstacle, it becomes unable to drop egg bombs.
* If the egg bomb collides with an obstacle, the egg bomb is vanished.
The acceleration of gravity is 9.8 {\rm m/s^2}. Gravity exerts a force on the objects in the decreasing direction of y-coordinate.
Input
A dataset follows the format shown below:
N V X Y
L_1 B_1 R_1 T_1
...
L_N B_N R_N T_N
All inputs are integer.
* N: the number of obstacles
* V: the initial speed of the white bird
* X, Y: the position of the pig
(0 \leq N \leq 50, 0 \leq V \leq 50, 0 \leq X, Y \leq 300, X \neq 0)
for 1 \leq i \leq N,
* L_i: the x-coordinate of the left side of the i-th obstacle
* B_i: the y-coordinate of the bottom side of the i-th obstacle
* R_i: the x-coordinate of the right side of the i-th obstacle
* T_i: the y-coordinate of the top side of the i-th obstacle
(0 \leq L_i, B_i, R_i, T_i \leq 300)
It is guaranteed that the answer remains unaffected by a change of L_i, B_i, R_i and T_i in 10^{-6}.
Output
Yes/No
You should answer whether the white bird can drop an egg bomb toward the pig.
Examples
Input
0 7 3 1
Output
Yes
Input
1 7 3 1
1 1 2 2
Output
No
Input
1 7 2 2
0 1 1 2
Output
No
|
// OBツ嘉ッツ嘉債宿2011 Day3 I : White Bird
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
const double EPS = 1e-8;
int main(){
int N, V, X, Y;
int L[50], B[50], R[50], T[50];
while(cin >> N >> V >> X >> Y){
vector<double> vd;
int low = Y, high = 1000000007;
for(int i=0;i<N;i++){
cin >> L[i] >> B[i] >> R[i] >> T[i];
L[i] = min(L[i], X);
R[i] = min(R[i], X);
if(L[i]<=X&&X<=R[i]&&B[i]>=high) high = min(high, B[i]);
}
bool clear = false;
for(int i=1;i<900000;i++){
double angle = (double)i/10000/180*acos(-1);
double vx = V*cos(angle);
double vy = V*sin(angle);
bool ok = true;
for(int j=0;j<N;j++){
double my = vy*(L[j]/vx) - 4.9*(L[j]/vx)*(L[j]/vx);
double My = vy*(R[j]/vx) - 4.9*(R[j]/vx)*(R[j]/vx);
if(my > My) swap(my, My);
if(L[j]+EPS < vx*vy/9.8 && vx*vy/9.8 < R[j]-EPS)
My = vy*(vy/9.8) - 4.9*(vy/9.8)*(vy/9.8);
if(min(My, (double)T[j]) - max(my, (double)B[j]) > EPS) ok = false;
}
if(!ok) continue;
double y = vy*(X/vx) - 4.9*(X/vx)*(X/vx);
if(low-EPS < y && y < high+EPS) clear = true;
}
cout << (clear ? "Yes" : "No") << endl;
}
}
|
Mr. Haskins is working on tuning a database system. The database is a simple associative storage that contains key-value pairs. In this database, a key is a distinct identification (ID) number and a value is an object of any type.
In order to boost the performance, the database system has a cache mechanism. The cache can be accessed much faster than the normal storage, but the number of items it can hold at a time is limited. To implement caching, he selected least recently used (LRU) algorithm: when the cache is full and a new item (not in the cache) is being accessed, the cache discards the least recently accessed entry and adds the new item.
You are an assistant of Mr. Haskins. He regards you as a trusted programmer, so he gave you a task. He wants you to investigate the cache entries after a specific sequence of accesses.
Input
The first line of the input contains two integers N and M. N is the number of accessed IDs, and M is the size of the cache. These values satisfy the following condition: 1 ≤ N, M ≤ 100000.
The following N lines, each containing one ID, represent the sequence of the queries. An ID is a positive integer less than or equal to 109.
Output
Print IDs remaining in the cache after executing all queries. Each line should contain exactly one ID. These IDs should appear in the order of their last access time, from the latest to the earliest.
Example
Input
Output
|
#include <algorithm>
#include <queue>
#define REP(i,n) for(int i=0; i<(int)(n); i++)
#include <cstdio>
#include <unordered_set>
inline int getInt(){ int s; scanf("%d", &s); return s; }
using namespace std;
int main(){
const int n = getInt();
const int m = getInt();
std::unordered_set<int> s;
vector<int> v(n);
REP(i,n) v[i] = getInt();
reverse(v.begin(), v.end());
for(int i = 0; i < n; i++){
if((int) s.size() < m && s.count(v[i]) == 0){
printf("%d\n", v[i]);
s.insert(v[i]);
}
}
return 0;
}
|
In Manhattan, roads run where the x or y coordinate is an integer. Both Sunuke-kun's house and Sumeke-kun's house are on the road, and the straight line distance (Euclidean distance) is just d. Find the maximum value that can be considered as the shortest distance when traveling along the road from Sunuke-kun's house to Sumek-kun's house.
Constraints
* 0 <d ≤ 10
* d is given up to exactly three decimal places
Input
d
Output
Print the answer on one line. If the absolute error or relative error is 10-9 or less, the answer is judged to be correct.
Examples
Input
1.000
Output
2.000000000000
Input
2.345
Output
3.316330803765
|
#include<iostream>
#include<vector>
#include<utility>
#include<algorithm>
#include<string>
#include<cstdio>
#include<queue>
#include<functional>
#include<tuple>
#include<iomanip>
#include<stack>
#include<cmath>
#define ll long long
using namespace std;
int main() {
double d,m; cin >> d;
m = sqrt(2)*d;
if (sqrt(d*d - floor(d)*floor(d)) <= 1.0) m = max(m, floor(d) + 1);
printf("%.10f\n", m);
return 0;
}
|
Example
Input
2 4
%.@\$
..\$\$
Output
Yes
|
#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define pi M_PI
#define R cin>>
#define Z class
#define ll long long
#define ln cout<<'\n'
#define in(a) insert(a)
#define pb(a) push_back(a)
#define pd(a) printf("%.10f\n",a)
#define mem(a) memset(a,0,sizeof(a))
#define all(c) (c).begin(),(c).end()
#define iter(c) __typeof((c).begin())
#define rrep(i,n) for(int i=(int)(n)-1;i>=0;i--)
#define REP(i,m,n) for(int i=(int)(m);i<(int)(n);i++)
#define rep(i,n) REP(i,0,n)
#define tr(it,c) for(iter(c) it=(c).begin();it!=(c).end();it++)
template<Z A>void pr(A a){cout<<a;ln;}
template<Z A,Z B>void pr(A a,B b){cout<<a<<' ';pr(b);}
template<Z A,Z B,Z C>void pr(A a,B b,C c){cout<<a<<' ';pr(b,c);}
template<Z A,Z B,Z C,Z D>void pr(A a,B b,C c,D d){cout<<a<<' ';pr(b,c,d);}
template<Z A>void PR(A a,ll n){rep(i,n){if(i)cout<<' ';cout<<a[i];}ln;}
ll check(ll n,ll m,ll x,ll y){return x>=0&&x<n&&y>=0&&y<m;}
const ll MAX=1000000007,MAXL=1LL<<61,dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};
typedef pair<int,int> P;
void Main() {
int n,m;
cin >> n >> m;
string s[n];
rep(i,n) R s[i];
vector<P> v;
int d[n][m];
rep(i,n)rep(j,m)d[i][j]=MAX;
queue<P> que;
rep(i,n)rep(j,m) {
if(s[i][j]=='%') {
d[i][j]=0;
que.push(P(i,j));
}
if(s[i][j]=='@') v.pb(P(i,j));
}
rep(i,n)rep(j,m)if(s[i][j]=='$') v.pb(P(i,j));
while(!que.empty()) {
P p=que.front();que.pop();
rep(i,4) {
int x=p.F+dx[i],y=p.S+dy[i];
if(!check(n,m,x,y)||d[x][y]<=d[p.F][p.S]+1||s[x][y]=='#') continue;
d[x][y]=d[p.F][p.S]+1;
que.push(P(x,y));
}
}
bool f=1;
REP(i,1,v.size()) {
if(d[v[0].F][v[0].S]>=d[v[i].F][v[i].S]) f=0;
}
if(f) pr("Yes");
else pr("No");
}
int main(){ios::sync_with_stdio(0);cin.tie(0);Main();return 0;}
|
D: Sontaku (Surmise)
Some twins like even numbers.
Count how many even numbers are in $ N $ integers $ A_1, A_2, A_3, \ dots, A_N $.
input
The integer $ N $ is given on the first line.
On the second line, $ N $ integers $ A_1, A_2, A_3, \ dots, A_N $ are given, separated by blanks.
output
Output an even number. However, insert a line break at the end.
Constraint
* $ N $ is an integer greater than or equal to $ 1 $ and less than or equal to $ 100 $
* $ A_1, A_2, A_3, \ dots, A_N $ are integers between $ 1 $ and $ 100 $
Input example 1
Five
4 3 5 2 6
Output example 1
3
$ A_1 = 4 $, $ A_4 = 2 $ and $ A_5 = 6 $ are even numbers. Therefore, the even number is $ 3 $.
Input example 2
3
2 2 2
Output example 2
3
Even if the numbers are the same, if the positions in $ A_1, A_2, A_3, \ dots, A_N $ are different, they are counted as different numbers.
Example
Input
5
4 3 5 2 6
Output
3
|
#include <bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
#define int long long
using namespace std;
typedef pair<int,int>P;
#define fi first
#define se second
signed main(){
int n,s=0;
cin>>n;
while(n--){
int a;
cin>>a;
if(a%2==0)s++;
}
cout<<s<<endl;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.