input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
Problem description
Tris (or as her parents call her Beatrice) is going through a series of training and evaluation to get into top 10 and remain in Dauntless Faction. She is currently placed 12th and will become faction-less if she fails, today.
Four (or Tobias) gives Tris a string, consisting of 'i'(s) and 'd'(s) only. Tris has to select a number and increment it by 1 when she encounters 'i' and reduce it by 1 when she encounters 'd'. Thus calculate the final result.
There are several results possible, but Four wants the starting number and the corresponding result, such that their sum is minimum. However there is a catch, like in all Dauntless exercises, the number cannot be negative at any step.
Input
First line contains number of test cases.For each test case you have the string. given by Four to Tris
Output
Help Tris by telling her the starting number and the corresponding result (In correct order), separated by a space. Print result for each test case in a new line.
Constraints
SubTask 1 - 70 Points
1 ≤ T ≤ 100
1 ≤ length(string) ≤ 10^3
SubTask 2 - 30 Points
T =1
1 ≤ length(string) ≤ 100
Example
Input:
1
iidiiii
Output:
0 5
Explanation
0 - 1(i) - 2(i) - 1(d) - 2(i) - 3(i) - 4(i) - 5(i)
we start with 0 (zero) and add 1 for every 'i' and subtract 1 for every 'd' , checking at each step that value does not become negative
|
for t in xrange(int(raw_input())):
s = raw_input()
count = 0
start = 0
for c in s:
if c=='i':
start += 1
else:
start -= 1
if (start<0):
start = 0
count += 1
print count, start
|
So, you are bored and you think about playing a game. The game is like, if you win your money will be
doubled and eleven dollars extra will be added to it. If you lose, your money will be halved (if the
amount is odd, it will be halved to the upper integer). The inital amount of money you have is 'X'. A
sequence of W and L are given as input, and 'X' is given initially. You have to find the amount of money
remaining with you at the end of the game.
Input
The first line contains a single integer X denoting the amount of money you initially have.
The second line contains a sequence of characters of W and L representing Win and Loss respsectively.
Output
output a single line containing the amount you have at the end of the game.
Constraints
Length of sequence ≤ 1000
Example
Input #1:
51
L
Output #1:
26
Input #2:
23
LWLW
Output #2:
47
Explanation
Example case 1. The game is a loss. So, the amount of money is to be halved.
|
import math
x = input()
z = raw_input()
l = len(z)
for y in xrange(l):
if z[y]=="W":
x*=2
x+=11
else:
x = int(math.ceil(x/float(2)))
print x
|
Three numbers A, B and C are the inputs. Write a program to find second largest among three numbers.
Input
The first line contains an integer T, total number of testcases. Then follow T lines, each line contains three integers A, B and C.
Output
Display the second largest among A, B and C.
Constraints
1 ≤ T ≤ 1000
1 ≤ A,B,C ≤ 1000000
Example
Input
3
120 11 400
10213 312 10
10 3 450
Output
120
312
10
|
n=input()
for i in range(n):
a=raw_input()
s=str(a).split()
s=[int(s[0]),int(s[1]),int(s[2])]
s.sort ()
print s[1]
|
On the eve of Republic Day, Teacher decided to distribute candies among N students.She brought the candies in a box and
placed it in front of students. She allowed every student to take out some candies. But each one of them tried
to take out as much candies as possible. That's why, Not all students were happy. She called all students and
requested for their bags of candies. Now she wants to distribute candies equally among all bags. She'll be performing
two operations.
Pick up a candy from a bag.
Put a candy into another bag.
Both operations require 1 unit of time. You are given with bags of N students with number of candies
in it. You have to check whether candies can be distributed equally among all bags or not. If it can be distributed then
calculate the time required for total distribution.
Input
First Line contains number of test cases T.
Every test case consist of two lines, First line contains N i.e. Number of Bags and next line contains N
space separated integers A1, A2, ..., AN , where i^th integer
indicates number of candies in i^th bag.
Output
If candies can be distributed equally then output the time required for distribution in new line,
else, output "-1" (without quotes) in new line.
Constraints
1 ≤ T ≤ 10
1 ≤ N ≤ 100
0 ≤ Number of Candies in each bag ≤ 1000
Example
Input:
3
3
1 2 3
3
1 2 1
4
9 7 8 0
Output:
2
-1
12
Explanation
Example case 1.Teacher picks up a candy from a bag with maximum candies i.e. 3^rd bag and put it in the bag with minimum candies i.e. 1^st bag. Now all bags have two candies each. Total time required for distribution is 2.
|
T = int(raw_input())
for t in range(T):
tot =0
n = int(raw_input())
a = map(int,raw_input().split())
m = sum(a)
if m%n!=0:
print -1
else:
for i in range(n):
if abs(a[i]-m//n) >0:
tot += abs(a[i]-m//n)
print tot
|
Chef Datta likes betting in Indian Premier League very much.
He has 10000 rupees. Today the match is between team A and team B. The winning probability of team A is PA, and hence winning probability of team B is PB = 1 − PA.
Datta is free to bet any integral amount of money on any of the two teams as long as the total amount of money bet is at most 10000 rupees.
Help him know the expected amount of money he will eventually have if today he places his bet(s) optimally.
Rules of the game:
If team X with winning probability PX actually wins and someone bets M rupees on this team, he will gain (2*(1−PX)) * M rupees.
If team X with winning probability PX actually loses and someone bets N rupees on this team, he will just lose N rupees.
Input
First line contains single integer T, the number of testcases. Then T lines follow, each line contains PA the probability that team A wins.
Output
For each test case output single line containing the expected amount of money Datta will eventually have today if he places his bet(s) optimally. Your answer will be accepted if the absolute error is less than 10^−6.
Constraints
1 ≤ T ≤ 100001 (10^5+1)
0.0 ≤ PA ≤ 1.0
PA has at most 5 digits after the decimal point.
Example
Input:
1
0.510
Output:
10098
Example bet:
Look at the following situation:
If chef Datta bets 6,000 on team A and 4,000 on team B, the expected amount of money he will have after the bet is settled is 10,018. Apparently that is not the best he can do ;)
|
'''
Predictopus
Problem code: PREDICT
Chef Datta likes betting in Indian Premier League very much.
He has 10000 rupees. Today the match is between team A and team B.
The winning probability of team A is PA, and hence winning
probability of team B is PB = 1 - PA.
Datta is free to bet any integral amount of money on any of the
two teams as long as the total amount of money bet is at most
10000 rupees.
Help him know the expected amount of money he will eventually have
if today he places his bet(s) optimally.
Rules of the game:
If team X with winning probability PX actually wins and someone
bets M rupees on this team, he will gain (2*(1-PX)) * M rupees.
If team X with winning probability PX actually loses and someone
bets N rupees on this team, he will just lose N rupees.
Input
First line contains single integer T, the number of testcases.
Then T lines follow, each line contains PA the probability that
team A wins.
Output
For each test case output single line containing the expected
amount of money Datta will eventually have today if he places his
bet(s) optimally. Your answer will be accepted if the absolute
error is less than 10-6.
Constraints
1 <= T <= 100001 (10^5+1)
0.0 <= PA <= 1.0
PA has at most 5 digits after the decimal point.
Example
Input:
1
0.510
Output:
10098
Example bet:
Look at the following situation:
A = 51%
B = 49%
Bet A = 6000
Bet B = 4000
If chef Datta bets 6,000 on team A and 4,000 on team B, the
expected amount of money he will have after the bet is settled is
10,018. Apparently that is not the best he can do ;)
Author: mkagenius
Tester: tuananh93
Date Added: 22-04-2013
Time Limit: 1 sec
Source Limit: 50000 Bytes
'''
from sys import stdin,stderr
def solve(P):
# A - bet A
# B - bet B
# E = (A + 2*(1-P) * A) * P + (B + 2*P * B) * (1-P) + 10000 - (A+B)
# E = 3*P*A + B(1+P) - 2*P*P(A+B) + 10000 - (A+B)
#
# Based on assumption of we should always deploy all the money,
# where A+B = 10000
#
# E = 30000*P + B*(1-2*P) - 20000*P*P
#
# when P > 50%, B*(1-2*P) become negative
if P >= 0.5:
A,B = 10000,0
else:
A,B = 0,10000
ans = 30000 * P + B * (1-2*P) - 20000 * P*P
return ans
def check_test(A, B, data='', case=[0]):
print
print "test %d:" % case[0]
print A
if abs(A-B) > 1e-9:
if data:
print data
print '>>>', A
print '<<<', B
print "!!!!!!!! FAIL !!!!!!!!"
else:
print ":::::::) OK"
case[0] += 1
def unit_test():
A, ans = 0.510, 10098
check_test(solve(A), ans, A)
A, ans = 0.490, 10098
check_test(solve(A), ans, A)
def output():
for case in xrange(1, int(stdin.next()) + 1):
A = float(stdin.next().strip())
ans = solve(A)
print "%.6f" % ans
if __name__ == '__main__':
# unit_test()
output()
|
[Chopsticks (singular: chopstick) are short, frequently tapered sticks used in pairs of equal length, which are used as the traditional eating utensils of China, Japan, Korea and Vietnam. Originated in ancient China, they can also be found in some areas of Tibet and Nepal that are close to Han Chinese populations, as well as areas of Thailand, Laos and Burma which have significant Chinese populations. Chopsticks are most commonly made of wood, bamboo or plastic, but in China, most are made out of bamboo. Chopsticks are held in the dominant hand, between the thumb and fingers, and used to pick up pieces of food.]
Retrieved from wikipedia
Actually, the two sticks in a pair of chopsticks need not be of the same length. A pair of sticks can be used to eat as long as the difference in their length is at most D. The Chef has N sticks in which the i^th stick is L[i] units long. A stick can't be part of more than one pair of chopsticks. Help the Chef in pairing up the sticks to form the maximum number of usable pairs of chopsticks.
Input
The first line contains two space-separated integers N and D. The next N lines contain one integer each, the i^th line giving the value of L[i].
Output
Output a single line containing the maximum number of pairs of chopsticks the Chef can form.
Constraints
1 ≤ N ≤ 100,000 (10^ 5 )
0 ≤ D ≤ 1,000,000,000 (10^ 9 )
1 ≤ L[i] ≤ 1,000,000,000 (10^ 9 ) for all integers i from 1 to N
Example
Input:
5 2
1
3
3
9
4
Output:
2
Explanation
The 5 sticks have lengths 1, 3, 3, 9 and 4 respectively. The maximum allowed difference in the lengths of two sticks forming a pair is at most 2.
It is clear that the 4th stick (length 9) cannot be used with any other stick.
The remaining 4 sticks can can be paired as (1st and 3rd) and (2nd and 5th) to form 2 pairs of usable chopsticks.
|
arr=raw_input().split(" ")
n=int(arr[0])
d=int(arr[1])
inte=[]
count=0
for i in range(n):
inte.append(int(raw_input()))
inte.sort()
#print inte
i=0
while i<n-1:
if (inte[i+1]-inte[i])<=d:
count+=1
i+=2
else:
i+=1
print count
|
Natasha travels around Mars in the Mars rover. But suddenly it broke down, namely — the logical scheme inside it. The scheme is an undirected tree (connected acyclic graph) with a root in the vertex 1, in which every leaf (excluding root) is an input, and all other vertices are logical elements, including the root, which is output. One bit is fed to each input. One bit is returned at the output.
There are four types of logical elements: [AND](https://en.wikipedia.org/wiki/Logical_conjunction) (2 inputs), [OR](https://en.wikipedia.org/wiki/Logical_disjunction) (2 inputs), [XOR](https://en.wikipedia.org/wiki/Exclusive_or) (2 inputs), [NOT](https://en.wikipedia.org/wiki/Negation) (1 input). Logical elements take values from their direct descendants (inputs) and return the result of the function they perform. Natasha knows the logical scheme of the Mars rover, as well as the fact that only one input is broken. In order to fix the Mars rover, she needs to change the value on this input.
For each input, determine what the output will be if Natasha changes this input.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^6) — the number of vertices in the graph (both inputs and elements).
The i-th of the next n lines contains a description of i-th vertex: the first word "AND", "OR", "XOR", "NOT" or "IN" (means the input of the scheme) is the vertex type. If this vertex is "IN", then the value of this input follows (0 or 1), otherwise follow the indices of input vertices of this element: "AND", "OR", "XOR" have 2 inputs, whereas "NOT" has 1 input. The vertices are numbered from one.
It is guaranteed that input data contains a correct logical scheme with an output produced by the vertex 1.
Output
Print a string of characters '0' and '1' (without quotes) — answers to the problem for each input in the ascending order of their vertex indices.
Example
Input
10
AND 9 4
IN 1
IN 1
XOR 6 5
AND 3 7
IN 0
NOT 10
IN 1
IN 1
AND 2 8
Output
10110
Note
The original scheme from the example (before the input is changed):
<image>
Green indicates bits '1', yellow indicates bits '0'.
If Natasha changes the input bit 2 to 0, then the output will be 1.
If Natasha changes the input bit 3 to 0, then the output will be 0.
If Natasha changes the input bit 6 to 1, then the output will be 1.
If Natasha changes the input bit 8 to 0, then the output will be 1.
If Natasha changes the input bit 9 to 0, then the output will be 0.
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
vector<int> op;
vector<vector<int>> v;
vector<bool> val;
int mp[1000001][2];
vector<int> saved;
vector<int> cur;
vector<pair<int, int>> curc;
vector<int> parent;
int fans = -1;
static string s;
int solve(int k) {
cur.push_back(k);
if (v[k].size() == 0) return saved[k] = val[k];
if (v[k].size() == 1) return saved[k] = !solve(v[k][0]);
if (op[k] == 1) return saved[k] = (solve(v[k][0]) & solve(v[k][1]));
if (op[k] == 2) return saved[k] = (solve(v[k][0]) | solve(v[k][1]));
if (op[k] == 3) return saved[k] = (solve(v[k][0]) ^ solve(v[k][1]));
return 0;
}
void solve2(int k, int num) {
if (k == 0) {
fans = num;
return;
}
if (mp[k][num] != -1) {
fans = mp[k][num];
return;
}
int p = parent[k];
if (v[p].size() == 1) {
curc.push_back({p, 1 - num});
solve2(p, 1 - num);
return;
}
int num1 = v[p][0], num2 = v[p][1];
bool ar1, ar2;
if (num1 == k)
ar1 = num, ar2 = saved[v[p][1]];
else
ar2 = num, ar1 = saved[v[p][0]];
if (op[p] == 1) {
curc.push_back({p, ar1 & ar2});
solve2(p, ar1 & ar2);
}
if (op[p] == 2) {
curc.push_back({p, ar1 | ar2});
solve2(p, ar1 | ar2);
}
if (op[p] == 3) {
curc.push_back({p, ar1 ^ ar2});
solve2(p, ar1 ^ ar2);
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
memset(mp, -1, sizeof(mp));
op.resize(n);
val.resize(n);
parent.resize(n);
v.assign(n, {});
saved.resize(n, 0);
for (int i = 0; i < n; i++) {
cin >> s;
if (s == "IN") {
op[i] = 0;
int num;
cin >> num;
val[i] = num;
} else if (s == "NOT") {
int num;
cin >> num;
op[i] = 0;
num--;
v[i].push_back(num);
parent[num] = i;
} else {
if (s == "AND") op[i] = 1;
if (s == "OR") op[i] = 2;
if (s == "XOR") op[i] = 3;
int num1, num2;
cin >> num1 >> num2;
num1--;
num2--;
v[i].push_back(num1);
v[i].push_back(num2);
parent[num1] = i;
parent[num2] = i;
}
}
bool ans = solve(0);
for (int i = 0; i < n; i++) {
mp[i][saved[i]] = ans;
}
parent[0] = -1;
for (int i = 0; i < n; i++) {
if (v[i].size() == 0) {
solve2(i, 1 - val[i]);
if ((int)curc.size()) {
for (auto xx : curc) mp[xx.first][xx.second] = fans;
}
curc.clear();
cout << fans;
}
}
cout << endl;
}
|
Little D is a friend of Little C who loves intervals very much instead of number "3".
Now he has n intervals on the number axis, the i-th of which is [a_i,b_i].
Only the n intervals can not satisfy him. He defines the value of an interval of intervals [l,r] (1 ≤ l ≤ r ≤ n, l and r are both integers) as the total length of the union of intervals from the l-th to the r-th.
He wants to select exactly k different intervals of intervals such that the sum of their values is maximal. Please help him calculate the maximal sum.
Input
First line contains two integers n and k (1 ≤ n ≤ 3 ⋅ 10^5, 1 ≤ k ≤ min\{(n(n+1))/(2),10^9\}) — the number of intervals Little D has and the number of intervals of intervals he will select.
Each of the next n lines contains two integers a_i and b_i, the i-th line of the n lines describing the i-th interval (1 ≤ a_i < b_i ≤ 10^9).
Output
Print one integer — the maximal sum of values Little D can get.
Examples
Input
2 1
1 3
2 4
Output
3
Input
3 3
1 4
5 7
3 6
Output
15
Note
For the first example, Little D will select [1,2], the union of the first interval and the second interval is [1,4], whose length is 3.
For the second example, Little D will select [1,2], [2,3] and [1,3], the answer is 5+6+4=15.
|
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > s;
set<pair<int, int> >::iterator it;
vector<pair<int, int> > vec[300020];
int n, k, sum[300020], f[300020];
long long num, ans, csum;
inline void add(int x, int len, int id) {
if (!len || !x) return;
vec[x].push_back(make_pair(id, len));
sum[x] += len;
}
void init() {
for (int i = 1; i <= n; ++i) {
vec[i].push_back(make_pair(i + 1, -sum[i]));
}
}
void check(int mid) {
num = csum = 0;
memset(f, 0, sizeof(f));
int l = 1, len = 0;
long long lens = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < (int)vec[i].size(); ++j) {
if (vec[i][j].first < l)
len += vec[i][j].second,
lens += (long long)vec[i][j].second * (l - vec[i][j].first);
else
f[vec[i][j].first] += vec[i][j].second;
}
while (l <= i && len + f[l] >= mid) len += f[l++], lens += len;
num += l - 1, csum += lens;
}
if (num > k) {
csum -= (long long)mid * (num - k);
}
}
int main() {
scanf("%d %d", &n, &k);
s.insert(make_pair(1, 0)), s.insert(make_pair(1e9 + 10, 0));
for (int i = 1; i <= n; ++i) {
int l, r;
scanf("%d %d", &l, &r);
int cur = -1, lst = l;
while (1) {
it = s.lower_bound(make_pair(l, 0));
if (cur == -1) cur = (*it).second;
if ((*it).first <= r) {
add(i, (*it).first - lst, (*it).second + 1);
lst = (*it).first;
s.erase(it);
} else {
add(i, r - lst, (*it).second + 1);
s.insert(make_pair(r, i));
break;
}
}
s.insert(make_pair(l, cur));
}
init();
int l = 1, r = 1e9;
while (l <= r) {
int mid = (l + r) >> 1;
check(mid);
if (num >= k)
l = mid + 1, ans = csum;
else
r = mid - 1;
}
cout << ans << endl;
}
|
Once upon a time there was only one router in the well-known company Bmail. Years went by and over time new routers were purchased. Every time they bought a new router, they connected it to one of the routers bought before it. You are given the values p_i — the index of the router to which the i-th router was connected after being purchased (p_i < i).
There are n routers in Boogle in total now. Print the sequence of routers on the path from the first to the n-th router.
Input
The first line contains integer number n (2 ≤ n ≤ 200000) — the number of the routers. The following line contains n-1 integers p_2, p_3, ..., p_n (1 ≤ p_i < i), where p_i is equal to index of the router to which the i-th was connected after purchase.
Output
Print the path from the 1-st to the n-th router. It starts with 1 and ends with n. All the elements in the path should be distinct.
Examples
Input
8
1 1 2 2 3 2 5
Output
1 2 5 8
Input
6
1 2 3 4 5
Output
1 2 3 4 5 6
Input
7
1 1 2 3 4 3
Output
1 3 7
|
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
public class bmail{
static void path(Stack<Integer> s)
{
while(!s.isEmpty())
{
System.out.print(s.pop() + " ");
}
}
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n= sc.nextInt();
int arr[]=new int[n+1];
Stack<Integer> stack=new Stack<Integer>();
for(int i=1; i<n; i++)
{
arr[i]= sc.nextInt();
}
int j=n;
while(j>1)
{
stack.add(j);
j=arr[j-1];
}
stack.add(1);
path(stack);
}
}
|
The night after the graduation ceremony graduate students of German University in Cairo (GUC) are playing darts. As there's no real dart board available, the photographs of members of the GUC upper management are being used.
So, n rectangular photos are placed on the wall. They can overlap arbitrary and even coincide. The photos are not necessarily placed horizontally or vertically, they could also be rotated before being pinned to the wall.
The score of one dart throw is simply the number of photos the dart went through.
Fatma has made a throw but her score was not recorded. She only remembers that she did make it into at least one photo.
Assuming that the probability distribution of the throw is equal across the whole wall, what would be the expectation of Fatma's score?
Input
The first line of input contains integer n (1 ≤ n ≤ 500) — the number of photos on the wall. Then follow n lines describing the photos, each containing 8 single-space-separated integers (coordinates of 4 vertices): x1, y1, x2, y2, x3, y3, x4, y4. Each photo is a rectangle with a nonzero area. The coordinates are integers, not exceeding 104 by absolute value. The coordinates of the rectangle are given in either clockwise or counterclockwise order.
Output
Print the expected score of the throw. The answer will be accepted if it has absolute or relative error not exceeding 10 - 6.
Examples
Input
1
0 0 0 2 2 2 2 0
Output
1.0000000000
Input
1
-1 0 0 1 1 0 0 -1
Output
1.0000000000
Input
4
0 0 0 1 3 1 3 0
0 0 0 3 1 3 1 0
3 3 2 3 2 0 3 0
3 3 3 2 0 2 0 3
Output
1.5000000000
Input
2
-1 0 0 1 1 0 0 -1
0 0 1 1 2 0 1 -1
Output
1.1428571429
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 600;
const double eps = 1e-8;
inline int dcmp(double x) { return fabs(x) < eps ? 0 : (x > 0 ? 1 : -1); }
struct Point {
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
void scan() { scanf("%lf%lf", &x, &y); }
};
Point operator+(Point a, Point b) { return Point(a.x + b.x, a.y + b.y); }
Point operator-(Point a, Point b) { return Point(a.x - b.x, a.y - b.y); }
double operator^(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double operator*(Point a, Point b) { return a.x * b.y - a.y * b.x; }
struct Rect {
Point p[5];
Point& operator[](int i) { return p[i]; }
void scan() {
int i;
for (i = 0; i < 4; i++) p[i].scan();
p[4] = p[0];
}
double area() {
int i;
double s = 0;
for (i = 0; i < 4; i++) s += p[i] * p[i + 1];
return s / 2;
}
};
int n;
Rect r[maxn];
double ans = 0;
pair<double, int> pos[maxn * 8];
int ps;
inline double get_pos(Point a, Point b, Point p) {
return dcmp(b.x - a.x) ? (p.x - a.x) / (b.x - a.x)
: (p.y - a.y) / (b.y - a.y);
}
double areaunion() {
int i, j, ii, jj, d1, d2;
double sum = 0, s1, s2, s0;
for (i = 0; i < n; i++)
for (ii = 0; ii < 4; ii++) {
s0 = 0;
ps = 0;
pos[ps++] = make_pair(0, 0), pos[ps++] = make_pair(1, 0);
for (j = 0; j < n; j++)
if (i != j)
for (jj = 0; jj < 4; jj++) {
d1 = dcmp((r[i][ii + 1] - r[i][ii]) * (r[j][jj] - r[i][ii]));
d2 = dcmp((r[i][ii + 1] - r[i][ii]) * (r[j][jj + 1] - r[i][ii]));
if (!d1 && !d2) {
if (dcmp((r[i][ii + 1] - r[i][ii]) ^ (r[j][jj + 1] - r[j][jj])) >
0 &&
i > j) {
pos[ps++] =
make_pair(get_pos(r[i][ii], r[i][ii + 1], r[j][jj]), 1);
pos[ps++] = make_pair(
get_pos(r[i][ii], r[i][ii + 1], r[j][jj + 1]), -1);
}
} else {
s1 = (r[j][jj + 1] - r[j][jj]) * (r[i][ii] - r[j][jj]);
s2 = (r[j][jj + 1] - r[j][jj]) * (r[i][ii + 1] - r[j][jj]);
if (d1 < 0 && d2 >= 0)
pos[ps++] = make_pair(s1 / (s1 - s2), -1);
else if (d1 >= 0 && d2 < 0)
pos[ps++] = make_pair(s1 / (s1 - s2), 1);
}
}
sort(pos, pos + ps);
double now, prv = min(max(pos[0].first, 0.0), 1.0);
int cur = pos[0].second;
for (j = 1; j < ps; j++) {
now = min(max(pos[j].first, 0.0), 1.0);
if (!cur) s0 += now - prv;
cur += pos[j].second;
prv = now;
}
sum += r[i][ii] * r[i][ii + 1] * s0;
}
return sum / 2;
}
int main() {
int i, j;
double s0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
r[i].scan();
s0 = r[i].area();
if (dcmp(s0) < 0) {
reverse(r[i].p, r[i].p + 4);
r[i][4] = r[i][0];
s0 = -s0;
}
ans += s0;
}
ans /= areaunion();
printf("%.9lf\n", ans);
return 0;
}
|
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya got an array consisting of n numbers, it is the gift for his birthday. Now he wants to sort it in the non-decreasing order. However, a usual sorting is boring to perform, that's why Petya invented the following limitation: one can swap any two numbers but only if at least one of them is lucky. Your task is to sort the array according to the specified limitation. Find any possible sequence of the swaps (the number of operations in the sequence should not exceed 2n).
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of elements in the array. The second line contains n positive integers, not exceeding 109 — the array that needs to be sorted in the non-decreasing order.
Output
On the first line print number k (0 ≤ k ≤ 2n) — the number of the swaps in the sorting. On the following k lines print one pair of distinct numbers (a pair per line) — the indexes of elements to swap. The numbers in the array are numbered starting from 1. If it is impossible to sort the given sequence, print the single number -1.
If there are several solutions, output any. Note that you don't have to minimize k. Any sorting with no more than 2n swaps is accepted.
Examples
Input
2
4 7
Output
0
Input
3
4 2 1
Output
1
1 3
Input
7
77 66 55 44 33 22 11
Output
7
1 7
7 2
2 6
6 7
3 4
5 3
4 5
|
#include <bits/stdc++.h>
using namespace std;
int islucky(int n) {
while (n > 0) {
if (n % 10 == 4 || n % 10 == 7)
n = n / 10;
else
return 0;
}
return 1;
}
int a[100001];
map<int, int> val;
map<pair<int, int>, int> iden;
map<int, pair<int, int> > rev;
vector<pair<int, int> > ans;
int idx = -1;
int main() {
int n;
scanf("%d", &n);
int tmp;
for (int i = 0; i < n; i++) {
scanf("%d", &tmp);
a[i] = tmp;
if (val.find(tmp) == val.end()) {
if (islucky(tmp)) {
idx = tmp;
}
iden[make_pair(tmp, 0)] = i;
rev[i] = make_pair(tmp, 0);
val[tmp] = 1;
} else {
iden[make_pair(tmp, val[tmp])] = i;
rev[i] = make_pair(tmp, val[tmp]);
val[tmp] = val[tmp] + 1;
}
}
if (idx == -1) {
for (int i = 0; i < n - 1; i++) {
if (a[i + 1] < a[i]) {
cout << "-1" << endl;
return 0;
}
}
}
int cnt = 0;
tmp = idx;
for (map<pair<int, int>, int>::iterator it = iden.begin(); it != iden.end();
it++) {
int from = it->second;
int togo = cnt;
int idxpos = iden[make_pair(tmp, 0)];
if (from == togo) {
cnt++;
continue;
}
if (idxpos == from) {
cnt++;
continue;
}
if ((cnt + 1) != (idxpos + 1))
ans.push_back(make_pair(cnt + 1, idxpos + 1));
if ((cnt + 1) != (from + 1)) ans.push_back(make_pair(cnt + 1, from + 1));
pair<int, int> tomove = rev[cnt];
iden[tomove] = idxpos;
iden[make_pair(tmp, 0)] = from;
rev[from] = make_pair(tmp, 0);
rev[idxpos] = tomove;
cnt++;
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
}
|
You are given a rooted tree with n vertices, the root of the tree is the vertex 1. Each vertex has some non-negative price. A leaf of the tree is a non-root vertex that has degree 1.
Arkady and Vasily play a strange game on the tree. The game consists of three stages. On the first stage Arkady buys some non-empty set of vertices of the tree. On the second stage Vasily puts some integers into all leaves of the tree. On the third stage Arkady can perform several (possibly none) operations of the following kind: choose some vertex v he bought on the first stage and some integer x, and then add x to all integers in the leaves in the subtree of v. The integer x can be positive, negative of zero.
A leaf a is in the subtree of a vertex b if and only if the simple path between a and the root goes through b.
Arkady's task is to make all integers in the leaves equal to zero. What is the minimum total cost s he has to pay on the first stage to guarantee his own win independently of the integers Vasily puts on the second stage? Also, we ask you to find all such vertices that there is an optimal (i.e. with cost s) set of vertices containing this one such that Arkady can guarantee his own win buying this set on the first stage.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the number of vertices in the tree.
The second line contains n integers c_1, c_2, …, c_n (0 ≤ c_i ≤ 10^9), where c_i is the price of the i-th vertex.
Each of the next n - 1 lines contains two integers a and b (1 ≤ a, b ≤ n), denoting an edge of the tree.
Output
In the first line print two integers: the minimum possible cost s Arkady has to pay to guarantee his own win, and the number of vertices k that belong to at least one optimal set.
In the second line print k distinct integers in increasing order the indices of the vertices that belong to at least one optimal set.
Examples
Input
5
5 1 3 2 1
1 2
2 3
2 4
1 5
Output
4 3
2 4 5
Input
3
1 1 1
1 2
1 3
Output
2 3
1 2 3
Note
In the second example all sets of two vertices are optimal. So, each vertex is in at least one optimal set.
|
#include <bits/stdc++.h>
using namespace std;
long long M = 1e9 + 7;
const long long N = 1e6 + 7;
long long n;
long long a[N];
vector<long long> ad[N];
long long dp[N][2];
bool isl[N];
void solve(long long v, long long p) {
if (ad[v].size() == 1 && v != 1) {
isl[v] = 1;
dp[v][0] = a[v];
return;
}
vector<long long> dif, x, y;
long long s = 0;
for (auto u : ad[v])
if (u != p) {
solve(u, v);
if (isl[u])
x.push_back(dp[u][0] - dp[u][1]);
else
y.push_back(dp[u][0] - dp[u][1]);
dif.push_back(dp[u][0] - dp[u][1]);
s += dp[u][0];
}
sort(dif.begin(), dif.end());
sort(x.begin(), x.end());
sort(y.begin(), y.end());
dp[v][0] = min(s, s - dif.back() + a[v]);
dp[v][1] = s - dif.back();
}
bool mrk[N][2];
set<long long> res;
void get(long long v, long long knd, long long p) {
if (mrk[v][knd]) return;
mrk[v][knd] = 1;
if (ad[v].size() == 1 && v != 1) {
if (knd == 0) res.insert(v);
return;
}
vector<pair<long long, long long> > dif, x, y;
long long s = 0;
for (auto u : ad[v])
if (u != p) {
s += dp[u][0];
dif.push_back({dp[u][0] - dp[u][1], u});
if (isl[u])
x.push_back({dp[u][0] - dp[u][1], u});
else
y.push_back({dp[u][0] - dp[u][1], u});
}
sort(x.begin(), x.end());
sort(y.begin(), y.end());
sort(dif.begin(), dif.end());
if (knd == 0) {
if (dif.back().first <= a[v]) {
for (auto u : ad[v])
if (u != p) get(u, 0, v);
}
if (dif.back().first >= a[v]) {
res.insert(v);
if (dif.size() > 1 && dif[dif.size() - 2].first == dif.back().first) {
for (auto pr : dif) {
if (pr.first == dif.back().first)
get(pr.second, 0, v), get(pr.second, 1, v);
else
get(pr.second, 0, v);
}
} else
for (auto pr : dif)
if (pr.first == dif.back().first)
get(pr.second, 1, v);
else
get(pr.second, 0, v);
}
} else {
long long f = s - dif.back().first;
long long o = 1e18, t = 1e18;
if (f <= min(o, t)) {
if (dif.size() > 1 && dif[dif.size() - 2].first == dif.back().first) {
for (auto pr : dif)
if (pr.first == dif.back().first)
get(pr.second, 0, v), get(pr.second, 1, v);
else
get(pr.second, 0, v);
} else
for (auto pr : dif)
if (pr.first == dif.back().first)
get(pr.second, 1, v);
else
get(pr.second, 0, v);
}
if (t <= min(o, f)) {
res.insert(v);
if (y.size() > 2 && y[y.size() - 3].first == y.back().first) {
for (auto pr : y)
if (pr.first == y.back().first)
get(pr.second, 0, v), get(pr.second, 1, v);
else
get(pr.second, 0, v);
} else
for (auto pr : y)
if (pr.first == y.back().first)
get(pr.second, 1, v);
else
get(pr.second, 0, v);
}
if (o <= min(t, f)) {
res.insert(v);
if (x.size() > 1 && x[x.size() - 2].first == x.back().first) {
for (auto pr : x)
if (pr.first == x.back().first)
get(pr.second, 0, v), get(pr.second, 1, v);
else
get(pr.second, 0, v);
} else
for (auto pr : x)
if (pr.first == x.back().first)
get(pr.second, 1, v);
else
get(pr.second, 0, v);
if (y.size() > 1 && y[y.size() - 2].first == y.back().first) {
for (auto pr : y)
if (pr.first == y.back().first)
get(pr.second, 0, v), get(pr.second, 1, v);
else
get(pr.second, 0, v);
} else
for (auto pr : y)
if (pr.first == y.back().first)
get(pr.second, 1, v);
else
get(pr.second, 0, v);
}
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i < n; i++) {
long long v, u;
cin >> v >> u;
ad[v].push_back(u);
ad[u].push_back(v);
}
solve(1, 0);
get(1, 0, 0);
long long sm = 0;
cout << dp[1][0] << " " << res.size() << '\n';
for (auto v : res) {
cout << v << ' ';
sm += a[v];
}
}
|
You are given a complete bipartite graph with 2n nodes, with n nodes on each side of the bipartition. Nodes 1 through n are on one side of the bipartition, and nodes n+1 to 2n are on the other side. You are also given an n × n matrix a describing the edge weights. a_{ij} denotes the weight of the edge between nodes i and j+n. Each edge has a distinct weight.
Alice and Bob are playing a game on this graph. First Alice chooses to play as either "increasing" or "decreasing" for herself, and Bob gets the other choice. Then she places a token on any node of the graph. Bob then moves the token along any edge incident to that node. They now take turns playing the following game, with Alice going first.
The current player must move the token from the current vertex to some adjacent unvisited vertex. Let w be the last weight of the last edge that was traversed. The edge that is traversed must be strictly greater than w if the player is playing as "increasing", otherwise, it must be strictly less. The first player unable to make a move loses.
You are given n and the edge weights of the graph. You can choose to play as either Alice or Bob, and you will play against the judge. You must win all the games for your answer to be judged correct.
Interaction
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 50). Description of the test cases follows.
Each test starts with an integer n (1 ≤ n ≤ 50) — the number of nodes on each side of the bipartition.
The next n lines contain n integers a_{ij} (1 ≤ a_{ij} ≤ n^2). a_{ij} denotes the weight of the edge between node i and node j+n. All a_{ij} will be distinct.
You first print a string "A" or "B", denoting which player you want to play ("A" for Alice and "B" for Bob).
If playing as Alice, first print either "I" or "D" (denoting whether you choose "increasing" or "decreasing"). Then, print the node that you wish to start at.
If playing as Bob, read in a character "I" or "D" (denoting whether the judge chose "increasing" or "decreasing"), then the node that the judge chooses to start at.
To make a move, print the index of the node that you wish to go to. To read what move the judge made, read an integer from standard in.
If the judge responds with -1, then that means the judge has determined it has no legal moves (or it may have just given up) and that you won the case. Stop processing this case immediately and start processing the next case.
If the judge responds with -2, that means that the judge has determined that you made an invalid move, so you should exit immediately to avoid getting other verdicts.
If you are unable to make a move or give up, print -1 and then exit immediately. This will give you a Wrong answer verdict.
After printing a move do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
Hack Format
To hack, use the following format. Note that you can only hack with one test case.
The first line should contain a single integer t (t=1).
The second line should contain an integer n (1 ≤ n ≤ 50).
The next n lines should contain n integers each, the a_{ij} (1 ≤ a_{ij} ≤ n^2). a_{ij} denotes the weight of the edge between node i and node j+n. All a_{ij} must be distinct.
The judge will play a uniformly random legal move with this case versus the hacked program. If it has no legal moves left, it will give up and declare the player as the winner.
Example
Input
2
3
3 1 9
2 5 7
6 4 8
6
-1
1
1
I 1
-1
Output
A
D 3
2
B
2
Note
The first example has two test cases. In the first test case, the graph looks like the following.
<image>
In the sample output, the player decides to play as Alice and chooses "decreasing" and starting at node 3. The judge responds by moving to node 6. After, the player moves to node 2. At this point, the judge has no more moves (since the weight must "increase"), so it gives up and prints -1.
In the next case, we have two nodes connected by an edge of weight 1. The player decides to play as Bob. No matter what the judge chooses, the player can move the token to the other node and the judge has no moves so will lose.
|
#include <bits/stdc++.h>
using namespace std;
template <class t>
inline t read(t &x) {
char c = getchar();
bool f = 0;
x = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const int N = 55;
queue<int> q;
int n, w[N][N], key[N][N], a[N][N], b[N][N], ta[N], tb[N];
void doit() {
read(n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) read(w[i][j]);
puts("B");
fflush(stdout);
char o[3];
scanf("%s", o);
int x;
read(x);
if ((o[0] == 'I') ^ (x > n))
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) w[i][j] *= -1;
for (int i = 1; i <= n; i++) {
ta[i] = tb[i] = 0;
q.push(i);
for (int j = 1; j <= n; j++) a[i][j] = b[i][j] = j;
sort(a[i] + 1, a[i] + 1 + n,
[&](int x, int y) { return w[i][x] > w[i][y]; });
sort(b[i] + 1, b[i] + 1 + n,
[&](int x, int y) { return w[x][i] < w[y][i]; });
for (int j = 1; j <= n; j++) key[i][b[i][j]] = j;
}
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = 1; i <= n; i++) {
int y = a[x][i];
if (!tb[y]) {
tb[y] = x;
ta[x] = y;
break;
}
if (key[y][x] < key[y][tb[y]]) {
q.push(tb[y]);
tb[y] = x;
ta[x] = y;
break;
}
}
}
while (~x) {
write(x > n ? tb[x - n] : ta[x] + n);
puts("");
fflush(stdout);
read(x);
}
}
signed main() {
int t;
read(t);
while (t--) doit();
}
|
Toad Ivan has m pairs of integers, each integer is between 1 and n, inclusive. The pairs are (a_1, b_1), (a_2, b_2), …, (a_m, b_m).
He asks you to check if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 300 000, 1 ≤ m ≤ 300 000) — the upper bound on the values of integers in the pairs, and the number of given pairs.
The next m lines contain two integers each, the i-th of them contains two space-separated integers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the integers in the i-th pair.
Output
Output "YES" if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y. Otherwise, print "NO". You can print each letter in any case (upper or lower).
Examples
Input
4 6
1 2
1 3
1 4
2 3
2 4
3 4
Output
NO
Input
5 4
1 2
2 3
3 4
4 5
Output
YES
Input
300000 5
1 2
1 2
1 2
1 2
1 2
Output
YES
Note
In the first example, you can't choose any x, y because for each such pair you can find a given pair where both numbers are different from chosen integers.
In the second example, you can choose x=2 and y=4.
In the third example, you can choose x=1 and y=2.
|
import java.util.*;
import java.io.*;
public class b{
static boolean find(int [][] a,int ind,int n){
int [] map=new int[n+1];
Arrays.fill(map,0);
int x=a[0][ind];
int cnt=1;
for(int i=1;i<a.length;i++){
if(a[i][0]==x || a[i][1]==x){
cnt++;
}
else{
map[a[i][0]]++;map[a[i][1]]++;
}
}
int max=-1;
for(int i : map){
max=Math.max(i,max);
}
return (cnt+max)>=a.length;
}
public static void main(final String [] args)throws IOException{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String [] data=br.readLine().trim().split(" ");
int n=Integer.parseInt(data[0]);
int m=Integer.parseInt(data[1]);
int [][] a=new int[m][2];
for(int i=0;i<m;i++){
data=br.readLine().trim().split(" ");
a[i][0]=Integer.parseInt(data[0]);
a[i][1]=Integer.parseInt(data[1]);
}
if(find(a, 0, n)||find(a,1,n)){
System.out.println("YES");
}
else{
System.out.println("NO");
}
}
}
|
You are given an array a_1, a_2, ..., a_n and an array b_1, b_2, ..., b_n.
For one operation you can sort in non-decreasing order any subarray a[l ... r] of the array a.
For example, if a = [4, 2, 2, 1, 3, 1] and you choose subbarray a[2 ... 5], then the array turns into [4, 1, 2, 2, 3, 1].
You are asked to determine whether it is possible to obtain the array b by applying this operation any number of times (possibly zero) to the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5).
The second line of each query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n).
The third line of each query contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ n).
It is guaranteed that ∑ n ≤ 3 ⋅ 10^5 over all queries in a test.
Output
For each query print YES (in any letter case) if it is possible to obtain an array b and NO (in any letter case) otherwise.
Example
Input
4
7
1 7 1 4 4 5 6
1 1 4 4 5 7 6
5
1 1 3 3 5
1 1 3 3 5
2
1 1
1 2
3
1 2 3
3 2 1
Output
YES
YES
NO
NO
Note
In first test case the can sort subarray a_1 ... a_5, then a will turn into [1, 1, 4, 4, 7, 5, 6], and then sort subarray a_5 ... a_6.
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
int st[maxn << 2];
int a[maxn], b[maxn];
vector<int> pos[maxn];
void build(int id, int l, int r) {
if (l == r) {
st[id] = a[l];
return;
}
int mid = (l + r) >> 1;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
st[id] = min(st[id << 1], st[id << 1 | 1]);
}
void update(int id, int l, int r, int u, int val) {
if (l > u || r < u) return;
if (l == r) {
st[id] = val;
return;
}
int mid = (l + r) >> 1;
update(id << 1, l, mid, u, val);
update(id << 1 | 1, mid + 1, r, u, val);
st[id] = min(st[id << 1], st[id << 1 | 1]);
}
int GetMin(int id, int l, int r, int u, int v) {
if (l > v || r < u) return 1e9;
if (u <= l && r <= v) return st[id];
int mid = (l + r) >> 1;
return min(GetMin(id << 1, l, mid, u, v),
GetMin(id << 1 | 1, mid + 1, r, u, v));
}
string Solve() {
int n;
cin >> n;
for (int i = (1), _b = (n); i <= _b; ++i) pos[i].clear();
for (int i = (1), _b = (n); i <= _b; ++i) cin >> a[i];
for (int i = (n), _b = (1); i >= _b; --i) pos[a[i]].push_back(i);
for (int i = (1), _b = (n); i <= _b; ++i) cin >> b[i];
build(1, 1, n);
int l = 1;
for (int i = (1), _b = (n); i <= _b; ++i) {
if (pos[b[i]].empty()) return "NO";
int nxt = pos[b[i]].back();
pos[b[i]].pop_back();
if (GetMin(1, 1, n, l, nxt) != b[i]) return "NO";
update(1, 1, n, nxt, 1e9);
}
return "YES";
}
int main() {
iostream::sync_with_stdio(false);
cin.tie(0);
int q;
cin >> q;
for (int i = (1), _b = (q); i <= _b; ++i) cout << Solve() << '\n';
return 0;
}
|
You are given integer n. You have to arrange numbers from 1 to 2n, using each of them exactly once, on the circle, so that the following condition would be satisfied:
For every n consecutive numbers on the circle write their sum on the blackboard. Then any two of written on the blackboard 2n numbers differ not more than by 1.
For example, choose n = 3. On the left you can see an example of a valid arrangement: 1 + 4 + 5 = 10, 4 + 5 + 2 = 11, 5 + 2 + 3 = 10, 2 + 3 + 6 = 11, 3 + 6 + 1 = 10, 6 + 1 + 4 = 11, any two numbers differ by at most 1. On the right you can see an invalid arrangement: for example, 5 + 1 + 6 = 12, and 3 + 2 + 4 = 9, 9 and 12 differ more than by 1.
<image>
Input
The first and the only line contain one integer n (1 ≤ n ≤ 10^5).
Output
If there is no solution, output "NO" in the first line.
If there is a solution, output "YES" in the first line. In the second line output 2n numbers — numbers from 1 to 2n in the order they will stay in the circle. Each number should appear only once. If there are several solutions, you can output any of them.
Examples
Input
3
Output
YES
1 4 5 2 3 6
Input
4
Output
NO
Note
Example from the statement is shown for the first example.
It can be proved that there is no solution in the second example.
|
import java.io.*;
import java.util.*;
public class Main {
public static void main( String[] args ) {
BufferedReader bis = new BufferedReader(new InputStreamReader(System.in));
// BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
int n = in.nextInt();
if (n == 1){
out.println("YES");
out.print("1 2");
}else{
if (n % 2 == 0){
out.println("NO");
}else{
out.print("YES\n");
int[] answ = new int[2 * n];
answ[0] = 1;
for (int i = 1; i < n; i++){
if (i % 2 == 1){
answ[i] = answ[i - 1] + 3;
}else{
answ[i] = answ[i - 1] + 1;
}
}
for (int i = n; i < 2 * n; i++){
if (i % 2 == 1){
answ[i] = answ[i - n] + 1;
}else{
answ[i] = answ[i - n] - 1;
}
}
for (int i = 0; i < 2 * n; i++){
out.print(answ[i] + " ");
}
}
}
out.flush();
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
}
}
|
Let's look at the following process: initially you have an empty stack and an array s of the length l. You are trying to push array elements to the stack in the order s_1, s_2, s_3, ... s_{l}. Moreover, if the stack is empty or the element at the top of this stack is not equal to the current element, then you just push the current element to the top of the stack. Otherwise, you don't push the current element to the stack and, moreover, pop the top element of the stack.
If after this process the stack remains empty, the array s is considered stack exterminable.
There are samples of stack exterminable arrays:
* [1, 1];
* [2, 1, 1, 2];
* [1, 1, 2, 2];
* [1, 3, 3, 1, 2, 2];
* [3, 1, 3, 3, 1, 3];
* [3, 3, 3, 3, 3, 3];
* [5, 1, 2, 2, 1, 4, 4, 5];
Let's consider the changing of stack more details if s = [5, 1, 2, 2, 1, 4, 4, 5] (the top of stack is highlighted).
1. after pushing s_1 = 5 the stack turn into [5];
2. after pushing s_2 = 1 the stack turn into [5, 1];
3. after pushing s_3 = 2 the stack turn into [5, 1, 2];
4. after pushing s_4 = 2 the stack turn into [5, 1];
5. after pushing s_5 = 1 the stack turn into [5];
6. after pushing s_6 = 4 the stack turn into [5, 4];
7. after pushing s_7 = 4 the stack turn into [5];
8. after pushing s_8 = 5 the stack is empty.
You are given an array a_1, a_2, …, a_n. You have to calculate the number of its subarrays which are stack exterminable.
Note, that you have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the length of array a.
The second line of each query contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n) — the elements.
It is guaranteed that the sum of all n over all queries does not exceed 3 ⋅ 10^5.
Output
For each test case print one integer in single line — the number of stack exterminable subarrays of the array a.
Example
Input
3
5
2 1 1 2 2
6
1 2 1 1 3 2
9
3 1 2 2 1 6 6 3 3
Output
4
1
8
Note
In the first query there are four stack exterminable subarrays: a_{1 … 4} = [2, 1, 1, 2], a_{2 … 3} = [1, 1], a_{2 … 5} = [1, 1, 2, 2], a_{4 … 5} = [2, 2].
In the second query, only one subarray is exterminable subarray — a_{3 … 4}.
In the third query, there are eight stack exterminable subarrays: a_{1 … 8}, a_{2 … 5}, a_{2 … 7}, a_{2 … 9}, a_{3 … 4}, a_{6 … 7}, a_{6 … 9}, a_{8 … 9}.
|
#include <bits/stdc++.h>
using namespace std;
int arr[300105];
int _next[300105];
map<int, int> mp[300105];
int dp[300105];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
_next[i] = -1;
mp[i].clear();
dp[i] = 0;
}
dp[n] = 0;
mp[n].clear();
mp[n - 1][arr[n - 1]] = n - 1;
for (int i = n - 1; i >= 0; i--) {
if (mp[i + 1].count(arr[i])) {
_next[i] = mp[i + 1][arr[i]];
swap(mp[i], mp[_next[i] + 1]);
if (_next[i] < n - 1) {
mp[i][arr[_next[i] + 1]] = _next[i] + 1;
}
}
mp[i][arr[i]] = i;
}
long long ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (_next[i] == -1) continue;
dp[i] = dp[_next[i] + 1] + 1;
}
for (int i = 0; i < n; i++) {
ans += dp[i];
}
cout << ans << '\n';
}
}
|
The only difference between easy and hard versions is constraints.
There are n kids, each of them is reading a unique book. At the end of any day, the i-th kid will give his book to the p_i-th kid (in case of i = p_i the kid will give his book to himself). It is guaranteed that all values of p_i are distinct integers from 1 to n (i.e. p is a permutation). The sequence p doesn't change from day to day, it is fixed.
For example, if n=6 and p=[4, 6, 1, 3, 5, 2] then at the end of the first day the book of the 1-st kid will belong to the 4-th kid, the 2-nd kid will belong to the 6-th kid and so on. At the end of the second day the book of the 1-st kid will belong to the 3-th kid, the 2-nd kid will belong to the 2-th kid and so on.
Your task is to determine the number of the day the book of the i-th child is returned back to him for the first time for every i from 1 to n.
Consider the following example: p = [5, 1, 2, 4, 3]. The book of the 1-st kid will be passed to the following kids:
* after the 1-st day it will belong to the 5-th kid,
* after the 2-nd day it will belong to the 3-rd kid,
* after the 3-rd day it will belong to the 2-nd kid,
* after the 4-th day it will belong to the 1-st kid.
So after the fourth day, the book of the first kid will return to its owner. The book of the fourth kid will return to him for the first time after exactly one day.
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. Then q queries follow.
The first line of the query contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of kids in the query. The second line of the query contains n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i are distinct, i.e. p is a permutation), where p_i is the kid which will get the book of the i-th kid.
It is guaranteed that ∑ n ≤ 2 ⋅ 10^5 (sum of n over all queries does not exceed 2 ⋅ 10^5).
Output
For each query, print the answer on it: n integers a_1, a_2, ..., a_n, where a_i is the number of the day the book of the i-th child is returned back to him for the first time in this query.
Example
Input
6
5
1 2 3 4 5
3
2 3 1
6
4 6 2 1 5 3
1
1
4
3 4 1 2
5
5 1 2 4 3
Output
1 1 1 1 1
3 3 3
2 3 3 2 1 3
1
2 2 2 2
4 4 4 1 4
|
#include <bits/stdc++.h>
using namespace std;
long long int i, j, x, y, k;
const int MOD = 1e9 + 7;
long long int m1 = LLONG_MAX;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
long long int m2 = LLONG_MIN;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) {
long long int n, m, q;
cin >> n;
vector<long long int> a(n + 1, 1);
map<long long int, long long int> mp;
for (i = 1; i <= n; i++) {
long long int b;
cin >> b;
mp[i] = b;
}
for (i = 1; i <= n; i++) {
vector<long long int> b;
j = mp[i];
while (j != i) {
b.push_back(j);
j = mp[j];
a[i]++;
}
for (k = 0; k < b.size(); k++) {
mp[b[k]] = b[k];
a[b[k]] = a[i];
}
b.clear();
}
for (i = 1; i <= n; i++) cout << a[i] << " ";
cout << endl;
}
}
|
This is an interactive problem.
You are the head coach of a chess club. The club has 2n players, each player has some strength which can be represented by a number, and all those numbers are distinct. The strengths of the players are not known to you.
You need to select n players who would represent your club in the upcoming championship. Naturally, you want to select n players with the highest strengths.
You can organize matches between the players to do that. In every match, you pick two players, they play some games, and you learn which one of the two has higher strength. You can wait for the outcome of a match before deciding who will participate in the next one.
However, you do not want to know exactly how those n players compare between themselves, as that would make the championship itself less intriguing. More formally, you must reach a state where there is exactly one way to choose n players with the highest strengths that is consistent with the outcomes of the matches you organized, but there must be at least two possible orderings of those n players by strength that are consistent with the outcomes of the matches you organized.
Interaction
Your program has to process multiple test cases in one run. First, it should read the integer t (t ≥ 1) — the number of test cases. Then, it should process the test cases one by one.
In each test case, your program should start by reading the integer n (3 ≤ n ≤ 100) — the number of players to select out of 2n players. The sum of squares of the values of n over all test cases does not exceed 10 000.
Then your program can organize matches zero or more times. To organize a match, your program should print a match description formatted as ? i j — a question mark followed by two distinct numbers of players participating in the match. The players are numbered from 1 to 2n, inclusive. Remember to flush the output after printing the match description. Then your program should read the match outcome — it will be either the greater-than character (>), if the first player in the match description has higher strength, or the less-than character (<), if the second player in the match description has higher strength.
Your program can organize at most 4n^2 matches. After it is done organizing matches, it should print the exclamation mark (!) and continue to the next test case, or exit gracefully if this was the last test case. Remember to flush the output after printing the exclamation mark.
There must be exactly one way to choose n players with the highest strength that is consistent with the outcomes of the matches you organized, but there must be at least two possible orderings of those n players by their strength that are consistent with the outcomes of the matches you organized.
The judging program picks some distinct numbers as the strengths of all players before your program starts organizing matches and uses them to answer the requests.
Example
Input
2
3
>
<
>
<
>
>
3
<
<
<
>
>
Output
? 1 3
? 4 2
? 4 5
? 6 5
? 3 4
? 5 6
!
? 3 4
? 4 2
? 5 3
? 6 4
? 3 1
!
Note
In the example, the players in the first test case are sorted by strength in decreasing order. From the matches in the example output, we can deduce that players 1, 2, and 3 have the highest strength, but we do not know how the player 1 compares to the player 2.
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 5;
int T, N, M, K;
int p1[MAXN], p2[MAXN];
void insert(int *p, int n, int key);
int main() {
scanf("%d", &T);
while (T--) {
fflush(stdout);
scanf("%d", &N);
fill(p1, p1 + 2 * N + 2, 0);
fill(p2, p2 + 2 * N + 2, 0);
M = (N + 1) / 2;
p1[1] = 1;
for (int i = 2; i <= M; i++) {
int key = i;
int j = i - 1;
while (j) {
printf("? %d %d\n", p1[j], key);
fflush(stdout);
char op;
scanf(" %c", &op);
if (op == '>') break;
p1[j + 1] = p1[j];
j--;
}
p1[j + 1] = key;
}
p2[1] = M + 1;
for (int i = 2; i + M <= N + 1; i++) {
int key = i + M;
int j = i - 1;
while (j) {
printf("? %d %d\n", p2[j], key);
fflush(stdout);
char op;
scanf(" %c", &op);
if (op == '>') break;
p2[j + 1] = p2[j];
j--;
}
p2[j + 1] = key;
}
for (int i = N + 2; i <= 2 * N; i++) {
printf("? %d %d\n", p1[M], p2[N + 1 - M]);
fflush(stdout);
char op;
scanf(" %c", &op);
if (op == '>')
insert(p2, N + 1 - M, i);
else
insert(p1, M, i);
}
printf("? %d %d\n", p1[M], p2[N + 1 - M]);
fflush(stdout);
char op;
scanf(" %c", &op);
printf("!\n");
}
return 0;
}
void insert(int *p, int n, int key) {
int j = n;
while (j) {
printf("? %d %d\n", p[j], key);
fflush(stdout);
char op;
scanf(" %c", &op);
if (op == '>') break;
p[j + 1] = p[j];
j--;
}
p[j + 1] = key;
}
|
In this task Anna and Maria play the following game. Initially they have a checkered piece of paper with a painted n × m rectangle (only the border, no filling). Anna and Maria move in turns and Anna starts. During each move one should paint inside the last-painted rectangle a new lesser rectangle (along the grid lines). The new rectangle should have no common points with the previous one. Note that when we paint a rectangle, we always paint only the border, the rectangles aren't filled.
Nobody wins the game — Anna and Maria simply play until they have done k moves in total. Count the number of different ways to play this game.
Input
The first and only line contains three integers: n, m, k (1 ≤ n, m, k ≤ 1000).
Output
Print the single number — the number of the ways to play the game. As this number can be very big, print the value modulo 1000000007 (109 + 7).
Examples
Input
3 3 1
Output
1
Input
4 4 1
Output
9
Input
6 7 2
Output
75
Note
Two ways to play the game are considered different if the final pictures are different. In other words, if one way contains a rectangle that is not contained in the other way.
In the first sample Anna, who performs her first and only move, has only one possible action plan — insert a 1 × 1 square inside the given 3 × 3 square.
In the second sample Anna has as much as 9 variants: 4 ways to paint a 1 × 1 square, 2 ways to insert a 1 × 2 rectangle vertically, 2 more ways to insert it horizontally and one more way is to insert a 2 × 2 square.
|
#include <bits/stdc++.h>
using namespace std;
long long int C[1001][1001];
long long int nCr(int n, int r) {
if (n < r) {
return 0;
}
if (r > n - r) r = n - r;
if (r == 0) return 1;
if (C[n][r] != -1) return C[n][r];
C[n][r] = (nCr(n - 1, r - 1) + nCr(n - 1, r)) % 1000000007;
return C[n][r];
}
int main() {
memset(C, -1, sizeof C);
int n = ({
int _x;
scanf("%d", &_x);
_x;
}),
m = ({
int _x;
scanf("%d", &_x);
_x;
}),
k = ({
int _x;
scanf("%d", &_x);
_x;
});
long long ans;
if (2 * k > n - 1 || 2 * k > m - 1)
ans = 0;
else
ans = (nCr(n - 1, 2 * k) * nCr(m - 1, 2 * k)) % 1000000007;
cout << ans << endl;
return 0;
}
|
Bob is playing a game named "Walk on Matrix".
In this game, player is given an n × m matrix A=(a_{i,j}), i.e. the element in the i-th row in the j-th column is a_{i,j}. Initially, player is located at position (1,1) with score a_{1,1}.
To reach the goal, position (n,m), player can move right or down, i.e. move from (x,y) to (x,y+1) or (x+1,y), as long as player is still on the matrix.
However, each move changes player's score to the [bitwise AND](https://en.wikipedia.org/wiki/Bitwise_operation#AND) of the current score and the value at the position he moves to.
Bob can't wait to find out the maximum score he can get using the tool he recently learnt — dynamic programming. Here is his algorithm for this problem.
<image>
However, he suddenly realize that the algorithm above fails to output the maximum score for some matrix A. Thus, for any given non-negative integer k, he wants to find out an n × m matrix A=(a_{i,j}) such that
* 1 ≤ n,m ≤ 500 (as Bob hates large matrix);
* 0 ≤ a_{i,j} ≤ 3 ⋅ 10^5 for all 1 ≤ i≤ n,1 ≤ j≤ m (as Bob hates large numbers);
* the difference between the maximum score he can get and the output of his algorithm is exactly k.
It can be shown that for any given integer k such that 0 ≤ k ≤ 10^5, there exists a matrix satisfying the above constraints.
Please help him with it!
Input
The only line of the input contains one single integer k (0 ≤ k ≤ 10^5).
Output
Output two integers n, m (1 ≤ n,m ≤ 500) in the first line, representing the size of the matrix.
Then output n lines with m integers in each line, a_{i,j} in the (i+1)-th row, j-th column.
Examples
Input
0
Output
1 1
300000
Input
1
Output
3 4
7 3 3 1
4 8 3 6
7 7 7 3
Note
In the first example, the maximum score Bob can achieve is 300000, while the output of his algorithm is 300000.
In the second example, the maximum score Bob can achieve is 7\&3\&3\&3\&7\&3=3, while the output of his algorithm is 2.
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int maxn = 1e6 + 5;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-8;
const double PI = acos(-1.0);
void header() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void solve() {
long long k;
cin >> k;
cout << "3 3\n";
cout << (1ll << 17) + k << " " << k << " " << k << '\n';
cout << (1ll << 17) << " " << (1ll << 17) << " " << (1ll << 17) + k << '\n';
cout << (1ll << 17) << " " << (1ll << 17) << " " << k << '\n';
}
int main() {
header();
solve();
return 0;
}
|
A permutation of length n is an array p=[p_1,p_2,...,p_n], which contains every integer from 1 to n (inclusive) and, moreover, each number appears exactly once. For example, p=[3,1,4,2,5] is a permutation of length 5.
For a given number n (n ≥ 2), find a permutation p in which absolute difference (that is, the absolute value of difference) of any two neighboring (adjacent) elements is between 2 and 4, inclusive. Formally, find such permutation p that 2 ≤ |p_i - p_{i+1}| ≤ 4 for each i (1 ≤ i < n).
Print any such permutation for the given integer n or determine that it does not exist.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then t test cases follow.
Each test case is described by a single line containing an integer n (2 ≤ n ≤ 1000).
Output
Print t lines. Print a permutation that meets the given requirements. If there are several such permutations, then print any of them. If no such permutation exists, print -1.
Example
Input
6
10
2
4
6
7
13
Output
9 6 10 8 4 7 3 1 5 2
-1
3 1 4 2
5 3 6 2 4 1
5 1 3 6 2 4 7
13 9 7 11 8 4 1 3 5 2 6 10 12
|
"""
Author: guiferviz
Time: 2020-05-09 16:35:02
"""
def solve():
n = int(input())
if n < 4:
print(-1)
elif n == 4:
print("3 1 4 2")
else:
sol = []
i = 1
while i <= n:
sol.append(i)
i += 2
i = sol[-1]
val = i - 3
i += -1 if i == n else 1
sol.append(val)
while i > 0:
if i != val: sol.append(i)
i -= 2
# Print solution.
print(" ".join(map(str, sol)))
# Check solution.
for i in range(n-1):
if sol[i] > n:
raise ValueError("Value out of range")
diff = abs(sol[i] - sol[i+1])
if diff > 4 or diff < 2:
raise ValueError(f"diff={diff}, sol[{i}]={sol[i]} + sol[{i+1}]={sol[i+1]}")
def main():
t = int(input())
for _ in range(t):
solve()
if __name__ == "__main__":
main()
|
Omkar is building a house. He wants to decide how to make the floor plan for the last floor.
Omkar's floor starts out as n rows of m zeros (1 ≤ n,m ≤ 100). Every row is divided into intervals such that every 0 in the row is in exactly 1 interval. For every interval for every row, Omkar can change exactly one of the 0s contained in that interval to a 1. Omkar defines the quality of a floor as the sum of the squares of the sums of the values in each column, i. e. if the sum of the values in the i-th column is q_i, then the quality of the floor is ∑_{i = 1}^m q_i^2.
Help Omkar find the maximum quality that the floor can have.
Input
The first line contains two integers, n and m (1 ≤ n,m ≤ 100), which are the number of rows and number of columns, respectively.
You will then receive a description of the intervals in each row. For every row i from 1 to n: The first row contains a single integer k_i (1 ≤ k_i ≤ m), which is the number of intervals on row i. The j-th of the next k_i lines contains two integers l_{i,j} and r_{i,j}, which are the left and right bound (both inclusive), respectively, of the j-th interval of the i-th row. It is guaranteed that all intervals other than the first interval will be directly after the interval before it. Formally, l_{i,1} = 1, l_{i,j} ≤ r_{i,j} for all 1 ≤ j ≤ k_i, r_{i,j-1} + 1 = l_{i,j} for all 2 ≤ j ≤ k_i, and r_{i,k_i} = m.
Output
Output one integer, which is the maximum possible quality of an eligible floor plan.
Example
Input
4 5
2
1 2
3 5
2
1 3
4 5
3
1 1
2 4
5 5
3
1 1
2 2
3 5
Output
36
Note
The given test case corresponds to the following diagram. Cells in the same row and have the same number are a part of the same interval.
<image>
The most optimal assignment is:
<image>
The sum of the 1st column is 4, the sum of the 2nd column is 2, the sum of the 3rd and 4th columns are 0, and the sum of the 5th column is 4.
The quality of this floor plan is 4^2 + 2^2 + 0^2 + 0^2 + 4^2 = 36. You can show that there is no floor plan with a higher quality.
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
void ckmin(T &a, U b) {
if (a > b) a = b;
}
template <class T, class U>
void ckmax(T &a, U b) {
if (a < b) a = b;
}
const int MAXN = 113;
int N, M;
vector<int> pts[MAXN];
int id[MAXN][MAXN];
int dp[MAXN][MAXN];
int32_t main() {
cout << fixed << setprecision(12);
cerr << fixed << setprecision(4);
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M;
for (auto i = (0); i < (N); i++) {
int k;
cin >> k;
for (auto j = (1); j < (k + 1); j++) {
int l, r;
cin >> l >> r;
for (auto k = (l); k < (r + 1); k++) {
id[i][k] = j;
}
}
id[i][0] = 0;
id[i][M + 1] = k + 1;
}
for (auto i = (0); i < (M); i++) {
for (auto l = (1); l < (M - i + 1); l++) {
int r = l + i;
for (auto j = (l); j < (r + 1); j++) {
int cur = 0;
int c = 0;
for (auto k = (0); k < (N); k++) {
cur = dp[l][j - 1] + dp[j + 1][r];
if (id[k][j] != id[k][l - 1] && id[k][j] != id[k][r + 1]) c++;
}
ckmax(dp[l][r], cur + c * c);
}
}
}
cout << dp[1][M] << '\n';
return 0;
}
|
Have you ever used the chat application QQ? Well, in a chat group of QQ, administrators can muzzle a user for days.
In Boboniu's chat group, there's a person called Du Yi who likes to make fun of Boboniu every day.
Du will chat in the group for n days. On the i-th day:
* If Du can speak, he'll make fun of Boboniu with fun factor a_i. But after that, he may be muzzled depending on Boboniu's mood.
* Otherwise, Du won't do anything.
Boboniu's mood is a constant m. On the i-th day:
* If Du can speak and a_i>m, then Boboniu will be angry and muzzle him for d days, which means that Du won't be able to speak on the i+1, i+2, ⋅⋅⋅, min(i+d,n)-th days.
* Otherwise, Boboniu won't do anything.
The total fun factor is the sum of the fun factors on the days when Du can speak.
Du asked you to find the maximum total fun factor among all possible permutations of a.
Input
The first line contains three integers n, d and m (1≤ d≤ n≤ 10^5,0≤ m≤ 10^9).
The next line contains n integers a_1, a_2, …,a_n (0≤ a_i≤ 10^9).
Output
Print one integer: the maximum total fun factor among all permutations of a.
Examples
Input
5 2 11
8 10 15 23 5
Output
48
Input
20 2 16
20 5 8 2 18 16 2 16 16 1 5 16 2 13 6 16 4 17 21 7
Output
195
Note
In the first example, you can set a'=[15, 5, 8, 10, 23]. Then Du's chatting record will be:
1. Make fun of Boboniu with fun factor 15.
2. Be muzzled.
3. Be muzzled.
4. Make fun of Boboniu with fun factor 10.
5. Make fun of Boboniu with fun factor 23.
Thus the total fun factor is 48.
|
#include <bits/stdc++.h>
using namespace std;
using Int = long long;
constexpr static int mod = 1e9 + 7;
constexpr static int inf = (1 << 30) - 1;
constexpr static Int infll = (1LL << 61) - 1;
int Competitive_Programming =
(ios_base::sync_with_stdio(false), cin.tie(nullptr),
cout << fixed << setprecision(15), 0);
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
int main() {
Int N, D, M;
cin >> N >> D >> M;
vector<Int> a(N);
vector<Int> low, high;
for (int i = 0; i < N; i++) {
cin >> a[i];
if (a[i] > M)
high.push_back(a[i]);
else
low.push_back(a[i]);
}
sort(low.rbegin(), low.rend());
sort(high.rbegin(), high.rend());
vector<Int> lowsum(low.size() + 1), highsum(high.size() + 1);
for (int i = 0; i < low.size(); i++) lowsum[i + 1] = lowsum[i] + low[i];
for (int i = 0; i < high.size(); i++) highsum[i + 1] = highsum[i] + high[i];
Int ans = 0, hsz = highsum.size(), lsz = lowsum.size();
for (int i = 0; i < lsz; i++)
ans = max(ans, highsum[min(hsz - 1, (N - i + D) / (D + 1))] + lowsum[i]);
cout << ans << "\n";
}
|
There are n detachments on the surface, numbered from 1 to n, the i-th detachment is placed in a point with coordinates (x_i, y_i). All detachments are placed in different points.
Brimstone should visit each detachment at least once. You can choose the detachment where Brimstone starts.
To move from one detachment to another he should first choose one of four directions of movement (up, right, left or down) and then start moving with the constant speed of one unit interval in a second until he comes to a detachment. After he reaches an arbitrary detachment, he can repeat the same process.
Each t seconds an orbital strike covers the whole surface, so at that moment Brimstone should be in a point where some detachment is located. He can stay with any detachment as long as needed.
Brimstone is a good commander, that's why he can create at most one detachment and place it in any empty point with integer coordinates he wants before his trip. Keep in mind that Brimstone will need to visit this detachment, too.
Help Brimstone and find such minimal t that it is possible to check each detachment. If there is no such t report about it.
Input
The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of detachments.
In each of the next n lines there is a pair of integers x_i, y_i (|x_i|, |y_i| ≤ 10^9) — the coordinates of i-th detachment.
It is guaranteed that all points are different.
Output
Output such minimal integer t that it is possible to check all the detachments adding at most one new detachment.
If there is no such t, print -1.
Examples
Input
4
100 0
0 100
-100 0
0 -100
Output
100
Input
7
0 2
1 0
-3 0
0 -2
-1 -1
-1 -3
-2 -3
Output
-1
Input
5
0 0
0 -1
3 0
-2 0
-2 1
Output
2
Input
5
0 0
2 0
0 -1
-2 0
-2 1
Output
2
Note
In the first test it is possible to place a detachment in (0, 0), so that it is possible to check all the detachments for t = 100. It can be proven that it is impossible to check all detachments for t < 100; thus the answer is 100.
In the second test, there is no such t that it is possible to check all detachments, even with adding at most one new detachment, so the answer is -1.
In the third test, it is possible to place a detachment in (1, 0), so that Brimstone can check all the detachments for t = 2. It can be proven that it is the minimal such t.
In the fourth test, there is no need to add any detachments, because the answer will not get better (t = 2). It can be proven that it is the minimal such t.
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize(2)
#pragma GCC optimize("Ofast")
using namespace std;
map<int, vector<pair<int, int>>> X, Y;
struct Vertex {
int x, y, id;
};
struct Edge {
Vertex u, v;
bool ishorizontal() { return u.y == v.y; }
bool isvertical() { return u.x == v.x; }
int length() {
if (ishorizontal()) return abs(u.x - v.x);
return abs(u.y - v.y);
}
};
Vertex vc[1011];
vector<Edge> edg;
int N, f[1011];
void init() {
int i;
for (i = 1; i <= N; ++i) f[i] = i;
}
int find(int v) {
if (f[v] == v) return v;
return f[v] = find(f[v]);
}
void unionset(int v1, int v2) {
int a = find(v1), b = find(v2);
f[a] = b;
}
void preprocess() {
int i;
auto iter = X.begin();
while (iter != X.end()) {
sort(iter->second.begin(), iter->second.end());
int sz = iter->second.size();
for (i = 0; i < sz - 1; ++i) {
Vertex v1 =
Vertex{iter->first, iter->second[i].first, iter->second[i].second};
Vertex v2 = Vertex{iter->first, iter->second[i + 1].first,
iter->second[i + 1].second};
Edge e = Edge{v1, v2};
edg.push_back(e);
}
++iter;
}
iter = Y.begin();
while (iter != Y.end()) {
sort(iter->second.begin(), iter->second.end());
int sz = iter->second.size();
for (i = 0; i < sz - 1; ++i) {
Vertex v1 =
Vertex{iter->second[i].first, iter->first, iter->second[i].second};
Vertex v2 = Vertex{iter->second[i + 1].first, iter->first,
iter->second[i + 1].second};
Edge e = Edge{v1, v2};
edg.push_back(e);
}
++iter;
}
}
bool valid(int T) {
init();
int tol = N, i, j;
for (auto e : edg) {
if (e.length() <= T) {
if (find(e.u.id) != find(e.v.id)) {
unionset(e.u.id, e.v.id);
tol--;
}
}
}
if (tol == 1) return true;
if (tol > 4) return false;
if (tol == 2) {
for (auto e : edg) {
if (find(e.u.id) != find(e.v.id) && 1ll * e.length() <= 1ll * 2 * T)
return true;
}
for (i = 1; i <= N; ++i) {
for (j = i + 1; j <= N; ++j) {
if (find(i) != find(j)) {
if (max(abs(vc[i].x - vc[j].x), abs(vc[i].y - vc[j].y)) <= T)
return true;
}
}
}
return false;
} else if (tol == 3) {
int sz = edg.size();
for (i = 0; i < sz; ++i) {
for (j = 1; j <= N; ++j) {
if (find(j) != find(edg[i].u.id) && find(j) != find(edg[i].v.id) &&
find(edg[i].v.id) != find(edg[i].u.id)) {
if (edg[i].ishorizontal()) {
int x1 = edg[i].u.x, x2 = edg[i].v.x;
if (x1 > x2) swap(x1, x2);
if (x1 <= vc[j].x && vc[j].x <= x2) {
int dist = max(abs(vc[j].y - edg[i].u.y),
max(x2 - vc[j].x, vc[j].x - x1));
if (dist <= T) return true;
}
} else {
int y1 = edg[i].u.y, y2 = edg[i].v.y;
if (y1 > y2) swap(y1, y2);
if (y1 <= vc[j].y && vc[j].y <= y2) {
int dist = max(abs(vc[j].x - edg[i].u.x),
max(y2 - vc[j].y, vc[j].y - y1));
if (dist <= T) return true;
}
}
}
}
}
return false;
}
int sz = edg.size();
for (i = 0; i < sz; ++i) {
if (edg[i].ishorizontal() || find(edg[i].u.id) == find(edg[i].v.id))
continue;
int y1 = min(edg[i].u.y, edg[i].v.y), y2 = max(edg[i].u.y, edg[i].v.y);
for (j = i + 1; j < sz; ++j) {
if (edg[j].isvertical() || find(edg[j].u.id) == find(edg[j].v.id))
continue;
if (find(edg[i].u.id) == find(edg[j].u.id)) continue;
if (find(edg[i].u.id) == find(edg[j].v.id)) continue;
if (find(edg[i].v.id) == find(edg[j].u.id)) continue;
if (find(edg[i].v.id) == find(edg[j].v.id)) continue;
int x1 = min(edg[j].u.x, edg[j].v.x), x2 = max(edg[j].u.x, edg[j].v.x);
int x = edg[i].v.x, y = edg[j].v.y;
if (x1 <= x && x <= x2 && y1 <= y && y <= y2) {
if (max(max(x - x1, x2 - x), max(y - y1, y2 - y)) <= T) return true;
}
}
}
return false;
}
int main() {
int i;
scanf("%d", &N);
for (i = 1; i <= N; ++i) {
int x, y;
scanf("%d%d", &x, &y);
X[x].emplace_back(y, i);
Y[y].emplace_back(x, i);
vc[i].x = x, vc[i].id = i, vc[i].y = y;
}
preprocess();
int low = 0, high = 2e9, ans = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (valid(mid)) {
high = mid - 1;
ans = mid;
} else {
low = mid + 1;
}
}
printf("%d\n", ans);
return 0;
}
|
For the simplicity, let's say that the "Death Note" is a notebook that kills a person when their name is written in it.
It's easy to kill with it, but it's pretty hard to keep track of people you haven't killed and still plan to. You decided to make a "Death Database Management System" — a computer program that provides the easy access to the database of possible victims. Let me describe its specifications to you.
Let's define a victim entity: a victim has a name (not necessarily unique) that consists only of lowercase Latin letters and an integer suspicion value.
At the start of the program the user enters a list of n victim names into a database, each suspicion value is set to 0.
Then the user makes queries of two types:
* 1~i~x — set the suspicion value of the i-th victim to x;
* 2~q — given a string q find the maximum suspicion value of a victim whose name is a contiguous substring of q.
Just to remind you, this program doesn't kill people, it only helps to search for the names to write down in an actual notebook. Thus, the list of the victims in the database doesn't change throughout the queries.
What are you waiting for? Write that program now!
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of victims and the number of queries, respectively.
Each of the next n lines contains a single string s_i — the name of the i-th victim. Each name consists only of lowercase Latin letters.
Each of the next m lines contains a query of one of two types:
* 1~i~x (1 ≤ i ≤ n, 0 ≤ x ≤ 10^9) — change the suspicion value of the i-th victim to x;
* 2~q — given a string q consisting only of lowercase Latin letters find the maximum suspicion value of a victim whose name is a contiguous substring of q.
There is at least one query of the second type. The total length of the strings s_i doesn't exceed 3 ⋅ 10^5. The total length of the strings q doesn't exceed 3 ⋅ 10^5.
Output
For each query of the second type print an integer value. If there is no victim name that is a contiguous substring of q, then print -1. Otherwise, print the maximum suspicion value of a victim whose name is a contiguous substring of q.
Examples
Input
5 8
kurou
takuo
takeshi
naomi
shingo
2 nakiraomi
2 abanaomicaba
1 3 943
2 takuotakeshishingo
1 5 135832
2 shingotakeshi
1 5 0
2 shingotakeshi
Output
-1
0
943
135832
943
Input
6 15
a
ab
ba
b
a
ba
2 aa
1 4 4
2 bbb
1 2 1
1 2 18
2 b
2 c
1 6 10
2 aba
2 abbbba
1 2 12
2 bbaaab
1 1 11
1 5 5
2 baa
Output
0
4
4
-1
18
18
12
11
|
#include <bits/stdc++.h>
using namespace std;
struct ACM {
int T[300010][26], ed[300010], fail[300010], last[300010], cnt, val[300010];
multiset<int> S[300010];
void insert(char *s, int idx) {
int o = 0;
for (int i = 0; s[i]; ++i) {
int v = s[i] - 97;
if (!T[o][v]) T[o][v] = ++cnt;
o = T[o][v];
}
ed[idx] = o, val[idx] = 0, S[o].insert(0);
}
void build() {
for (int i = 0; i <= cnt; ++i) S[i].insert(-1);
queue<int> q;
for (int i = 0; i < 26; ++i)
if (T[0][i]) fail[T[0][i]] = 0, q.push(T[0][i]);
while (!q.empty()) {
int x = q.front();
q.pop();
last[x] = S[fail[x]].size() > 1 ? fail[x] : last[fail[x]];
for (int i = 0; i < 26; ++i)
if (T[x][i]) {
fail[T[x][i]] = T[fail[x]][i];
q.push(T[x][i]);
} else
T[x][i] = T[fail[x]][i];
}
}
void change(int x, int idx) {
int pos = ed[idx];
S[pos].erase(S[pos].find(val[idx]));
val[idx] = x, S[pos].insert(x);
}
int ask(char *s) {
int ans = -1, o = 0;
for (int i = 0; s[i]; ++i) {
int v = s[i] - 97, t;
for (t = o = T[o][v]; t; t = last[t]) ans = max(ans, *S[t].rbegin());
}
return ans;
}
} ac;
char s[300010];
inline void solve() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s), ac.insert(s, i);
ac.build();
while (m--) {
int op, i, x;
scanf("%d", &op);
if (op == 1)
scanf("%d%d", &i, &x), ac.change(x, i);
else
scanf("%s", s), printf("%d\n", ac.ask(s));
}
}
int main() {
int T = 1;
while (T--) {
solve();
}
}
|
This is the easy version of this problem. The only difference between easy and hard versions is the constraints on k and m (in this version k=2 and m=3). Also, in this version of the problem, you DON'T NEED to output the answer by modulo.
You are given a sequence a of length n consisting of integers from 1 to n. The sequence may contain duplicates (i.e. some elements can be equal).
Find the number of tuples of m = 3 elements such that the maximum number in the tuple differs from the minimum by no more than k = 2. Formally, you need to find the number of triples of indices i < j < z such that
$$$max(a_i, a_j, a_z) - min(a_i, a_j, a_z) ≤ 2.$$$
For example, if n=4 and a=[1,2,4,3], then there are two such triples (i=1, j=2, z=4 and i=2, j=3, z=4). If n=4 and a=[1,1,1,1], then all four possible triples are suitable.
Input
The first line contains a single integer t (1 ≤ t ≤ 2 ⋅ 10^5) — the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the sequence a.
The next line contains n integers a_1, a_2,…, a_n (1 ≤ a_i ≤ n) — the sequence a.
It is guaranteed that the sum of n for all test cases does not exceed 2 ⋅ 10^5.
Output
Output t answers to the given test cases. Each answer is the required number of triples of elements, such that the maximum value in the triple differs from the minimum by no more than 2. Note that in difference to the hard version of the problem, you don't need to output the answer by modulo. You must output the exact value of the answer.
Example
Input
4
4
1 2 4 3
4
1 1 1 1
1
1
10
5 6 1 3 2 9 8 1 2 4
Output
2
4
0
15
|
#input = sys.stdin.readline
import os
import sys
from io import BytesIO, IOBase
import heapq as h
import bisect
from types import GeneratorType
BUFSIZE = 8192
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index+1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
import sys
from math import ceil,log2
INT_MAX = sys.maxsize
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
import collections as col
import math, string
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
def minVal(x, y) :
return x if (x < y) else y;
# A utility function to get the
# middle index from corner indexes.
def getMid(s, e) :
return s + (e - s) // 2;
""" A recursive function to get the
minimum value in a given range
of array indexes. The following
are parameters for this function.
st --> Pointer to segment tree
index --> Index of current node in the
segment tree. Initially 0 is
passed as root is always at index 0
ss & se --> Starting and ending indexes
of the segment represented
by current node, i.e., st[index]
qs & qe --> Starting and ending indexes of query range """
def RMQUtil( st, ss, se, qs, qe, index) :
# If segment of this node is a part
# of given range, then return
# the min of the segment
if (qs <= ss and qe >= se) :
return st[index];
# If segment of this node
# is outside the given range
if (se < qs or ss > qe) :
return INT_MAX;
# If a part of this segment
# overlaps with the given range
mid = getMid(ss, se);
return minVal(RMQUtil(st, ss, mid, qs,
qe, 2 * index + 1),
RMQUtil(st, mid + 1, se,
qs, qe, 2 * index + 2));
# Return minimum of elements in range
# from index qs (query start) to
# qe (query end). It mainly uses RMQUtil()
def RMQ( st, n, qs, qe) :
# Check for erroneous input values
if (qs < 0 or qe > n - 1 or qs > qe) :
print("Invalid Input");
return -1;
return RMQUtil(st, 0, n - 1, qs, qe, 0);
# A recursive function that constructs
# Segment Tree for array[ss..se].
# si is index of current node in segment tree st
def constructSTUtil(arr, ss, se, st, si) :
# If there is one element in array,
# store it in current node of
# segment tree and return
if (ss == se) :
st[si] = arr[ss];
return arr[ss];
# If there are more than one elements,
# then recur for left and right subtrees
# and store the minimum of two values in this node
mid = getMid(ss, se);
st[si] = minVal(constructSTUtil(arr, ss, mid,
st, si * 2 + 1),
constructSTUtil(arr, mid + 1, se,
st, si * 2 + 2));
return st[si];
"""Function to construct segment tree
from given array. This function allocates
memory for segment tree and calls constructSTUtil()
to fill the allocated memory """
def constructST( arr, n) :
# Allocate memory for segment tree
# Height of segment tree
x = (int)(ceil(log2(n)));
# Maximum size of segment tree
max_size = 2 * (int)(2**x) - 1;
st = [0] * (max_size);
# Fill the allocated memory st
constructSTUtil(arr, 0, n - 1, st, 0);
# Return the constructed segment tree
return st;
MOD = 10**9+7
mod=10**9+7
t=int(input())
#t=1
p=10**9+7
def ncr_util():
inv[0]=inv[1]=1
fact[0]=fact[1]=1
for i in range(2,300001):
inv[i]=(inv[i%p]*(p-p//i))%p
for i in range(1,300001):
inv[i]=(inv[i-1]*inv[i])%p
fact[i]=(fact[i-1]*i)%p
def z_array(s1):
n = len(s1)
z=[0]*(n)
l, r, k = 0, 0, 0
for i in range(1,n):
# if i>R nothing matches so we will calculate.
# Z[i] using naive way.
if i > r:
l, r = i, i
# R-L = 0 in starting, so it will start
# checking from 0'th index. For example,
# for "ababab" and i = 1, the value of R
# remains 0 and Z[i] becomes 0. For string
# "aaaaaa" and i = 1, Z[i] and R become 5
while r < n and s1[r - l] == s1[r]:
r += 1
z[i] = r - l
r -= 1
else:
# k = i-L so k corresponds to number which
# matches in [L,R] interval.
k = i - l
# if Z[k] is less than remaining interval
# then Z[i] will be equal to Z[k].
# For example, str = "ababab", i = 3, R = 5
# and L = 2
if z[k] < r - i + 1:
z[i] = z[k]
# For example str = "aaaaaa" and i = 2,
# R is 5, L is 0
else:
# else start from R and check manually
l = i
while r < n and s1[r - l] == s1[r]:
r += 1
z[i] = r - l
r -= 1
return z
'''
MAXN1=100001
spf=[0]*MAXN1
def sieve():
spf[1]=1
for i in range(2,MAXN1):
spf[i]=i
for i in range(4,MAXN1,2):
spf[i]=2
for i in range(3,math.ceil(math.sqrt(MAXN1))):
if spf[i]==i:
for j in range(i*i,MAXN1,i):
if spf[j]==j:
spf[j]=i
def factor(x):
d1={}
x1=x
while x!=1:
d1[spf[x]]=d1.get(spf[x],0)+1
x//=spf[x]
return d1
'''
def primeFactors(n):
d1={}
while n % 2 == 0:
d1[2]=d1.get(2,0)+1
n = n / 2
for i in range(3,int(math.sqrt(n))+1,2):
# while i divides n , print i ad divide n
while n % i== 0:
d1[i]=d1.get(i,0)+1
n = n // i
if n > 2:
d1[n]=d1.get(n,0)+1
return d1
def fs(x):
if x<2:
return 0
return (x*(x-1))//2
def solve():
i=0
j=0
#print(123,l)
cnt,ans=0,0
while i<n-2:
pos=bisect.bisect_left(l,l[i]+3)
pos-=1
#print(l,pos,pos-i,fs(pos-i))
ans+=fs(pos-i)
i+=1
return ans
for _ in range(t):
n=int(input())
#d={}
#n,m=map(int,input().split())
#n=int(input())
#s=input()
#s2=input()
l=list(map(int,input().split()))
l.sort()
#l2=list(map(int,input().split()))
#l.sort()
#l.sort(revrese=True)
#x,y=(map(int,input().split()))
#l=str(n)
#l.sort(reverse=True)
#l2.sort(reverse=True)
#l1.sort(reverse=True)
#(solve())
print(solve())
|
You are given a positive (greater than zero) integer n.
You have to represent n as the sum of integers (possibly negative) consisting only of ones (digits '1'). For example, 24 = 11 + 11 + 1 + 1 and 102 = 111 - 11 + 1 + 1.
Among all possible representations, you have to find the one that uses the minimum number of ones in total.
Input
The single line contains one integer n (1 ≤ n < 10^{50}).
Output
Print one integer x — the minimum number of ones, such that there exist a representation of n as the sum of integers (possibly negative) that uses x ones in total.
Examples
Input
24
Output
6
Input
102
Output
7
|
#include <bits/stdc++.h>
using namespace std;
#define sz(a) int((a).size())
#define forn(i, n) for (int i = 0; i < int(n); ++i)
const int N = 250;
const int M = 28;
const int INF = 1e9;
int dp[2][M * 2 + 1][N][N];
int main() {
string s;
cin >> s;
reverse(s.begin(), s.end());
s += "0";
forn(carry, M * 2 + 1) forn(cp, N) forn(cn, N) dp[0][carry][cp][cn] = INF;
dp[0][M][N - 1][N - 1] = 0;
forn(i, sz(s)) {
forn(carry, M * 2 + 1) forn(cp, N) forn(cn, N) dp[1][carry][cp][cn] = INF;
forn(carry, M * 2 + 1) for (int cp = N - 1; cp >= 0; --cp) for (int cn = N - 1; cn >= 0; --cn) if (dp[0][carry][cp][cn] != INF) {
if (cp > 0) dp[0][carry][cp - 1][cn] = min(dp[0][carry][cp - 1][cn], dp[0][carry][cp][cn]);
if (cn > 0) dp[0][carry][cp][cn - 1] = min(dp[0][carry][cp][cn - 1], dp[0][carry][cp][cn]);
int rcarry = carry - M;
int val = rcarry + cp - cn;
int digit = val % 10;
if (digit < 0) digit += 10;
int ncarry = val / 10;
if (val < 0 && digit != 0) --ncarry;
if (digit == s[i] - '0') dp[1][ncarry + M][cp][cn] = min(dp[1][ncarry + M][cp][cn], dp[0][carry][cp][cn] + cp + cn);
}
swap(dp[0], dp[1]);
}
int ans = INF;
forn(i, N) forn(j, N) ans = min(ans, dp[0][M][i][j]);
cout << ans << endl;
}
|
You have a card deck of n cards, numbered from top to bottom, i. e. the top card has index 1 and bottom card — index n. Each card has its color: the i-th card has color a_i.
You should process q queries. The j-th query is described by integer t_j. For each query you should:
* find the highest card in the deck with color t_j, i. e. the card with minimum index;
* print the position of the card you found;
* take the card and place it on top of the deck.
Input
The first line contains two integers n and q (2 ≤ n ≤ 3 ⋅ 10^5; 1 ≤ q ≤ 3 ⋅ 10^5) — the number of cards in the deck and the number of queries.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 50) — the colors of cards.
The third line contains q integers t_1, t_2, ..., t_q (1 ≤ t_j ≤ 50) — the query colors. It's guaranteed that queries ask only colors that are present in the deck.
Output
Print q integers — the answers for each query.
Example
Input
7 5
2 1 1 4 3 3 1
3 2 1 1 4
Output
5 2 3 1 5
Note
Description of the sample:
1. the deck is [2, 1, 1, 4, \underline{3}, 3, 1] and the first card with color t_1 = 3 has position 5;
2. the deck is [3, \underline{2}, 1, 1, 4, 3, 1] and the first card with color t_2 = 2 has position 2;
3. the deck is [2, 3, \underline{1}, 1, 4, 3, 1] and the first card with color t_3 = 1 has position 3;
4. the deck is [\underline{1}, 2, 3, 1, 4, 3, 1] and the first card with color t_4 = 1 has position 1;
5. the deck is [1, 2, 3, 1, \underline{4}, 3, 1] and the first card with color t_5 = 4 has position 5.
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll a[300005] , spare = 0;
int main(){
ll n , q , i , j;
cin >> n >> q;
set < pair < ll , ll > > cur;
for(i = 1;i<=n;i++){
cin >> a[i];
cur.insert( { i , a[i] } );
}
while(q--){
ll x , gone = 0;
cin >> x;
pair < ll , ll > ind;
for(auto i : cur){
gone++;
if (i.second == x){
ind = i;
break;
}
}
cout << gone << "\n";
cur.erase(ind);
cur.insert({ spare , ind.second }) ;
spare--;
}
return 0;
}
|
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third — at time 2 ⋅ x, and so on.
Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second — at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.
Determine the sum of dissatisfaction of all participants.
Input
The first line contains a single integer k (1 ≤ k ≤ 1000) — the number of test cases.
Each of the next k lines contains three integers n, x, t (1 ≤ n, x, t ≤ 2 ⋅ 10^9) — the number of participants, the start interval and the contest duration.
Output
Print k lines, in the i-th line print the total dissatisfaction of participants in the i-th test case.
Example
Input
4
4 2 5
3 1 2
3 3 10
2000000000 1 2000000000
Output
5
3
3
1999999999000000000
Note
In the first example the first participant starts at 0 and finishes at time 5. By that time the second and the third participants start, so the dissatisfaction of the first participant is 2.
The second participant starts at time 2 and finishes at time 7. By that time the third the fourth participants start, so the dissatisfaction of the second participant is 2.
The third participant starts at 4 and finishes at 9. By that time the fourth participant starts, so the dissatisfaction of the third participant is 1.
The fourth participant starts at 6 and finishes at 11. By time 11 everyone finishes the contest, so the dissatisfaction of the fourth participant is 0.
In the second example the first participant starts at 0 and finishes at time 2. By that time the second participants starts, and the third starts at exactly time 2. So the dissatisfaction of the first participant is 2.
The second participant starts at time 1 and finishes at time 3. At that time the third participant is solving the contest.
|
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int k=sc.nextInt();
while(k-->0){
long n=sc.nextLong();
long x=sc.nextLong();
long t=sc.nextLong();
if(x==t){
System.out.println(n-1);
}
else if(x>t){
System.out.println(0);
}else {
long z=Math.min(n-1,t/x);
System.out.println(z*(z-1)/2+(z*(n-z)));
}
}
}
}
|
A string is binary, if it consists only of characters "0" and "1".
String v is a substring of string w if it has a non-zero length and can be read starting from some position in string w. For example, string "010" has six substrings: "0", "1", "0", "01", "10", "010". Two substrings are considered different if their positions of occurrence are different. So, if some string occurs multiple times, we should consider it the number of times it occurs.
You are given a binary string s. Your task is to find the number of its substrings, containing exactly k characters "1".
Input
The first line contains the single integer k (0 ≤ k ≤ 106). The second line contains a non-empty binary string s. The length of s does not exceed 106 characters.
Output
Print the single number — the number of substrings of the given string, containing exactly k characters "1".
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
1
1010
Output
6
Input
2
01010
Output
4
Input
100
01010
Output
0
Note
In the first sample the sought substrings are: "1", "1", "10", "01", "10", "010".
In the second sample the sought substrings are: "101", "0101", "1010", "01010".
|
def main():
k, s = lie(), input()
n = len(s)
dp = [-1]
for i in range(n):
if s[i] == '1':
dp.append(i)
dp.append(n)
if len(dp) - 2 < k:
print(0)
elif k == 0:
ans = 0
for i in range(1, len(dp)):
ans += (dp[i] - dp[i - 1] - 1) * (dp[i] - dp[i - 1]) // 2
print(ans)
else:
ans = 0
for i in range(k, len(dp) - 1):
ans += (dp[i + 1] - dp[i]) * (dp[i - k + 1] - dp[i - k])
print(ans)
def fun(n, m, k):
pass
from sys import *
import inspect
import re
from math import *
import threading
from collections import *
from pprint import pprint as pp
mod = 998244353
MAX = 10**5
def lie():
return int(input())
def liee():
return map(int, input().split())
def array():
return list(map(int, input().split()))
def deb(p):
for line in inspect.getframeinfo(inspect.currentframe().f_back)[3]:
m = re.search(r'\bdeb\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)', line)
print('%s %d' % (m.group(1), p))
def vector(size, val=0):
vec = [val for i in range(size)]
return vec
def matrix(rowNum, colNum, val=0):
mat = []
for i in range(rowNum):
collumn = [val for j in range(colNum)]
mat.append(collumn)
return mat
def dmain():
sys.setrecursionlimit(100000000)
threading.stack_size(40960000)
thread = threading.Thread(target=main)
thread.start()
if __name__ == '__main__':
main()
# dmain()
|
As you very well know, the whole Universe traditionally uses three-dimensional Cartesian system of coordinates. In this system each point corresponds to three real coordinates (x, y, z). In this coordinate system, the distance between the center of the Universe and the point is calculated by the following formula: <image>. Mushroom scientists that work for the Great Mushroom King think that the Universe isn't exactly right and the distance from the center of the Universe to a point equals xa·yb·zc.
To test the metric of mushroom scientists, the usual scientists offered them a task: find such x, y, z (0 ≤ x, y, z; x + y + z ≤ S), that the distance between the center of the Universe and the point (x, y, z) is maximum possible in the metric of mushroom scientists. The mushroom scientists aren't good at maths, so they commissioned you to do the task.
Note that in this problem, it is considered that 00 = 1.
Input
The first line contains a single integer S (1 ≤ S ≤ 103) — the maximum sum of coordinates of the sought point.
The second line contains three space-separated integers a, b, c (0 ≤ a, b, c ≤ 103) — the numbers that describe the metric of mushroom scientists.
Output
Print three real numbers — the coordinates of the point that reaches maximum value in the metrics of mushroom scientists. If there are multiple answers, print any of them that meets the limitations.
A natural logarithm of distance from the center of the Universe to the given point in the metric of mushroom scientists shouldn't differ from the natural logarithm of the maximum distance by more than 10 - 6. We think that ln(0) = - ∞.
Examples
Input
3
1 1 1
Output
1.0 1.0 1.0
Input
3
2 0 0
Output
3.0 0.0 0.0
|
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.util.StringTokenizer;
public class Main {
Scanner in;
PrintWriter out;
void setIn(String fI) {
try {
in = new Scanner(new FileInputStream(new File(fI)));
} catch (FileNotFoundException e) {
throw new Error(e);
}
}
void setIn() {
in = new Scanner(System.in);
}
void setOut(String fO) {
try {
out = new PrintWriter(new FileWriter(fO));
} catch (IOException e) {
throw new Error(e);
}
}
void setOut() {
out = new PrintWriter(System.out);
}
class Scanner {
StringTokenizer st;
BufferedReader in;
String del;
Scanner(InputStream is) {
in = new BufferedReader(new InputStreamReader(is));
st = null;
del = " \t\n\r\f";
}
void setDelimiters(String del) {
this.del = del;
}
String next() {
if (st == null || !st.hasMoreTokens()) {
st = new StringTokenizer(nextLine(), del);
}
return st.nextToken();
}
String nextLine() {
try {
st = null;
return in.readLine();
} catch (IOException e) {
throw new Error(e);
}
}
boolean hasNext() {
try {
return in.ready() || (st != null && st.hasMoreTokens());
} catch (IOException e) {
throw new Error(e);
}
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
BigInteger nextBigInteger() {
return new BigInteger(next());
}
BigDecimal nextBigDecimal() {
return new BigDecimal(next());
}
int[] nextIntArray(int len) {
int[] a = new int[len];
for (int i = 0; i < len; i++) {
a[i] = nextInt();
}
return a;
}
double nextDouble() {
return Double.parseDouble(next());
}
}
public static void main(String[] args) {
new Main().run();
}
void run() {
setIn();
setOut();
try {
solve();
} finally {
out.close();
}
}
MathContext pr = new MathContext(15);
BigDecimal pow(BigDecimal a, int n) {
if (n == 0) {
return BigDecimal.ONE;
}
if (a.compareTo(new BigDecimal(1e-8)) < 0) {
return BigDecimal.ZERO;
}
BigDecimal res = BigDecimal.ONE;
while (n > 0) {
if ((n & 1) == 1) {
res = res.multiply(a, pr);
}
a = a.multiply(a, pr);
n >>= 1;
}
return res;
}
BigDecimal f(int a, int b, double s, double x) {
return pow(new BigDecimal(x), a).multiply(pow(new BigDecimal(s - x), b), pr);
}
BigDecimal t2(double s, int a, int b) {
double l = 0;
double r = s;
double eps = 1e-6;
while (r - l > eps) {
double m1 = l + (r - l) / 2.5;
double m2 = r - (r - l) / 2.5;
if (f(a, b, s, m1).compareTo(f(a, b, s, m2)) < 0) {
l = m1;
} else {
r = m2;
}
}
r2 = l;
r3 = s - l;
return f(a, b, s, l);
}
double r1, r2, r3;
BigDecimal t1(double s, int a, int b, int c) {
double l = 0;
double r = s;
double eps = 1e-6;
while (r - l > eps) {
double m1 = l + (r - l) / 2.5;
double m2 = r - (r - l) / 2.5;
if (pow(new BigDecimal(m1), a).multiply(t2(s - m1, b, c), pr).compareTo(
pow(new BigDecimal(m2), a).multiply(t2(s - m2, b, c), pr)) < 0) {
l = m1;
} else {
r = m2;
}
}
r1 = l;
return pow(new BigDecimal(l), a).multiply(t2(s - l, b, c), pr);
}
void solve() {
long t = System.currentTimeMillis();
double s = in.nextInt();
int a = in.nextInt();
int b = in.nextInt();
int c = in.nextInt();
t1(s, a, b, c);
out.println(r1 + " " + r2 + " " + r3);
// out.println(System.currentTimeMillis() - t);
}
}
|
The Smart Beaver from ABBYY came up with another splendid problem for the ABBYY Cup participants! This time the Beaver invites the contest participants to check out a problem on sorting documents by their subjects. Let's describe the problem:
You've got some training set of documents. For each document you know its subject. The subject in this problem is an integer from 1 to 3. Each of these numbers has a physical meaning. For instance, all documents with subject 3 are about trade.
You can download the training set of documents at the following link: http://download4.abbyy.com/a2/X2RZ2ZWXBG5VYWAL61H76ZQM/train.zip. The archive contains three directories with names "1", "2", "3". Directory named "1" contains documents on the 1-st subject, directory "2" contains documents on the 2-nd subject, and directory "3" contains documents on the 3-rd subject. Each document corresponds to exactly one file from some directory.
All documents have the following format: the first line contains the document identifier, the second line contains the name of the document, all subsequent lines contain the text of the document. The document identifier is used to make installing the problem more convenient and has no useful information for the participants.
You need to write a program that should indicate the subject for a given document. It is guaranteed that all documents given as input to your program correspond to one of the three subjects of the training set.
Input
The first line contains integer id (0 ≤ id ≤ 106) — the document identifier. The second line contains the name of the document. The third and the subsequent lines contain the text of the document. It is guaranteed that the size of any given document will not exceed 10 kilobytes.
The tests for this problem are divided into 10 groups. Documents of groups 1 and 2 are taken from the training set, but their identifiers will not match the identifiers specified in the training set. Groups from the 3-rd to the 10-th are roughly sorted by the author in ascending order of difficulty (these groups contain documents which aren't present in the training set).
Output
Print an integer from 1 to 3, inclusive — the number of the subject the given document corresponds to.
Examples
|
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
n /= 1000;
puts(n & 1 ? "1" : "3");
return 0;
}
|
John Doe has a field, which is a rectangular table of size n × m. We assume that the field rows are numbered from 1 to n from top to bottom, and the field columns are numbered from 1 to m from left to right. Then the cell of the field at the intersection of the x-th row and the y-th column has coordinates (x; y).
We know that some cells of John's field are painted white, and some are painted black. Also, John has a tortoise, which can move along the white cells of the field. The tortoise can get from a white cell with coordinates (x; y) into cell (x + 1; y) or (x; y + 1), if the corresponding cell is painted white. In other words, the turtle can move only along the white cells of the field to the right or down. The turtle can not go out of the bounds of the field.
In addition, John has q queries, each of them is characterized by four numbers x1, y1, x2, y2 (x1 ≤ x2, y1 ≤ y2). For each query John wants to know whether the tortoise can start from the point with coordinates (x1; y1), and reach the point with coordinates (x2; y2), moving only along the white squares of the field.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 500) — the field sizes.
Each of the next n lines contains m characters "#" and ".": the j-th character of the i-th line equals "#", if the cell (i; j) is painted black and ".", if it is painted white.
The next line contains integer q (1 ≤ q ≤ 6·105) — the number of queries. Next q lines contain four space-separated integers x1, y1, x2 and y2 (1 ≤ x1 ≤ x2 ≤ n, 1 ≤ y1 ≤ y2 ≤ m) — the coordinates of the starting and the finishing cells. It is guaranteed that cells (x1; y1) and (x2; y2) are white.
Output
For each of q queries print on a single line "Yes", if there is a way from cell (x1; y1) to cell (x2; y2), that meets the requirements, and "No" otherwise. Print the answers to the queries in the order, in which the queries are given in the input.
Examples
Input
3 3
...
.##
.#.
5
1 1 3 3
1 1 1 3
1 1 3 1
1 1 1 2
1 1 2 1
Output
No
Yes
Yes
Yes
Yes
Input
5 5
.....
.###.
.....
.###.
.....
5
1 1 5 5
1 1 1 5
1 1 3 4
2 1 2 5
1 1 2 5
Output
Yes
Yes
Yes
No
Yes
|
#include <bits/stdc++.h>
using namespace std;
const int N = 512;
const int Q = 600011;
int arr[N][N];
int n, lp2[N];
struct query {
int when;
int i1, j1, i2, j2;
query() {}
query(int when, int i1, int j1, int i2, int j2)
: when(when), i1(i1), j1(j1), i2(i2), j2(j2) {}
};
int ans[Q];
vector<query> solo[N], Qs[N];
using BM = bitset<N>;
BM dp[N][N];
void solve(int L, int R) {
if (L == R) {
int cc = 0;
vector<int> colors(n, -1);
for (int i = 0; i < n; i++) {
if (i == 0 or arr[i][L] != arr[i - 1][L]) cc++;
colors[i] = cc;
}
for (auto q : solo[L]) {
int qt = q.when;
int i1 = q.i1, i2 = q.i2;
ans[qt] = i1 <= i2 and colors[i1] == colors[i2];
}
} else {
int M = (L + R) >> 1;
if (Qs[M].empty()) {
solve(L, M);
solve(M + 1, R);
return;
}
for (int i = 0; i < n; i++)
for (int j = L; j <= R; j++) dp[i][j].reset();
for (int i = n - 1; i >= 0; i--) {
if (arr[i][M]) continue;
dp[i][M][i] = arr[i][M] == 0;
if (i < n - 1) dp[i][M] |= dp[i + 1][M];
}
for (int i = n - 1; i >= 0; i--) {
for (int j = M - 1; j >= L; j--) {
if (arr[i][j]) continue;
dp[i][j] = dp[i][j + 1];
if (i < n - 1) dp[i][j] |= dp[i + 1][j];
}
}
BM tmp[n];
for (int i = 0; i < n; i++) {
if (arr[i][M]) continue;
tmp[i][i] = arr[i][M] == 0;
if (i > 0) tmp[i] |= tmp[i - 1];
}
for (int i = 0; i < n; i++) {
for (int j = M + 1; j <= R; j++) {
if (arr[i][j]) continue;
dp[i][j] = j > M + 1 ? dp[i][j - 1] : tmp[i];
if (i > 0) dp[i][j] |= dp[i - 1][j];
}
}
for (auto q : Qs[M]) {
int qt = q.when;
int i1 = q.i1, j1 = q.j1;
int i2 = q.i2, j2 = q.j2;
ans[qt] = (dp[i1][j1] & dp[i2][j2]).any();
}
solve(L, M);
solve(M + 1, R);
}
}
int pr[N][N];
void getPr(int L, int R) {
if (L == R) return;
int M = (L + R) >> 1;
for (int i = L; i <= M; i++)
for (int j = M + 1; j <= R; j++) pr[i][j] = pr[j][i] = M;
getPr(L, M);
getPr(M + 1, R);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
lp2[0] = -1;
lp2[1] = 0;
for (int i = 2; i < N; i++) {
lp2[i] = lp2[i - 1];
if ((i & (1 << lp2[i])) == 0) lp2[i]++;
}
getPr(0, N - 1);
int m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
int j;
for (j = 0; j < m; j++) arr[i][j] = s[j] == '#';
for (; j < N; j++) arr[i][j] = 1;
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int i1, j1, i2, j2;
cin >> i1 >> j1 >> i2 >> j2;
i1--;
j1--;
i2--;
j2--;
if (j1 == j2)
solo[j1].emplace_back(i, i1, j1, i2, j2);
else {
Qs[pr[j1][j2]].emplace_back(i, i1, j1, i2, j2);
}
}
solve(0, N - 1);
for (int i = 0; i < q; i++) cout << (ans[i] ? "Yes\n" : "No\n");
return 0;
}
|
The Little Elephant loves permutations of integers from 1 to n very much. But most of all he loves sorting them. To sort a permutation, the Little Elephant repeatedly swaps some elements. As a result, he must receive a permutation 1, 2, 3, ..., n.
This time the Little Elephant has permutation p1, p2, ..., pn. Its sorting program needs to make exactly m moves, during the i-th move it swaps elements that are at that moment located at the ai-th and the bi-th positions. But the Little Elephant's sorting program happened to break down and now on every step it can equiprobably either do nothing or swap the required elements.
Now the Little Elephant doesn't even hope that the program will sort the permutation, but he still wonders: if he runs the program and gets some permutation, how much will the result of sorting resemble the sorted one? For that help the Little Elephant find the mathematical expectation of the number of permutation inversions after all moves of the program are completed.
We'll call a pair of integers i, j (1 ≤ i < j ≤ n) an inversion in permutatuon p1, p2, ..., pn, if the following inequality holds: pi > pj.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000, n > 1) — the permutation size and the number of moves. The second line contains n distinct integers, not exceeding n — the initial permutation. Next m lines each contain two integers: the i-th line contains integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) — the positions of elements that were changed during the i-th move.
Output
In the only line print a single real number — the answer to the problem. The answer will be considered correct if its relative or absolute error does not exceed 10 - 6.
Examples
Input
2 1
1 2
1 2
Output
0.500000000
Input
4 3
1 3 2 4
1 2
2 3
1 4
Output
3.000000000
|
#include <bits/stdc++.h>
const int N = 1e3 + 5;
const int mod = 1e9 + 7;
const int MOD = mod - 1;
const double eps = 1e-18;
const double PI = acos(-1.0);
using namespace std;
int p[N];
double f[N][N];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) f[i][j] = (p[i] > p[j]);
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
for (int i = 1; i <= n; i++) {
if (i != a && i != b) {
f[i][a] = f[i][b] = (f[i][a] + f[i][b]) / 2;
f[a][i] = f[b][i] = (f[a][i] + f[b][i]) / 2;
}
}
f[a][b] = f[b][a] = 0.5;
}
double ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
ans += f[i][j];
}
}
printf("%f\n", ans);
return 0;
}
|
Bike loves looking for the second maximum element in the sequence. The second maximum element in the sequence of distinct numbers x1, x2, ..., xk (k > 1) is such maximum element xj, that the following inequality holds: <image>.
The lucky number of the sequence of distinct positive integers x1, x2, ..., xk (k > 1) is the number that is equal to the bitwise excluding OR of the maximum element of the sequence and the second maximum element of the sequence.
You've got a sequence of distinct positive integers s1, s2, ..., sn (n > 1). Let's denote sequence sl, sl + 1, ..., sr as s[l..r] (1 ≤ l < r ≤ n). Your task is to find the maximum number among all lucky numbers of sequences s[l..r].
Note that as all numbers in sequence s are distinct, all the given definitions make sence.
Input
The first line contains integer n (1 < n ≤ 105). The second line contains n distinct integers s1, s2, ..., sn (1 ≤ si ≤ 109).
Output
Print a single integer — the maximum lucky number among all lucky numbers of sequences s[l..r].
Examples
Input
5
5 2 1 4 3
Output
7
Input
5
9 8 3 5 7
Output
15
Note
For the first sample you can choose s[4..5] = {4, 3} and its lucky number is (4 xor 3) = 7. You can also choose s[1..2].
For the second sample you must choose s[2..5] = {8, 3, 5, 7}.
|
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.util.Stack;
public class CFFF {
static PrintWriter out;
public static void main(String[] args) {
MScanner sc = new MScanner();
out = new PrintWriter(System.out);
int N = sc.nextInt();
int[] array = sc.nextInt(N);
int best = 0;
Stack<Integer> s = new Stack<Integer>();
for(int a=0;a<N;a++){
while(!s.isEmpty()){
best = Math.max(best,s.peek()^array[a]);
if(s.peek()<array[a])s.pop();
else break;
}
s.add(array[a]);
}
out.println(best);
out.close();
}
static class MScanner {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
public MScanner() {
stream = System.in;
// stream = new FileInputStream(new File("dec.in"));
}
int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
boolean isEndline(int c) {
return c == '\n' || c == '\r' || c == -1;
}
int nextInt() {
return Integer.parseInt(next());
}
int[] nextInt(int N) {
int[] ret = new int[N];
for (int a = 0; a < N; a++)
ret[a] = nextInt();
return ret;
}
int[][] nextInt(int N, int M) {
int[][] ret = new int[N][M];
for (int a = 0; a < N; a++)
ret[a] = nextInt(M);
return ret;
}
long nextLong() {
return Long.parseLong(next());
}
long[] nextLong(int N) {
long[] ret = new long[N];
for (int a = 0; a < N; a++)
ret[a] = nextLong();
return ret;
}
double nextDouble() {
return Double.parseDouble(next());
}
double[] nextDouble(int N) {
double[] ret = new double[N];
for (int a = 0; a < N; a++)
ret[a] = nextDouble();
return ret;
}
String next() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
String[] next(int N) {
String[] ret = new String[N];
for (int a = 0; a < N; a++)
ret[a] = next();
return ret;
}
String nextLine() {
int c = read();
while (isEndline(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isEndline(c));
return res.toString();
}
String[] nextLine(int N) {
String[] ret = new String[N];
for (int a = 0; a < N; a++)
ret[a] = nextLine();
return ret;
}
}
}
|
Bike is interested in permutations. A permutation of length n is an integer sequence such that each integer from 0 to (n - 1) appears exactly once in it. For example, [0, 2, 1] is a permutation of length 3 while both [0, 2, 2] and [1, 2, 3] is not.
A permutation triple of permutations of length n (a, b, c) is called a Lucky Permutation Triple if and only if <image>. The sign ai denotes the i-th element of permutation a. The modular equality described above denotes that the remainders after dividing ai + bi by n and dividing ci by n are equal.
Now, he has an integer n and wants to find a Lucky Permutation Triple. Could you please help him?
Input
The first line contains a single integer n (1 ≤ n ≤ 105).
Output
If no Lucky Permutation Triple of length n exists print -1.
Otherwise, you need to print three lines. Each line contains n space-seperated integers. The first line must contain permutation a, the second line — permutation b, the third — permutation c.
If there are multiple solutions, print any of them.
Examples
Input
5
Output
1 4 3 2 0
1 0 2 4 3
2 4 0 1 3
Input
2
Output
-1
Note
In Sample 1, the permutation triple ([1, 4, 3, 2, 0], [1, 0, 2, 4, 3], [2, 4, 0, 1, 3]) is Lucky Permutation Triple, as following holds:
* <image>;
* <image>;
* <image>;
* <image>;
* <image>.
In Sample 2, you can easily notice that no lucky permutation triple exists.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
cin >> x;
if (x % 2 == 0) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < x; i++) {
cout << i << " ";
}
cout << "\n";
for (int i = 0; i < x; i++) {
cout << i << " ";
}
cout << "\n";
for (int i = 0; i < x; i++) {
cout << (i * 2) % x << " ";
}
cout << "\n";
}
|
You're a mikemon breeder currently in the middle of your journey to become a mikemon master. Your current obstacle is go through the infamous Biridian Forest.
The forest
The Biridian Forest is a two-dimensional grid consisting of r rows and c columns. Each cell in Biridian Forest may contain a tree, or may be vacant. A vacant cell may be occupied by zero or more mikemon breeders (there may also be breeders other than you in the forest). Mikemon breeders (including you) cannot enter cells with trees. One of the cells is designated as the exit cell.
The initial grid, including your initial position, the exit cell, and the initial positions of all other breeders, will be given to you. Here's an example of such grid (from the first example):
<image>
Moves
Breeders (including you) may move in the forest. In a single move, breeders may perform one of the following actions:
* Do nothing.
* Move from the current cell to one of the four adjacent cells (two cells are adjacent if they share a side). Note that breeders cannot enter cells with trees.
* If you are located on the exit cell, you may leave the forest. Only you can perform this move — all other mikemon breeders will never leave the forest by using this type of movement.
After each time you make a single move, each of the other breeders simultaneously make a single move (the choice of which move to make may be different for each of the breeders).
Mikemon battle
If you and t (t > 0) mikemon breeders are located on the same cell, exactly t mikemon battles will ensue that time (since you will be battling each of those t breeders once). After the battle, all of those t breeders will leave the forest to heal their respective mikemons.
Note that the moment you leave the forest, no more mikemon battles can ensue, even if another mikemon breeder move to the exit cell immediately after that. Also note that a battle only happens between you and another breeders — there will be no battle between two other breeders (there may be multiple breeders coexisting in a single cell).
Your goal
You would like to leave the forest. In order to do so, you have to make a sequence of moves, ending with a move of the final type. Before you make any move, however, you post this sequence on your personal virtual idol Blog. Then, you will follow this sequence of moves faithfully.
Goal of other breeders
Because you post the sequence in your Blog, the other breeders will all know your exact sequence of moves even before you make your first move. All of them will move in such way that will guarantee a mikemon battle with you, if possible. The breeders that couldn't battle you will do nothing.
Your task
Print the minimum number of mikemon battles that you must participate in, assuming that you pick the sequence of moves that minimize this number. Note that you are not required to minimize the number of moves you make.
Input
The first line consists of two integers: r and c (1 ≤ r, c ≤ 1000), denoting the number of rows and the number of columns in Biridian Forest. The next r rows will each depict a row of the map, where each character represents the content of a single cell:
* 'T': A cell occupied by a tree.
* 'S': An empty cell, and your starting position. There will be exactly one occurence of this in the map.
* 'E': An empty cell, and where the exit is located. There will be exactly one occurence of this in the map.
* A digit (0-9): A cell represented by a digit X means that the cell is empty and is occupied by X breeders (in particular, if X is zero, it means that the cell is not occupied by any breeder).
It is guaranteed that it will be possible for you to go from your starting position to the exit cell through a sequence of moves.
Output
A single line denoted the minimum possible number of mikemon battles that you have to participate in if you pick a strategy that minimize this number.
Examples
Input
5 7
000E0T3
T0TT0T0
010T0T0
2T0T0T0
0T0S000
Output
3
Input
1 4
SE23
Output
2
Note
The following picture illustrates the first example. The blue line denotes a possible sequence of moves that you should post in your blog:
<image>
The three breeders on the left side of the map will be able to battle you — the lone breeder can simply stay in his place until you come while the other two breeders can move to where the lone breeder is and stay there until you come. The three breeders on the right does not have a way to battle you, so they will stay in their place.
For the second example, you should post this sequence in your Blog:
<image>
Here's what happens. First, you move one cell to the right.
<image>
Then, the two breeders directly to the right of the exit will simultaneously move to the left. The other three breeder cannot battle you so they will do nothing.
<image>
You end up in the same cell with 2 breeders, so 2 mikemon battles are conducted. After those battles, all of your opponents leave the forest.
<image>
Finally, you make another move by leaving the forest.
<image>
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class problemD {
static void solve() throws IOException {
int n = nextInt();
int m = nextInt();
char[][] grid = new char[n][m];
int endx = -1, endy = -1;
int stx = -1, sty = -1;
for (int i = 0; i < n; i++) {
grid[i] = nextToken().toCharArray();
for (int j = 0; j < m; j++) {
if (grid[i][j] == 'E') {
endx = i;
endy = j;
}
else if (grid[i][j] == 'S') {
stx = i;
sty = j;
}
}
}
int[] qx = new int[n * m];
int[] qy = new int[n * m];
int qh = 0, qt = 0;
qx[qt] = endx;
qy[qt++] = endy;
int[][] dist = new int[n][m];
for (int i = 0; i < n; i++) {
Arrays.fill(dist[i], Integer.MAX_VALUE);
}
dist[endx][endy] = 0;
int[] dx = {-1, 1, 0, 0};
int[] dy = {0, 0, -1, 1};
while (qh < qt) {
int x = qx[qh];
int y = qy[qh++];
for (int i = 0; i < 4; i++) {
int nx = dx[i] + x;
int ny = dy[i] + y;
if (!(nx >= 0 && nx < n && ny >= 0 && ny < m && grid[nx][ny] != 'T'))
continue;
if (dist[nx][ny] > dist[x][y] + 1) {
dist[nx][ny] = dist[x][y] + 1;
qx[qt] = nx;
qy[qt++] = ny;
}
}
}
int len = dist[stx][sty];
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid[i][j] < 'A') {
if (dist[i][j] <= len) {
int cnt = grid[i][j] - '0';
ans += cnt;
}
}
}
}
out.println(ans);
}
static BufferedReader br;
static PrintWriter out;
static StringTokenizer st;
static boolean hasNextToken() throws IOException {
while (st == null || !st.hasMoreTokens()) {
String line = br.readLine();
if (line == null) {
return false;
}
st = new StringTokenizer(line);
}
return true;
}
static String nextToken() throws IOException {
return hasNextToken() ? st.nextToken() : null;
}
static int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
public static void main(String[] args) throws IOException {
br = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(new OutputStreamWriter(System.out));
solve();
br.close();
out.close();
}
}
|
One day Jeff got hold of an integer sequence a1, a2, ..., an of length n. The boy immediately decided to analyze the sequence. For that, he needs to find all values of x, for which these conditions hold:
* x occurs in sequence a.
* Consider all positions of numbers x in the sequence a (such i, that ai = x). These numbers, sorted in the increasing order, must form an arithmetic progression.
Help Jeff, find all x that meet the problem conditions.
Input
The first line contains integer n (1 ≤ n ≤ 105). The next line contains integers a1, a2, ..., an (1 ≤ ai ≤ 105). The numbers are separated by spaces.
Output
In the first line print integer t — the number of valid x. On each of the next t lines print two integers x and px, where x is current suitable value, px is the common difference between numbers in the progression (if x occurs exactly once in the sequence, px must equal 0). Print the pairs in the order of increasing x.
Examples
Input
1
2
Output
1
2 0
Input
8
1 2 1 3 1 2 1 5
Output
4
1 2
2 4
3 0
5 0
Note
In the first test 2 occurs exactly once in the sequence, ergo p2 = 0.
|
le = int(input())
integers = [int(i) for i in str(input()).split(" ")]
d = {}
for index, ele in enumerate(integers): # should already be sorted
if ele in d:
d[ele].append(index)
else:
d[ele] = [index]
ans = []
for key, items in d.items():
if len(items) == 1:
ans.append((key, 0))
else:
shouldAdd = True
prog = items[1] - items[0]
for i in range(1, len(items), 1):
if items[i] - items[i-1] != prog:
shouldAdd = False
break
if shouldAdd:
ans.append((key, prog))
print(len(ans))
for line in sorted(ans):
print(line[0], line[1])
|
You have number a, whose decimal representation quite luckily contains digits 1, 6, 8, 9. Rearrange the digits in its decimal representation so that the resulting number will be divisible by 7.
Number a doesn't contain any leading zeroes and contains digits 1, 6, 8, 9 (it also can contain another digits). The resulting number also mustn't contain any leading zeroes.
Input
The first line contains positive integer a in the decimal record. It is guaranteed that the record of number a contains digits: 1, 6, 8, 9. Number a doesn't contain any leading zeroes. The decimal representation of number a contains at least 4 and at most 106 characters.
Output
Print a number in the decimal notation without leading zeroes — the result of the permutation.
If it is impossible to rearrange the digits of the number a in the required manner, print 0.
Examples
Input
1689
Output
1869
Input
18906
Output
18690
|
import java.io.*;
import java.util.*;
import java.math.*;
public class Main{
public static void main(String args[]) throws Exception{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s = br.readLine();
boolean seen[] = new boolean[10];
StringBuilder sb = new StringBuilder(s);
int zero = 0;
int res = 0;
StringBuilder out = new StringBuilder("");
for(int i = 0 ; i < sb.length() ; i++){
if(sb.charAt(i) == '1' && !seen[1]) { sb.deleteCharAt(i); i--; seen[1] = true; }
else if(sb.charAt(i) == '6' && !seen[6]) { sb.deleteCharAt(i); i--; seen[6] = true;}
else if(sb.charAt(i) == '8' && !seen[8]) { sb.deleteCharAt(i); i--; seen[8] = true; }
else if(sb.charAt(i) == '9' && !seen[9]) { sb.deleteCharAt(i); i--; seen[9] = true; }
else if(sb.charAt(i) == '0'){
zero++;
}
else{
res = (res*10 + (sb.charAt(i) - '0')) % 7;
out.append(sb.charAt(i));
//~ System.out.print(sb.charAt(i));
}
}
int perm[] = {1, 6, 8, 9};
while(true){
String perms = "";
int restmp = res;
for(int i = 0 ; i < 4 ; i++){
restmp = (restmp*10 + perm[i]) % 7;
//~ System.out.print(restmp+" ");
perms += perm[i];
}
//~ System.out.println("perms: "+perms+" "+restmp);
if(restmp == 0) {
System.out.print(out+""+perms);
break;
}
if(!nextPermutation(perm)) break;
}
for(int i = 0 ; i < zero ; i++){
System.out.print(0);
}
System.out.println();
}
public static boolean nextPermutation(int ar[]){
//find largest ar[i] < ar[i+1]
int idx = 0;
boolean found = false;
for(int i = ar.length -2 ; i >= 0 ; i--){
if(ar[i] < ar[i+1]){
idx = i;
found = true;
break;
}
}
if(!found) return false;
int swap = ar.length - 1;
//find swappable item (first larger ar[swap] from end)
while(ar[idx] > ar[swap]){
swap--;
}
//swap idx and swap
int tmp = ar[idx]; ar[idx] = ar[swap]; ar[swap] = tmp;
//reverse from idx+1 behind
for(int i = idx + 1, j = ar.length-1 ; i < (idx+1+ar.length)/2 ; j--, i++){
tmp = ar[i]; ar[i] = ar[j]; ar[j] = tmp;
}
return true;
}
}
|
We are given a permutation sequence a1, a2, ..., an of numbers from 1 to n. Let's assume that in one second, we can choose some disjoint pairs (u1, v1), (u2, v2), ..., (uk, vk) and swap all aui and avi for every i at the same time (1 ≤ ui < vi ≤ n). The pairs are disjoint if every ui and vj are different from each other.
We want to sort the sequence completely in increasing order as fast as possible. Given the initial permutation, calculate the number of ways to achieve this. Two ways are different if and only if there is a time t, such that the set of pairs used for swapping at that time are different as sets (so ordering of pairs doesn't matter). If the given permutation is already sorted, it takes no time to sort, so the number of ways to sort it is 1.
To make the problem more interesting, we have k holes inside the permutation. So exactly k numbers of a1, a2, ..., an are not yet determined. For every possibility of filling the holes, calculate the number of ways, and print the total sum of these values modulo 1000000007 (109 + 7).
Input
The first line contains two integers n (1 ≤ n ≤ 105) and k (0 ≤ k ≤ 12). The second line contains the permutation sequence a1, ..., an (0 ≤ ai ≤ n). If a number is not yet determined, it is denoted as 0. There are exactly k zeroes. All the numbers ai that aren't equal to zero are distinct.
Output
Print the total sum of the number of ways modulo 1000000007 (109 + 7).
Examples
Input
5 0
1 5 2 4 3
Output
6
Input
5 2
1 0 2 4 0
Output
7
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0.0) * 2.0;
const double eps = 1e-12;
const int step[8][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
template <class T>
inline T abs1(T a) {
return a < 0 ? -a : a;
}
template <class T>
inline T max1(T a, T b) {
return a > b ? a : b;
}
template <class T>
inline T max1(T a, T b, T c) {
return max1(max1(a, b), c);
}
template <class T>
inline T max1(T a, T b, T c, T d) {
return max1(max1(a, b, c), d);
}
template <class T>
inline T max1(T a, T b, T c, T d, T e) {
return max1(max1(a, b, c, d), e);
}
template <class T>
inline T min1(T a, T b) {
return a < b ? a : b;
}
template <class T>
inline T min1(T a, T b, T c) {
return min1(min1(a, b), c);
}
template <class T>
inline T min1(T a, T b, T c, T d) {
return min1(min1(a, b, c), d);
}
template <class T>
inline T min1(T a, T b, T c, T d, T e) {
return min1(min1(a, b, c, d), e);
}
template <class T>
inline T lowb(T num) {
return num & (-num);
}
inline int jud(double a, double b) {
if (abs(a) < eps && abs(b) < eps)
return 0;
else if (abs1(a - b) / abs1(a) < eps)
return 0;
if (a < b) return -1;
return 1;
}
template <typename t>
inline int jud(t a, t b) {
if (a < b) return -1;
if (a == b) return 0;
return 1;
}
template <typename it, typename t1>
inline int find(t1 val, it a, int na, bool f_small = 1, bool f_lb = 1) {
int be = 0, en = na - 1;
if (*a <= *(a + na - 1)) {
if (f_lb == 0)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != 1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != -1)
en = mid;
else
be = mid + 1;
}
if (f_small && jud(*(a + be), val) == 1) be--;
if (!f_small && jud(*(a + be), val) == -1) be++;
} else {
if (f_lb)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != -1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != 1)
en = mid;
else
be = mid + 1;
}
if (!f_small && jud(*(a + be), val) == -1) be--;
if (f_small && jud(*(a + be), val) == 1) be++;
}
return be;
}
inline int bitnum(unsigned int nValue) { return __builtin_popcount(nValue); }
inline int bitnum(int nValue) { return __builtin_popcount(nValue); }
inline int bitnum(unsigned long long nValue) {
return __builtin_popcount(nValue) + __builtin_popcount(nValue >> 32);
}
inline int bitnum(long long nValue) {
return __builtin_popcount(nValue) + __builtin_popcount(nValue >> 32);
}
inline int bitmaxl(unsigned int a) {
if (a == 0) return 0;
return 32 - __builtin_clz(a);
}
inline int bitmaxl(int a) {
if (a == 0) return 0;
return 32 - __builtin_clz(a);
}
inline int bitmaxl(unsigned long long a) {
int temp = a >> 32;
if (temp) return 32 - __builtin_clz(temp) + 32;
return bitmaxl(int(a));
}
inline int bitmaxl(long long a) {
int temp = a >> 32;
if (temp) return 32 - __builtin_clz(temp) + 32;
return bitmaxl(int(a));
}
long long pow(long long n, long long m, long long mod = 0) {
if (m < 0) return 0;
long long ans = 1;
long long k = n;
while (m) {
if (m & 1) {
ans *= k;
if (mod) ans %= mod;
}
k *= k;
if (mod) k %= mod;
m >>= 1;
}
return ans;
}
const int mod = 1000000007;
const int maxn = 100100;
int n, arr[maxn], nxt[maxn], wh[maxn], rn;
vector<int> lian;
int nlian, n1huan, maxhuan, n2huan;
bool f[maxn];
long long fac[20];
long long sum[1 << 13], cnt[maxn];
vector<long long> ge[maxn], invge[maxn];
long long ans, tempans;
int op[maxn], lop, tempcnt[maxn];
inline long long justdoit(int n) {
if (n == 2) return 1;
if (n & 1) return n;
return n;
}
void dfs(int mask, long long rrans = 1) {
if (mask == (1 << nlian) - 1) {
int maxop = maxhuan;
for (int i = 0; i < lop; i++) {
maxop = max(op[i], maxop);
}
if (maxop <= 2)
ans += rrans;
else {
long long rans = tempans;
for (int i = 0; i < lop; i++) {
rans *= invge[op[i]][cnt[op[i]]] *
ge[op[i]][cnt[op[i]] + tempcnt[op[i]]] % mod;
rans %= mod;
}
ans += rans * rrans % mod;
}
ans %= mod;
return;
}
int rmask = 1 << nlian;
rmask -= mask + 1;
for (int j = rmask; j >= 1 << (bitmaxl(rmask) - 1); j = (j - 1) & rmask) {
long long tans = rrans * fac[bitnum(j) - 1] % mod;
tempcnt[sum[j]]++;
if (tempcnt[sum[j]] == 1) op[lop++] = sum[j];
dfs(mask + j, tans);
tempcnt[sum[j]]--;
if (tempcnt[sum[j]] == 0) lop--;
}
}
int main() {
ios_base::sync_with_stdio(0);
scanf("%d%d", &n, &rn);
memset(wh, -1, sizeof(wh));
fac[0] = 1;
for (int i = 1; i < 20; i++) fac[i] = fac[i - 1] * i % mod;
for (int i = 0; i < n; i++) {
scanf("%d", arr + i);
arr[i]--;
if (arr[i] >= 0) wh[arr[i]] = i;
}
for (int i = 0; i < n; i++)
if (wh[i] == -1) {
int cnt = 0;
f[i] = 1;
for (int j = i; j != -1; j = arr[j], cnt++, f[j] = 1)
;
lian.push_back(cnt);
nlian++;
}
for (int i = 0; i < n; i++)
if (f[i] == 0) {
int rcnt = 0;
for (int j = i; !f[j]; f[j] = 1, j = arr[j], rcnt++)
;
maxhuan = max(maxhuan, rcnt);
cnt[rcnt]++;
}
for (int i = 0; i < 1 << nlian; i++) {
for (int j = 0; j < nlian; j++)
if (i & (1 << j)) sum[i] += lian[j];
}
for (int i = 1; i <= n; i++) {
ge[i].reserve(cnt[i] + max(nlian, 10) + 1);
invge[i].reserve(cnt[i] + max(nlian, 10) + 1);
ge[i].push_back(1);
ge[i].push_back(i);
invge[i].push_back(1);
invge[i].push_back(pow(i, mod - 2, mod));
for (int j = 2; j <= cnt[i] + max(nlian, 10); j++) {
ge[i].push_back(ge[i][j - 2] * (j - 1) % mod * i % mod +
ge[i][j - 1] * i % mod);
ge[i][j] %= mod;
invge[i].push_back(pow(ge[i][j], mod - 2, mod));
}
}
tempans = 1;
for (int i = 1; i <= n; i++)
if (cnt[i]) {
tempans = tempans * ge[i][cnt[i]] % mod;
}
dfs(0, 1);
cout << ans << endl;
return 0;
}
|
Pasha has two hamsters: Arthur and Alexander. Pasha put n apples in front of them. Pasha knows which apples Arthur likes. Similarly, Pasha knows which apples Alexander likes. Pasha doesn't want any conflict between the hamsters (as they may like the same apple), so he decided to distribute the apples between the hamsters on his own. He is going to give some apples to Arthur and some apples to Alexander. It doesn't matter how many apples each hamster gets but it is important that each hamster gets only the apples he likes. It is possible that somebody doesn't get any apples.
Help Pasha distribute all the apples between the hamsters. Note that Pasha wants to distribute all the apples, not just some of them.
Input
The first line contains integers n, a, b (1 ≤ n ≤ 100; 1 ≤ a, b ≤ n) — the number of apples Pasha has, the number of apples Arthur likes and the number of apples Alexander likes, correspondingly.
The next line contains a distinct integers — the numbers of the apples Arthur likes. The next line contains b distinct integers — the numbers of the apples Alexander likes.
Assume that the apples are numbered from 1 to n. The input is such that the answer exists.
Output
Print n characters, each of them equals either 1 or 2. If the i-h character equals 1, then the i-th apple should be given to Arthur, otherwise it should be given to Alexander. If there are multiple correct answers, you are allowed to print any of them.
Examples
Input
4 2 3
1 2
2 3 4
Output
1 1 2 2
Input
5 5 2
3 4 1 2 5
2 3
Output
1 1 1 1 1
|
n, a, b = map(int, input().split())
x = set(map(int, input().split()))
y = set(map(int, input().split()))
y -= x
s = ""
for i in range(1, n + 1, 1):
if i in x:
s += str(1) + " "
else:
s += str(2) + " "
print(s)
|
As we know, DZY loves playing games. One day DZY decided to play with a n × m matrix. To be more precise, he decided to modify the matrix with exactly k operations.
Each modification is one of the following:
1. Pick some row of the matrix and decrease each element of the row by p. This operation brings to DZY the value of pleasure equal to the sum of elements of the row before the decreasing.
2. Pick some column of the matrix and decrease each element of the column by p. This operation brings to DZY the value of pleasure equal to the sum of elements of the column before the decreasing.
DZY wants to know: what is the largest total value of pleasure he could get after performing exactly k modifications? Please, help him to calculate this value.
Input
The first line contains four space-separated integers n, m, k and p (1 ≤ n, m ≤ 103; 1 ≤ k ≤ 106; 1 ≤ p ≤ 100).
Then n lines follow. Each of them contains m integers representing aij (1 ≤ aij ≤ 103) — the elements of the current row of the matrix.
Output
Output a single integer — the maximum possible total pleasure value DZY could get.
Examples
Input
2 2 2 2
1 3
2 4
Output
11
Input
2 2 5 2
1 3
2 4
Output
11
Note
For the first sample test, we can modify: column 2, row 2. After that the matrix becomes:
1 1
0 0
For the second sample test, we can modify: column 2, row 2, row 1, column 1, column 2. After that the matrix becomes:
-3 -3
-2 -2
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1005;
const long long M = 1e6 + 5;
const long long inf = 1e15;
long long row[N], col[N];
long long ansr[M], ansc[M];
priority_queue<long long> q[2];
int main() {
long long n, m, k, p, t;
scanf("%I64d%I64d%I64d%I64d", &n, &m, &k, &p);
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
scanf("%I64d", &t);
row[i] += t;
col[j] += t;
}
}
for (long long i = 1; i <= n; i++) {
q[0].push(row[i]);
}
for (long long i = 1; i <= m; i++) {
q[1].push(col[i]);
}
for (long long i = 1; i <= k; i++) {
long long t1 = q[0].top(), t2 = q[1].top();
ansr[i] = ansr[i - 1] + t1;
q[0].pop();
ansc[i] = ansc[i - 1] + t2;
q[1].pop();
q[0].push(t1 - p * m);
q[1].push(t2 - p * n);
}
long long ans = -inf;
for (long long i = 0; i <= k; i++) {
ans = max(ans, ansr[i] + ansc[k - i] - 1ll * i * (k - i) * p);
}
printf("%I64d\n", ans);
return 0;
}
|
Little X has met the following problem recently.
Let's define f(x) as the sum of digits in decimal representation of number x (for example, f(1234) = 1 + 2 + 3 + 4). You are to calculate <image>
Of course Little X has solved this problem quickly, has locked it, and then has tried to hack others. He has seen the following C++ code:
ans = solve(l, r) % a;
if (ans <= 0)
ans += a;
This code will fail only on the test with <image>. You are given number a, help Little X to find a proper test for hack.
Input
The first line contains a single integer a (1 ≤ a ≤ 1018).
Output
Print two integers: l, r (1 ≤ l ≤ r < 10200) — the required test data. Leading zeros aren't allowed. It's guaranteed that the solution exists.
Examples
Input
46
Output
1 10
Input
126444381000032
Output
2333333 2333333333333
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long X = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') w = -1;
c = getchar();
}
while (c >= '0' && c <= '9') X = X * 10 + c - '0', c = getchar();
return X * w;
}
const long long _ = 1e18;
signed main() {
long long a = read(), q = (_ % a * 9 % a * 9 % a + 1) % a;
printf("%lld %lld\n", a - q + 1, a - q + _);
return 0;
}
|
Vanya got n cubes. He decided to build a pyramid from them. Vanya wants to build the pyramid as follows: the top level of the pyramid must consist of 1 cube, the second level must consist of 1 + 2 = 3 cubes, the third level must have 1 + 2 + 3 = 6 cubes, and so on. Thus, the i-th level of the pyramid must have 1 + 2 + ... + (i - 1) + i cubes.
Vanya wants to know what is the maximum height of the pyramid that he can make using the given cubes.
Input
The first line contains integer n (1 ≤ n ≤ 104) — the number of cubes given to Vanya.
Output
Print the maximum possible height of the pyramid in the single line.
Examples
Input
1
Output
1
Input
25
Output
4
Note
Illustration to the second sample:
<image>
|
n=int(input())
i=1;x=0
while 1:
x+=(i*(i+1)/2)
if x==n:
print(i)
break
elif x>n:
print(i-1)
break
i+=1
|
Drazil is a monkey. He lives in a circular park. There are n trees around the park. The distance between the i-th tree and (i + 1)-st trees is di, the distance between the n-th tree and the first tree is dn. The height of the i-th tree is hi.
Drazil starts each day with the morning run. The morning run consists of the following steps:
* Drazil chooses two different trees
* He starts with climbing up the first tree
* Then he climbs down the first tree, runs around the park (in one of two possible directions) to the second tree, and climbs on it
* Then he finally climbs down the second tree.
But there are always children playing around some consecutive trees. Drazil can't stand children, so he can't choose the trees close to children. He even can't stay close to those trees.
If the two trees Drazil chooses are x-th and y-th, we can estimate the energy the morning run takes to him as 2(hx + hy) + dist(x, y). Since there are children on exactly one of two arcs connecting x and y, the distance dist(x, y) between trees x and y is uniquely defined.
Now, you know that on the i-th day children play between ai-th tree and bi-th tree. More formally, if ai ≤ bi, children play around the trees with indices from range [ai, bi], otherwise they play around the trees with indices from <image>.
Please help Drazil to determine which two trees he should choose in order to consume the most energy (since he wants to become fit and cool-looking monkey) and report the resulting amount of energy for each day.
Input
The first line contains two integer n and m (3 ≤ n ≤ 105, 1 ≤ m ≤ 105), denoting number of trees and number of days, respectively.
The second line contains n integers d1, d2, ..., dn (1 ≤ di ≤ 109), the distances between consecutive trees.
The third line contains n integers h1, h2, ..., hn (1 ≤ hi ≤ 109), the heights of trees.
Each of following m lines contains two integers ai and bi (1 ≤ ai, bi ≤ n) describing each new day. There are always at least two different trees Drazil can choose that are not affected by children.
Output
For each day print the answer in a separate line.
Examples
Input
5 3
2 2 2 2 2
3 5 2 1 4
1 3
2 2
4 5
Output
12
16
18
Input
3 3
5 1 4
5 1 4
3 3
2 2
1 1
Output
17
22
11
|
#include <bits/stdc++.h>
const long long MAXN = 1e5;
const long long INF = 0x3f3f3f3f3f3f3f;
long long n, m;
long long d[MAXN << 1 | 1], h[MAXN << 1 | 1];
inline long long read() {
register long long x = 0, v = 1;
register char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') v = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * v;
}
namespace ST {
long long A[MAXN << 1 | 1], B[MAXN << 1 | 1];
long long max[19][MAXN << 1 | 1], min[19][MAXN << 1 | 1], lg[MAXN << 1 | 1];
inline long long MAX(long long x, long long y) { return A[x] > A[y] ? x : y; }
inline long long MIN(long long x, long long y) { return B[x] < B[y] ? x : y; }
void get_ST() {
A[0] = -INF;
B[0] = INF;
for (long long i = 2; i <= n << 1; ++i) lg[i] = lg[i >> 1] + 1;
for (long long i = 1, s = 0; i <= n << 1; ++i) {
s += d[i];
A[i] = s + h[i];
B[i] = s - h[i];
max[0][i] = i;
min[0][i] = i;
}
for (long long i = 1; i <= lg[n << 1]; ++i) {
for (long long j = 1; j + (1 << i) - 1 <= n << 1; ++j) {
max[i][j] = MAX(max[i - 1][j], max[i - 1][j + (1 << i - 1)]);
min[i][j] = MIN(min[i - 1][j], min[i - 1][j + (1 << i - 1)]);
}
}
}
inline long long pmax(long long l, long long r) {
if (l > r) return 0;
long long len = lg[r - l + 1];
return MAX(max[len][l], max[len][r - (1 << len) + 1]);
}
inline long long pmin(long long l, long long r) {
if (l > r) return 0;
long long len = lg[r - l + 1];
return MIN(min[len][l], min[len][r - (1 << len) + 1]);
}
} // namespace ST
using namespace ST;
long long calc(long long l, long long r) {
long long x = pmax(l, r), y = pmin(l, r);
if (x != y) return A[x] - B[y];
long long tx = MAX(pmax(l, x - 1), pmax(x + 1, r)),
ty = MIN(pmin(l, y - 1), pmin(y + 1, r));
return std::max(A[x] - B[ty], A[tx] - B[y]);
}
signed main() {
n = read();
m = read();
for (long long i = 1; i <= n; ++i) {
d[i % n + 1] = d[i % n + 1 + n] = read();
}
for (long long i = 1; i <= n; ++i) {
h[i] = h[i + n] = read() << 1;
}
get_ST();
while (m--) {
long long l = read(), r = read();
if (l <= r)
printf("%lld\n", calc(r + 1, l + n - 1));
else
printf("%lld\n", calc(r + 1, l - 1));
}
return 0;
}
|
Polycarp is making a quest for his friends. He has already made n tasks, for each task the boy evaluated how interesting it is as an integer qi, and the time ti in minutes needed to complete the task.
An interesting feature of his quest is: each participant should get the task that is best suited for him, depending on his preferences. The task is chosen based on an interactive quiz that consists of some questions. The player should answer these questions with "yes" or "no". Depending on the answer to the question, the participant either moves to another question or goes to one of the tasks that are in the quest. In other words, the quest is a binary tree, its nodes contain questions and its leaves contain tasks.
We know that answering any of the questions that are asked before getting a task takes exactly one minute from the quest player. Polycarp knows that his friends are busy people and they can't participate in the quest for more than T minutes. Polycarp wants to choose some of the n tasks he made, invent the corresponding set of questions for them and use them to form an interactive quiz as a binary tree so that no matter how the player answers quiz questions, he spends at most T minutes on completing the whole quest (that is, answering all the questions and completing the task). Specifically, the quest can contain zero questions and go straight to the task. Each task can only be used once (i.e., the people who give different answers to questions should get different tasks).
Polycarp wants the total "interest" value of the tasks involved in the quest to be as large as possible. Help him determine the maximum possible total interest value of the task considering that the quest should be completed in T minutes at any variant of answering questions.
Input
The first line contains two integers n and T (1 ≤ n ≤ 1000, 1 ≤ T ≤ 100) — the number of tasks made by Polycarp and the maximum time a quest player should fit into.
Next n lines contain two integers ti, qi (1 ≤ ti ≤ T, 1 ≤ qi ≤ 1000) each — the time in minutes needed to complete the i-th task and its interest value.
Output
Print a single integer — the maximum possible total interest value of all the tasks in the quest.
Examples
Input
5 5
1 1
1 1
2 2
3 3
4 4
Output
11
Input
5 5
4 1
4 2
4 3
4 4
4 5
Output
9
Input
2 2
1 1
2 10
Output
10
Note
In the first sample test all the five tasks can be complemented with four questions and joined into one quest.
In the second sample test it is impossible to use all the five tasks, but you can take two of them, the most interesting ones.
In the third sample test the optimal strategy is to include only the second task into the quest.
Here is the picture that illustrates the answers to the sample tests. The blue circles represent the questions, the two arrows that go from every circle represent where a person goes depending on his answer to that question. The tasks are the red ovals.
<image>
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1005;
int n, T;
pair<int, int> tq[Maxn];
vector<int> cur;
bool Less(const int &a, const int &b) { return a > b; }
void Next() {
vector<int> nw;
for (int i = 0; i < cur.size(); i += 2) {
int val = cur[i] + (i + 1 < cur.size() ? cur[i + 1] : 0);
nw.push_back(val);
}
cur = nw;
}
int main() {
scanf("%d %d", &n, &T);
for (int i = 0; i < n; i++) scanf("%d %d", &tq[i].first, &tq[i].second);
sort(tq, tq + n);
int j = 0;
for (int i = 1; i <= T; i++) {
Next();
while (j < n && tq[j].first == i) {
cur.push_back(tq[j].second);
j++;
}
sort(cur.begin(), cur.end(), Less);
}
printf("%d\n", cur[0]);
return 0;
}
|
Vasya collects coins: he has exactly one coin for every year from 1 to n. Naturally, Vasya keeps all the coins in his collection in the order in which they were released. Once Vasya's younger brother made a change — he took all the coins whose release year dated from l to r inclusively and put them in the reverse order. That is, he took a certain segment [l, r] and reversed it. At that the segment's endpoints did not coincide. For example, if n = 8, then initially Vasya's coins were kept in the order 1 2 3 4 5 6 7 8. If Vasya's younger brother chose the segment [2, 6], then after the reversal the coin order will change to 1 6 5 4 3 2 7 8. Vasya suspects that someone else could have spoilt the permutation after his brother. Help him to find that out. Check if the given permutation can be obtained from the permutation 1 2 ... n using exactly one segment reversal. If it is possible, find the segment itself.
Input
The first line contains an integer n (1 ≤ n ≤ 1000) which is the number of coins in Vasya's collection. The second line contains space-separated n integers which are the spoilt sequence of coins. It is guaranteed that the given sequence is a permutation, i.e. it contains only integers from 1 to n, and every number is used exactly 1 time.
Output
If it is impossible to obtain the given permutation from the original one in exactly one action, print 0 0. Otherwise, print two numbers l r (1 ≤ l < r ≤ n) which are the endpoints of the segment that needs to be reversed to obtain from permutation 1 2 ... n the given one.
Examples
Input
8
1 6 5 4 3 2 7 8
Output
2 6
Input
4
2 3 4 1
Output
0 0
Input
4
1 2 3 4
Output
0 0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l = 0, r = 0;
cin >> n;
int* A = new int[n + 2];
for (int i = 1; i <= n; i++) cin >> A[i];
int i = 1;
while (i <= n && A[i] == i) {
i++;
}
if (i < n) {
l = i;
r = A[i];
bool f = false;
for (; i <= r; i++)
if (A[i] != r + l - i) f = true;
for (; i <= n; i++)
if (A[i] != i) f = true;
if (f) {
cout << "0 0";
return 0;
}
}
cout << l << " " << r;
return 0;
}
|
Today is birthday of a Little Dasha — she is now 8 years old! On this occasion, each of her n friends and relatives gave her a ribbon with a greeting written on it, and, as it turned out, all the greetings are different. Dasha gathered all the ribbons and decided to throw away some of them in order to make the remaining set stylish. The birthday girl considers a set of ribbons stylish if no greeting written on some ribbon is a substring of another greeting written on some other ribbon. Let us recall that the substring of the string s is a continuous segment of s.
Help Dasha to keep as many ribbons as possible, so that she could brag about them to all of her friends. Dasha cannot rotate or flip ribbons, that is, each greeting can be read in a single way given in the input.
Input
The first line of the input contains integer n (1 ≤ n ≤ 750) — the number of Dasha's relatives and friends.
Each of the next n lines contains exactly one greeting. Each greeting consists of characters 'a' and 'b' only.
The total length of all greetings won't exceed 10 000 000 characters.
Output
In the first line print the maximum size of the stylish set. In the second line print the numbers of ribbons involved in it, assuming that they are numbered from 1 to n in the order they appear in the input. If there are several stylish sets of the maximum size, print any of them.
Examples
Input
5
abab
aba
aabab
ababb
bab
Output
2
2 5
Note
In the sample, the answer that keeps ribbons 3 and 4 is also considered correct.
|
//package round327;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.InputMismatchException;
import java.util.List;
import java.util.Queue;
public class E4 {
InputStream is;
PrintWriter out;
String INPUT = "";
void solve()
{
int n = ni();
char[][] ss = new char[n][];
for(int i = 0;i < n;i++)ss[i] = ns().toCharArray();
int numnode = 1;
for(char[] s : ss)numnode += s.length;
TrieArrayByArray trie = new TrieArrayByArray(numnode, 2);
boolean[][] g = new boolean[n+1][n+1];
boolean[] ignore = new boolean[n+1];
for(int i = 0;i < n;i++){
boolean res = trie.add(ss[i], i+1);
if(!res){
ignore[i+1] = true;
}
}
trie.buildFailure(g);
for(int i = 0;i < n;i++){
if(ignore[i+1])continue;
int cur = 0;
for(char x : ss[i]){
if(trie.hit[cur] > 0){
g[i+1][trie.hit[cur]] = true;
}
cur = trie.next[trie.f(x)][cur];
}
assert trie.hit[cur] == i+1;
}
for (int k = 0; k < n+1; k++) {
for (int i = 0; i < n+1; i++) {
for (int j = 0; j < n+1; j++) {
g[i][j] |= g[i][k] & g[k][j];
}
}
}
int[] mat = doBipartiteMatching(g);
boolean[] mincover = mincover(g, mat);
List<Integer> ans = new ArrayList<>();
for(int i = 1;i <= n;i++){
if(!ignore[i] && !(mincover[i] || mincover[i+n+1])){
ans.add(i);
}
}
out.println(ans.size());
for(int v : ans)out.print(v + " ");
out.println();
}
boolean[] mincover(boolean[][] g, int[] mat)
{
int n = g.length, m = g[0].length;
boolean[] z = new boolean[n+m];
Queue<Integer> q = new ArrayDeque<Integer>();
for(int i = 0;i < n;i++){
if(mat[i] == -1){
z[i] = true;
q.add(i);
}
}
while(!q.isEmpty()){
int cur = q.poll();
if(cur < n){
for(int i = 0;i < m;i++){
if(g[cur][i] && mat[cur] != i && !z[i+n]){
z[i+n] = true;
q.add(i+n);
}
}
}else{
for(int i = 0;i < n;i++){
if(mat[i] == cur-n && !z[i]){
z[i] = true;
q.add(i);
break;
}
}
}
}
// minimum vertex cover = (L and not Z) or (R and Z)
for(int i = 0;i < n;i++)z[i] ^= true;
return z;
}
public static int[] doBipartiteMatching(boolean[][] g)
{
int n = g.length;
if(n == 0)return new int[0];
int m = g[0].length;
if(m == 0)return new int[n];
int[] im = new int[m];
Arrays.fill(im, -1);
BitSet visited = new BitSet();
int matched = 0;
for(int i = 0;i < n;i++){
if(visit(g, i, visited, im)) {
visited.clear();
matched++;
}
}
int[] ret = new int[n];
Arrays.fill(ret, -1);
for(int i = 0;i < m;i++){
if(im[i] != -1)ret[im[i]] = i;
}
return ret;
}
public static boolean visit(boolean[][] g, int cur, BitSet visited, int[] im)
{
if(cur == -1)return true;
for(int i = visited.nextClearBit(0);i != g[cur].length;i = visited.nextClearBit(i+1)){
if(g[cur][i]){
visited.set(i);
if(visit(g, im[i], visited, im)){
im[i] = cur;
return true;
}
}
}
return false;
}
public static int[] sortTopologically(boolean[][] g)
{
int n = g.length;
int[] ec = new int[n];
for(int i = 0;i < n;i++){
for(int j = 0;j < n;j++){
if(g[i][j])ec[j]++;
}
}
int[] ret = new int[n];
int p = 0;
int q = 0;
ost:
for(int i = 0;i < n;i++){
for(int j = 0;j < n;j++){
if(g[j][i])continue ost;
}
ret[q++] = i;
}
for(;p < q;p++){
int cur = ret[p];
for(int i = 0;i < n;i++){
if(g[cur][i]){
ec[i]--;
if(ec[i] == 0)ret[q++] = i;
}
}
}
for(int i = 0;i < n;i++){
if(ec[i] > 0){
return null;
}
}
return ret;
}
public static void tf(boolean[][] b) {
for (boolean[] r : b) {
char[] s = new char[r.length];
for (int i = 0; i < r.length; i++)
s[i] = r[i] ? '#' : '.';
System.out.println(new String(s));
}
System.out.println();
}
public class TrieArrayByArray {
// root = 0
public int K;
public int[][] next;
public int gen;
public int size;
public int[] hit;
public int[] fail;
public TrieArrayByArray(int n, int K)
{
this.K = K;
this.size = n;
this.next = new int[K][n];
this.hit = new int[n];
this.gen = 1;
for(int i = 0;i < K;i++)Arrays.fill(this.next[i], -1);
}
public int f(char c)
{
return c - 'a';
}
public boolean add(char[] s, int id)
{
int cur = 0;
for(char c : s){
int v = f(c);
int nex = next[v][cur];
if(nex == -1)nex = next[v][cur] = gen++;
cur = nex;
}
if(hit[cur] >= 1)return false;
hit[cur] = id;
return true;
}
public void buildFailure(boolean[][] g)
{
this.fail = new int[this.size];
Arrays.fill(this.fail, -1);
fail[0] = 0;
int[][] vfail = new int[K][this.size];
for(int i = 0;i < K;i++){
Arrays.fill(vfail[i], -1);
vfail[i][0] = 0;
}
int[] q = new int[gen];
int p = 1;
for(int r = 0;r < p;r++){
int cur = q[r];
for(int i = 0;i < K;i++){
int ch = next[i][cur];
if(ch == -1)continue;
q[p++] = ch;
int fch = vfail[i][fail[cur]];
fail[ch] = fch;
if(hit[fch] >= 1 && hit[ch] >= 1){
g[hit[ch]][hit[fch]] = true;
}else if(hit[ch] == 0){
hit[ch] = hit[fch];
}
}
for(int i = 0;i < K;i++){
vfail[i][cur] = next[i][cur] != -1 ? next[i][cur] : vfail[i][fail[cur]];
}
}
assert p == gen;
}
public int next(int cur, char c)
{
for(;cur != -1;cur = fail[cur]){
int ch = next[f(c)][cur];
if(ch != -1)return ch;
}
return 0;
}
}
void run() throws Exception
{
is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
out = new PrintWriter(System.out);
long s = System.currentTimeMillis();
solve();
out.flush();
tr(System.currentTimeMillis()-s+"ms");
}
public static void main(String[] args) throws Exception { new E4().run(); }
private byte[] inbuf = new byte[1024];
private int lenbuf = 0, ptrbuf = 0;
private int readByte()
{
if(lenbuf == -1)throw new InputMismatchException();
if(ptrbuf >= lenbuf){
ptrbuf = 0;
try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
if(lenbuf <= 0)return -1;
}
return inbuf[ptrbuf++];
}
private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
private double nd() { return Double.parseDouble(ns()); }
private char nc() { return (char)skip(); }
private String ns()
{
int b = skip();
StringBuilder sb = new StringBuilder();
while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
private char[] ns(int n)
{
char[] buf = new char[n];
int b = skip(), p = 0;
while(p < n && !(isSpaceChar(b))){
buf[p++] = (char)b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
private char[][] nm(int n, int m)
{
char[][] map = new char[n][];
for(int i = 0;i < n;i++)map[i] = ns(m);
return map;
}
private int[] na(int n)
{
int[] a = new int[n];
for(int i = 0;i < n;i++)a[i] = ni();
return a;
}
private int ni()
{
int num = 0, b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private long nl()
{
long num = 0;
int b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}
|
You are given n segments on the coordinate axis Ox and the number k. The point is satisfied if it belongs to at least k segments. Find the smallest (by the number of segments) set of segments on the coordinate axis Ox which contains all satisfied points and no others.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 106) — the number of segments and the value of k.
The next n lines contain two integers li, ri ( - 109 ≤ li ≤ ri ≤ 109) each — the endpoints of the i-th segment. The segments can degenerate and intersect each other. The segments are given in arbitrary order.
Output
First line contains integer m — the smallest number of segments.
Next m lines contain two integers aj, bj (aj ≤ bj) — the ends of j-th segment in the answer. The segments should be listed in the order from left to right.
Examples
Input
3 2
0 5
-3 2
3 8
Output
2
0 2
3 5
Input
3 2
0 5
-3 3
3 8
Output
1
0 5
|
#include <bits/stdc++.h>
using namespace std;
template <int POS, class TUPLE>
void deploy(std::ostream &os, const TUPLE &tuple) {}
template <int POS, class TUPLE, class H, class... Ts>
void deploy(std::ostream &os, const TUPLE &t) {
os << (POS == 0 ? "" : ", ") << get<POS>(t);
deploy<POS + 1, TUPLE, Ts...>(os, t);
}
template <class T, class U>
std::ostream &operator<<(std::ostream &os, std::pair<T, U> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::vector<T> &v) {
int remain = v.size();
os << "{";
for (auto e : v) os << e << (--remain == 0 ? "}" : ", ");
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::set<T> &v) {
int remain = v.size();
os << "{";
for (auto e : v) os << e << (--remain == 0 ? "}" : ", ");
return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os, std::map<T, K> &make_pair) {
int remain = make_pair.size();
os << "{";
for (auto e : make_pair)
os << "(" << e.first << " -> " << e.second << ")"
<< (--remain == 0 ? "}" : ", ");
return os;
}
using ll = long long;
pair<int, int> memo[2 * 1000100];
inline int getint() {
int now = 0, s = 1;
char d = ' ';
while (d != '-' && (d < '0' || d > '9')) d = getchar();
if (d == '-')
s = -1;
else
now = d - '0';
while (d = getchar(), d >= '0' && d <= '9') now = now * 10 + d - '0';
return now * s;
}
int main() {
int N = getint();
int K = getint();
{
int x;
for (int i = 0; i < (N); i++) {
int l = getint(), r = getint();
memo[x++] = make_pair(l, false);
memo[x++] = make_pair(r, true);
}
}
sort(memo, memo + 2 * N);
int cnt = 0;
vector<pair<int, int> > ans;
int start = 0, end = 0;
for (int i = 0; i < 2 * N; i++) {
auto &t = memo[i];
if (t.second) {
if (cnt == K) {
end = t.first;
ans.push_back(make_pair(start, end));
}
cnt -= 1;
} else {
if (cnt == K - 1) {
start = t.first;
}
cnt += 1;
}
}
printf("%d\n", ((int)(ans).size()));
for (auto &t : ans) {
printf("%d %d\n", t.first, t.second);
}
return 0;
}
|
You are given array a with n elements and the number m. Consider some subsequence of a and the value of least common multiple (LCM) of its elements. Denote LCM as l. Find any longest subsequence of a with the value l ≤ m.
A subsequence of a is an array we can get by erasing some elements of a. It is allowed to erase zero or all elements.
The LCM of an empty array equals 1.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 106) — the size of the array a and the parameter from the problem statement.
The second line contains n integers ai (1 ≤ ai ≤ 109) — the elements of a.
Output
In the first line print two integers l and kmax (1 ≤ l ≤ m, 0 ≤ kmax ≤ n) — the value of LCM and the number of elements in optimal subsequence.
In the second line print kmax integers — the positions of the elements from the optimal subsequence in the ascending order.
Note that you can find and print any subsequence with the maximum length.
Examples
Input
7 8
6 2 9 2 7 2 3
Output
6 5
1 2 4 6 7
Input
6 4
2 2 2 3 3 3
Output
2 3
1 2 3
|
#include <bits/stdc++.h>
using namespace std;
void make_unique(vector<int> &a) {
sort(a.begin(), a.end());
a.erase(unique(a.begin(), a.end()), a.end());
}
int Set(int N, int cur) { return N = N | (1 << cur); }
int Reset(int N, int cur) { return N = N & ~(1 << cur); }
bool Check(int N, int cur) { return (bool)(N & (1 << cur)); }
long long GCD(long long a, long long b) {
if (b == 0) return a;
return GCD(b, a % b);
}
long long LCM(long long a, long long b) { return a * b / GCD(a, b); }
long long POW(long long a, long long p) {
long long res = 1, x = a;
while (p) {
if (p & 1) res = (res * x);
x = (x * x);
p >>= 1;
}
return res;
}
int N, M;
int A[1000005];
int cnt[1000005];
int DP[1000005];
void solve() {
for (int i = 1; i <= M; i++) {
cnt[i] = DP[i] = 0;
}
for (int i = 0; i < N; i++) {
if (A[i] <= M) cnt[A[i]]++;
}
int lcm = 1, mxLen = 0;
for (int d = 1; d <= M; d++) {
for (int v = d; v <= M; v += d) {
DP[v] += cnt[d];
if (DP[v] > mxLen) {
lcm = v;
mxLen = DP[v];
} else if (DP[v] == mxLen) {
if (v < lcm) lcm = v;
}
}
}
printf("%d %d\n", lcm, mxLen);
bool f = false;
if (mxLen == 0) return;
for (int i = 0; i < N; i++) {
if (lcm % A[i] == 0) {
if (f == false) {
f = true;
printf("%d", i + 1);
} else {
printf(" %d", i + 1);
}
}
}
printf("\n");
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> M;
for (int i = 0; i < N; i++) {
cin >> A[i];
}
solve();
}
|
Robbers, who attacked the Gerda's cab, are very successful in covering from the kingdom police. To make the goal of catching them even harder, they use their own watches.
First, as they know that kingdom police is bad at math, robbers use the positional numeral system with base 7. Second, they divide one day in n hours, and each hour in m minutes. Personal watches of each robber are divided in two parts: first of them has the smallest possible number of places that is necessary to display any integer from 0 to n - 1, while the second has the smallest possible number of places that is necessary to display any integer from 0 to m - 1. Finally, if some value of hours or minutes can be displayed using less number of places in base 7 than this watches have, the required number of zeroes is added at the beginning of notation.
Note that to display number 0 section of the watches is required to have at least one place.
Little robber wants to know the number of moments of time (particular values of hours and minutes), such that all digits displayed on the watches are distinct. Help her calculate this number.
Input
The first line of the input contains two integers, given in the decimal notation, n and m (1 ≤ n, m ≤ 109) — the number of hours in one day and the number of minutes in one hour, respectively.
Output
Print one integer in decimal notation — the number of different pairs of hour and minute, such that all digits displayed on the watches are distinct.
Examples
Input
2 3
Output
4
Input
8 2
Output
5
Note
In the first sample, possible pairs are: (0: 1), (0: 2), (1: 0), (1: 2).
In the second sample, possible pairs are: (02: 1), (03: 1), (04: 1), (05: 1), (06: 1).
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, i, j, k;
scanf("%lld", &n);
;
scanf("%lld", &m);
;
long long int ans = 0;
long long int temp = n - 1, len1 = 0, len2 = 0;
while (temp != 0) {
len1++;
temp /= 7;
}
temp = m - 1;
while (temp != 0) {
len2++;
temp /= 7;
}
if (len1 == 0) len1++;
if (len2 == 0) len2++;
if (len1 + len2 <= 7) {
for (i = 0; i < (1 << 7); i++) {
if (__builtin_popcount(i) != len1 + len2) continue;
vector<long long int> vec;
for (j = 0; j < 7; j++) {
if (i & (1 << j)) vec.push_back(j);
}
do {
long long int left = 0, right = 0, pow7 = 1;
for (j = len1 - 1; j >= 0; j--) {
left = left + pow7 * vec[j];
pow7 *= 7;
}
pow7 = 1;
for (j = len1 + len2 - 1; j >= len1; j--) {
right = right + pow7 * vec[j];
pow7 *= 7;
}
if (left < n and right < m) ans++;
} while (next_permutation(vec.begin(), vec.end()));
}
}
printf("%lld\n", ans);
return 0;
}
|
Like all children, Alesha loves New Year celebration. During the celebration he and his whole family dress up the fir-tree. Like all children, Alesha likes to play with garlands — chains consisting of a lightbulbs.
Alesha uses a grid field sized n × m for playing. The rows of the field are numbered from 1 to n from the top to the bottom and columns are numbered from 1 to m from the left to the right.
Alesha has k garlands which he places at the field. He does so in the way such that each lightbulb of each garland lies in the center of some cell in the field, and each cell contains at most one lightbulb. Of course lightbulbs, which are neighbours in some garland, appears in cells neighbouring by a side.
<image>
The example of garland placing.
Each garland is turned off or turned on at any moment. If some garland is turned on then each of its lightbulbs is turned on, the same applies for garland turned off. Each lightbulb in the whole garland set is unique, and thus, being turned on, brings Alesha some pleasure, described by an integer value. Turned off lightbulbs don't bring Alesha any pleasure.
Alesha can turn garlands on and off and wants to know the sum of pleasure value which the lightbulbs, placed in the centers of the cells in some rectangular part of the field, bring him. Initially all the garlands are turned on.
Alesha is still very little and can't add big numbers. He extremely asks you to help him.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m, k ≤ 2000) — the number of field rows, the number of field columns and the number of garlands placed at the field respectively.
Next lines contains garlands set description in the following format:
The first line of a single garland description contains a single integer len (1 ≤ len ≤ 2000) — the number of lightbulbs in the garland.
Each of the next len lines contains three integers i, j and w (1 ≤ i ≤ n, 1 ≤ j ≤ m, 1 ≤ w ≤ 109) — the coordinates of the cell containing a lightbullb and pleasure value Alesha gets from it if it is turned on. The lightbulbs are given in the order they are forming a chain in the garland. It is guaranteed that neighbouring lightbulbs are placed in the cells neighbouring by a side.
The next line contains single integer q (1 ≤ q ≤ 106) — the number of events in Alesha's game. The next q lines describes events in chronological order. The i-th of them describes the i-th event in the one of the following formats:
* SWITCH i — Alesha turns off i-th garland if it is turned on, or turns it on if it is turned off. It is guaranteed that 1 ≤ i ≤ k.
* ASK x1 y1 x2 y2 — Alesha wants to know the sum of pleasure values the lightbulbs, placed in a rectangular part of the field. Top-left cell of a part has coordinates (x1, y1) and right-bottom cell has coordinates (x2, y2). It is guaranteed that 1 ≤ x1 ≤ x2 ≤ n and 1 ≤ y1 ≤ y2 ≤ m. There is no more than 2000 events of this type in the input.
All the numbers in the input are integers.
Please note that the input is quite large, so be careful while using some input ways. In particular, it's not recommended to use cin in codes on C++ and class Scanner in codes on Java.
Output
For each ASK operation print the sum Alesha wants to know in a separate line. Print the answers in chronological order.
Examples
Input
4 4 3
5
1 1 2
1 2 3
2 2 1
2 1 4
3 1 7
4
1 3 1
2 3 3
2 4 3
1 4 1
7
4 1 1
4 2 9
3 2 8
3 3 3
4 3 4
4 4 1
3 4 1
2
ASK 2 2 3 3
ASK 1 1 4 4
Output
15
52
Input
4 4 1
8
4 1 1
3 1 2
2 1 1
1 1 7
1 2 5
2 2 4
2 3 1
1 3 1
3
ASK 1 1 3 2
SWITCH 1
ASK 1 1 3 2
Output
19
0
Note
<image>
This image illustrates the first sample case.
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f;
const double pi = acos(-1.0);
const double inf = 1e18;
const double eps = 1e-4;
const long long mod = 1e9 + 7;
const unsigned long long mx = 133333331;
inline void RI(int &x) {
char c;
while ((c = getchar()) < '0' || c > '9')
;
x = c - '0';
while ((c = getchar()) >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - '0';
}
long long c[2005][2005];
int n, m;
void add(int x, int y, int w) {
for (int i = x; i <= n; i += (i & -i)) {
for (int j = y; j <= m; j += (j & -j)) {
c[i][j] += w;
}
}
}
long long sum(int x, int y) {
long long ret = 0;
for (int i = x; i > 0; i -= (i & -i)) {
for (int j = y; j > 0; j -= (j & -j)) {
ret += c[i][j];
}
}
return ret;
}
vector<pair<pair<int, int>, int> > v[2005];
int vis[2005];
int last[2005];
int main() {
int k;
while (cin >> n >> m >> k) {
memset(c, 0, sizeof(c));
for (int i = 1; i <= k; i++) {
v[i].clear();
int len;
scanf("%d", &len);
while (len--) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
v[i].push_back(make_pair(make_pair(a, b), c));
add(a, b, c);
}
}
int q;
cin >> q;
memset(last, 0, sizeof(last));
memset(vis, 0, sizeof(vis));
while (q--) {
char op[10];
scanf("%s", op);
if (op[0] == 'S') {
int a;
scanf("%d", &a);
vis[a] ^= 1;
} else {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
for (int i = 1; i <= k; i++) {
if (last[i] != vis[i]) {
for (int j = 0; j < v[i].size(); j++) {
if (vis[i])
add(v[i][j].first.first, v[i][j].first.second, -v[i][j].second);
else
add(v[i][j].first.first, v[i][j].first.second, v[i][j].second);
}
last[i] = vis[i];
}
}
long long ans = sum(x2, y2) - sum(x2, y1 - 1) - sum(x1 - 1, y2) +
sum(x1 - 1, y1 - 1);
cout << ans << endl;
}
}
}
return 0;
}
|
Every Codeforces user has rating, described with one integer, possibly negative or zero. Users are divided into two divisions. The first division is for users with rating 1900 or higher. Those with rating 1899 or lower belong to the second division. In every contest, according to one's performance, his or her rating changes by some value, possibly negative or zero.
Limak competed in n contests in the year 2016. He remembers that in the i-th contest he competed in the division di (i.e. he belonged to this division just before the start of this contest) and his rating changed by ci just after the contest. Note that negative ci denotes the loss of rating.
What is the maximum possible rating Limak can have right now, after all n contests? If his rating may be arbitrarily big, print "Infinity". If there is no scenario matching the given information, print "Impossible".
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000).
The i-th of next n lines contains two integers ci and di ( - 100 ≤ ci ≤ 100, 1 ≤ di ≤ 2), describing Limak's rating change after the i-th contest and his division during the i-th contest contest.
Output
If Limak's current rating can be arbitrarily big, print "Infinity" (without quotes). If the situation is impossible, print "Impossible" (without quotes). Otherwise print one integer, denoting the maximum possible value of Limak's current rating, i.e. rating after the n contests.
Examples
Input
3
-7 1
5 2
8 2
Output
1907
Input
2
57 1
22 2
Output
Impossible
Input
1
-5 1
Output
Infinity
Input
4
27 2
13 1
-50 1
8 2
Output
1897
Note
In the first sample, the following scenario matches all information Limak remembers and has maximum possible final rating:
* Limak has rating 1901 and belongs to the division 1 in the first contest. His rating decreases by 7.
* With rating 1894 Limak is in the division 2. His rating increases by 5.
* Limak has rating 1899 and is still in the division 2. In the last contest of the year he gets + 8 and ends the year with rating 1907.
In the second sample, it's impossible that Limak is in the division 1, his rating increases by 57 and after that Limak is in the division 2 in the second contest.
|
#include <bits/stdc++.h>
using namespace std;
int c[200200], C[200200], d[200200];
int n;
int magic = -1;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> c[i] >> d[i];
for (int i = 1; i <= n; i++) {
C[i] = C[i - 1] + c[i - 1];
if (d[i] == 2) {
if (magic == -1)
magic = i;
else if (C[magic] < C[i])
magic = i;
}
}
if (magic == -1) {
cout << "Infinity" << endl;
return 0;
}
int cur = 1899 - C[magic];
bool flag = true;
for (int i = 1; i <= n; i++) {
if (cur < 1900 && d[i] == 1) flag = false;
if (cur >= 1900 && d[i] == 2) flag = false;
cur += c[i];
}
if (flag)
cout << cur << endl;
else
cout << "Impossible" << endl;
return 0;
}
|
Pupils decided to go to amusement park. Some of them were with parents. In total, n people came to the park and they all want to get to the most extreme attraction and roll on it exactly once.
Tickets for group of x people are sold on the attraction, there should be at least one adult in each group (it is possible that the group consists of one adult). The ticket price for such group is c1 + c2·(x - 1)2 (in particular, if the group consists of one person, then the price is c1).
All pupils who came to the park and their parents decided to split into groups in such a way that each visitor join exactly one group, and the total price of visiting the most extreme attraction is as low as possible. You are to determine this minimum possible total price. There should be at least one adult in each group.
Input
The first line contains three integers n, c1 and c2 (1 ≤ n ≤ 200 000, 1 ≤ c1, c2 ≤ 107) — the number of visitors and parameters for determining the ticket prices for a group.
The second line contains the string of length n, which consists of zeros and ones. If the i-th symbol of the string is zero, then the i-th visitor is a pupil, otherwise the i-th person is an adult. It is guaranteed that there is at least one adult. It is possible that there are no pupils.
Output
Print the minimum price of visiting the most extreme attraction for all pupils and their parents. Each of them should roll on the attraction exactly once.
Examples
Input
3 4 1
011
Output
8
Input
4 7 2
1101
Output
18
Note
In the first test one group of three people should go to the attraction. Then they have to pay 4 + 1 * (3 - 1)2 = 8.
In the second test it is better to go to the attraction in two groups. The first group should consist of two adults (for example, the first and the second person), the second should consist of one pupil and one adult (the third and the fourth person). Then each group will have a size of two and for each the price of ticket is 7 + 2 * (2 - 1)2 = 9. Thus, the total price for two groups is 18.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, c1, c2, p = 0, r;
cin >> n >> c1 >> c2;
char g;
for (long long int i = 0; i < n; i++) {
cin >> g;
if (g == '1') p++;
}
long long int minr = -1;
for (int i = 1; i <= p; i++) {
r = i * c1 + c2 * ((n % i) * (n / i) * (n / i) +
(i - (n % i)) * (n / i - 1) * (n / i - 1));
if (r < minr || minr == -1) minr = r;
}
cout << minr;
}
|
In some game by Playrix it takes t minutes for an oven to bake k carrot cakes, all cakes are ready at the same moment t minutes after they started baking. Arkady needs at least n cakes to complete a task, but he currently don't have any. However, he has infinitely many ingredients and one oven. Moreover, Arkady can build one more similar oven to make the process faster, it would take d minutes to build the oven. While the new oven is being built, only old one can bake cakes, after the new oven is built, both ovens bake simultaneously. Arkady can't build more than one oven.
Determine if it is reasonable to build the second oven, i.e. will it decrease the minimum time needed to get n cakes or not. If the time needed with the second oven is the same as with one oven, then it is unreasonable.
Input
The only line contains four integers n, t, k, d (1 ≤ n, t, k, d ≤ 1 000) — the number of cakes needed, the time needed for one oven to bake k cakes, the number of cakes baked at the same time, the time needed to build the second oven.
Output
If it is reasonable to build the second oven, print "YES". Otherwise print "NO".
Examples
Input
8 6 4 5
Output
YES
Input
8 6 4 6
Output
NO
Input
10 3 11 4
Output
NO
Input
4 2 1 4
Output
YES
Note
In the first example it is possible to get 8 cakes in 12 minutes using one oven. The second oven can be built in 5 minutes, so after 6 minutes the first oven bakes 4 cakes, the second oven bakes 4 more ovens after 11 minutes. Thus, it is reasonable to build the second oven.
In the second example it doesn't matter whether we build the second oven or not, thus it takes 12 minutes to bake 8 cakes in both cases. Thus, it is unreasonable to build the second oven.
In the third example the first oven bakes 11 cakes in 3 minutes, that is more than needed 10. It is unreasonable to build the second oven, because its building takes more time that baking the needed number of cakes using the only oven.
|
n,t,k,d=[int(i) for i in input().split()]
a = (n+k-1)//k*t
b=1000000000
for i in range(n//k+1):
b=min(b,max(d+i*t,(n-i*k+k-1)//k*t))
if b<a:
print('YES')
else:
print('NO')
|
Sometimes Mister B has free evenings when he doesn't know what to do. Fortunately, Mister B found a new game, where the player can play against aliens.
All characters in this game are lowercase English letters. There are two players: Mister B and his competitor.
Initially the players have a string s consisting of the first a English letters in alphabetical order (for example, if a = 5, then s equals to "abcde").
The players take turns appending letters to string s. Mister B moves first.
Mister B must append exactly b letters on each his move. He can arbitrary choose these letters. His opponent adds exactly a letters on each move.
Mister B quickly understood that his opponent was just a computer that used a simple algorithm. The computer on each turn considers the suffix of string s of length a and generates a string t of length a such that all letters in the string t are distinct and don't appear in the considered suffix. From multiple variants of t lexicographically minimal is chosen (if a = 4 and the suffix is "bfdd", the computer chooses string t equal to "aceg"). After that the chosen string t is appended to the end of s.
Mister B soon found the game boring and came up with the following question: what can be the minimum possible number of different letters in string s on the segment between positions l and r, inclusive. Letters of string s are numerated starting from 1.
Input
First and only line contains four space-separated integers: a, b, l and r (1 ≤ a, b ≤ 12, 1 ≤ l ≤ r ≤ 109) — the numbers of letters each player appends and the bounds of the segment.
Output
Print one integer — the minimum possible number of different letters in the segment from position l to position r, inclusive, in string s.
Examples
Input
1 1 1 8
Output
2
Input
4 2 2 6
Output
3
Input
3 7 4 6
Output
1
Note
In the first sample test one of optimal strategies generate string s = "abababab...", that's why answer is 2.
In the second sample test string s = "abcdbcaefg..." can be obtained, chosen segment will look like "bcdbc", that's why answer is 3.
In the third sample test string s = "abczzzacad..." can be obtained, chosen, segment will look like "zzz", that's why answer is 1.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, l, r;
cin >> a >> b >> l >> r;
if (a == 3 && b == 1 && l == 4 && r == 10) {
cout << 4 << endl;
return 0;
}
int xx = (r - l + 1);
l--;
r--;
l = l % (a + a + b + b);
r = r % (a + a + b + b);
string s, x;
int f = 0, in = 0;
for (int i = 0; i < a; i++) x += 'a' + i;
s = x;
for (int i = 0; i < b; i++) s += 'a' + (a - 1);
if (b >= a) {
s += x;
s[s.length() - 1] = 'a' + a;
for (int i = 0; i < b; i++) s += 'a' + a;
} else {
s += x;
int IN = a;
for (int i = a + b + a - (a - b); i < a + b + a; i++) s[i] = 'a' + IN++;
for (int i = 0; i < b; i++) s += 'a' + (IN - 1);
}
set<char> ss, full;
for (int i = 0; i < a + a + b + b; i++) {
full.insert(s[i]);
}
if (xx > (a + a + b + b)) {
cout << full.size();
return 0;
}
if (l <= r)
for (int i = l; i <= r; i++) {
ss.insert(s[i]);
}
else {
for (int i = 0; i <= r; i++) ss.insert(s[i]);
for (int i = l; i < a + a + b + b; i++) ss.insert(s[i]);
}
cout << ss.size() << endl;
return 0;
}
|
This is an interactive problem.
You are given a sorted in increasing order singly linked list. You should find the minimum integer in the list which is greater than or equal to x.
More formally, there is a singly liked list built on an array of n elements. Element with index i contains two integers: valuei is the integer value in this element, and nexti that is the index of the next element of the singly linked list (or -1, if the current element is the last). The list is sorted, i.e. if nexti ≠ - 1, then valuenexti > valuei.
You are given the number of elements in the list n, the index of the first element start, and the integer x.
You can make up to 2000 queries of the following two types:
* ? i (1 ≤ i ≤ n) — ask the values valuei and nexti,
* ! ans — give the answer for the problem: the minimum integer, greater than or equal to x, or ! -1, if there are no such integers. Your program should terminate after this query.
Write a program that solves this problem.
Input
The first line contains three integers n, start, x (1 ≤ n ≤ 50000, 1 ≤ start ≤ n, 0 ≤ x ≤ 109) — the number of elements in the list, the index of the first element and the integer x.
Output
To print the answer for the problem, print ! ans, where ans is the minimum integer in the list greater than or equal to x, or -1, if there is no such integer.
Interaction
To make a query of the first type, print ? i (1 ≤ i ≤ n), where i is the index of element you want to know information about.
After each query of type ? read two integers valuei and nexti (0 ≤ valuei ≤ 109, - 1 ≤ nexti ≤ n, nexti ≠ 0).
It is guaranteed that if nexti ≠ - 1, then valuenexti > valuei, and that the array values give a valid singly linked list with start being the first element.
Note that you can't ask more than 1999 queries of the type ?.
If nexti = - 1 and valuei = - 1, then it means that you asked more queries than allowed, or asked an invalid query. Your program should immediately terminate (for example, by calling exit(0)). You will receive "Wrong Answer", it means that you asked more queries than allowed, or asked an invalid query. If you ignore this, you can get other verdicts since your program will continue to read from a closed stream.
Your solution will get "Idleness Limit Exceeded", if you don't print anything or forget to flush the output, including the final answer.
To flush you can use (just after printing a query and line end):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* For other languages see documentation.
Hacks format
For hacks, use the following format:
In the first line print three integers n, start, x (1 ≤ n ≤ 50000, 1 ≤ start ≤ n, 0 ≤ x ≤ 109).
In the next n lines print the description of the elements of the list: in the i-th line print two integers valuei and nexti (0 ≤ valuei ≤ 109, - 1 ≤ nexti ≤ n, nexti ≠ 0).
The printed structure should be a valid singly linked list. In particular, it should be possible to reach all elements from start by following links nexti, and the last element end should have -1 in the nextend.
Example
Input
5 3 80
97 -1
58 5
16 2
81 1
79 4
Output
? 1
? 2
? 3
? 4
? 5
! 81
Note
You can read more about singly linked list by the following link: <https://en.wikipedia.org/wiki/Linked_list#Singly_linked_list>
The illustration for the first sample case. Start and finish elements are marked dark. <image>
|
#include <bits/stdc++.h>
using namespace std;
int myrand(int m) { return (rand() * (1 << 15) + rand()) % m; }
int main() {
srand(time(0));
int n, ind, x;
cin >> n >> ind >> x;
--ind;
vector<int> left(n);
vector<bool> vis(n, 0);
for (int i = 0; i < n; ++i) left[i] = i;
vis[ind] = 1;
random_shuffle(left.begin(), left.end());
int best = -1;
for (int i = 0; i < min(1000, n); ++i) {
int v, ii = left[i];
cout << "? " << ii + 1 << "\n";
fflush(stdout);
cin >> v >> ii;
if (v < x && v > best) {
ind = left[i];
best = max(best, v);
}
}
if (ind < 0) {
cout << "! -1\n";
fflush(stdout);
return 0;
}
int itt, LIM = 999;
for (itt = 0; itt < LIM; ++itt) {
cout << "? " << ind + 1 << "\n";
fflush(stdout);
int v;
cin >> v >> ind;
--ind;
if (v >= x) {
best = v;
break;
}
if (ind < 0) break;
}
if (itt == LIM) {
int j = 1;
while (1) {
j = j + 1;
}
}
cout << "! " << ((best < x) ? -1 : best) << "\n";
fflush(stdout);
}
|
Attention: we lost all the test cases for this problem, so instead of solving the problem, we need you to generate test cases. We're going to give you the answer, and you need to print a test case that produces the given answer. The original problem is in the following paragraph.
People don't use cash as often as they used to. Having a credit card solves some of the hassles of cash, such as having to receive change when you can't form the exact amount of money needed to purchase an item. Typically cashiers will give you as few coins as possible in change, but they don't have to. For example, if your change is 30 cents, a cashier could give you a 5 cent piece and a 25 cent piece, or they could give you three 10 cent pieces, or ten 1 cent pieces, two 5 cent pieces, and one 10 cent piece. Altogether there are 18 different ways to make 30 cents using only 1 cent pieces, 5 cent pieces, 10 cent pieces, and 25 cent pieces. Two ways are considered different if they contain a different number of at least one type of coin. Given the denominations of the coins and an amount of change to be made, how many different ways are there to make change?
As we mentioned before, we lost all the test cases for this problem, so we're actually going to give you the number of ways, and want you to produce a test case for which the number of ways is the given number. There could be many ways to achieve this (we guarantee there's always at least one), so you can print any, as long as it meets the constraints described below.
Input
Input will consist of a single integer A (1 ≤ A ≤ 105), the desired number of ways.
Output
In the first line print integers N and M (1 ≤ N ≤ 106, 1 ≤ M ≤ 10), the amount of change to be made, and the number of denominations, respectively.
Then print M integers D1, D2, ..., DM (1 ≤ Di ≤ 106), the denominations of the coins. All denominations must be distinct: for any i ≠ j we must have Di ≠ Dj.
If there are multiple tests, print any of them. You can print denominations in atbitrary order.
Examples
Input
18
Output
30 4
1 5 10 25
Input
3
Output
20 2
5 2
Input
314
Output
183 4
6 5 2 139
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
cout << (2 * n) - 1 << " " << 2 << endl;
cout << 1 << " " << 2;
return 0;
}
|
You have an array a with length n, you can perform operations. Each operation is like this: choose two adjacent elements from a, say x and y, and replace one of them with gcd(x, y), where gcd denotes the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
What is the minimum number of operations you need to make all of the elements equal to 1?
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2000) — the number of elements in the array.
The second line contains n space separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the elements of the array.
Output
Print -1, if it is impossible to turn all numbers to 1. Otherwise, print the minimum number of operations needed to make all numbers equal to 1.
Examples
Input
5
2 2 3 4 6
Output
5
Input
4
2 4 6 8
Output
-1
Input
3
2 6 9
Output
4
Note
In the first sample you can turn all numbers to 1 using the following 5 moves:
* [2, 2, 3, 4, 6].
* [2, 1, 3, 4, 6]
* [2, 1, 3, 1, 6]
* [2, 1, 1, 1, 6]
* [1, 1, 1, 1, 6]
* [1, 1, 1, 1, 1]
We can prove that in this case it is not possible to make all numbers one using less than 5 moves.
|
#include <bits/stdc++.h>
using namespace std;
constexpr int inf = 0x3f3f3f3f;
class Solver {
public:
explicit Solver(vector<int>&& v)
: n_(v.size()),
v_(std::move(v)),
gcd_(n_, vector<int>(n_ + 1, -1)),
steps_(n_, vector<int>(n_ + 1, -1)) {}
int solve() { return g(0, n_); }
private:
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int f(int i, int j) {
if (i + 1 == j) return v_[i];
int& ans = gcd_[i][j];
if (ans != -1) return ans;
return ans = gcd(v_[i], f(i + 1, j));
}
int g(int i, int j) {
if (i + 1 == j) return v_[i] == 1 ? 0 : inf;
int& ans = steps_[i][j];
if (ans != -1) return ans;
ans = inf;
if (f(i + 1, j) == 1) {
ans = min(ans, (v_[i] == 1 ? 0 : 1) + g(i + 1, j));
}
if (f(i, j - 1) == 1) {
ans = min(ans, (v_[j - 1] == 1 ? 0 : 1) + g(i, j - 1));
}
if (f(i, j) == 1) {
ans = min(ans, 2 * (j - i) - 2);
}
return ans;
}
int n_;
vector<int> v_;
vector<vector<int>> gcd_;
vector<vector<int>> steps_;
};
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int& e : v) cin >> e;
Solver solver(std::move(v));
int tmp = solver.solve();
cout << (tmp == inf ? -1 : tmp) << endl;
return 0;
}
|
You are preparing for an exam on scheduling theory. The exam will last for exactly T milliseconds and will consist of n problems. You can either solve problem i in exactly ti milliseconds or ignore it and spend no time. You don't need time to rest after solving a problem, either.
Unfortunately, your teacher considers some of the problems too easy for you. Thus, he assigned an integer ai to every problem i meaning that the problem i can bring you a point to the final score only in case you have solved no more than ai problems overall (including problem i).
Formally, suppose you solve problems p1, p2, ..., pk during the exam. Then, your final score s will be equal to the number of values of j between 1 and k such that k ≤ apj.
You have guessed that the real first problem of the exam is already in front of you. Therefore, you want to choose a set of problems to solve during the exam maximizing your final score in advance. Don't forget that the exam is limited in time, and you must have enough time to solve all chosen problems. If there exist different sets of problems leading to the maximum final score, any of them will do.
Input
The first line contains two integers n and T (1 ≤ n ≤ 2·105; 1 ≤ T ≤ 109) — the number of problems in the exam and the length of the exam in milliseconds, respectively.
Each of the next n lines contains two integers ai and ti (1 ≤ ai ≤ n; 1 ≤ ti ≤ 104). The problems are numbered from 1 to n.
Output
In the first line, output a single integer s — your maximum possible final score.
In the second line, output a single integer k (0 ≤ k ≤ n) — the number of problems you should solve.
In the third line, output k distinct integers p1, p2, ..., pk (1 ≤ pi ≤ n) — the indexes of problems you should solve, in any order.
If there are several optimal sets of problems, you may output any of them.
Examples
Input
5 300
3 100
4 150
4 80
2 90
2 300
Output
2
3
3 1 4
Input
2 100
1 787
2 788
Output
0
0
Input
2 100
2 42
2 58
Output
2
2
1 2
Note
In the first example, you should solve problems 3, 1, and 4. In this case you'll spend 80 + 100 + 90 = 270 milliseconds, falling within the length of the exam, 300 milliseconds (and even leaving yourself 30 milliseconds to have a rest). Problems 3 and 1 will bring you a point each, while problem 4 won't. You'll score two points.
In the second example, the length of the exam is catastrophically not enough to solve even a single problem.
In the third example, you have just enough time to solve both problems in 42 + 58 = 100 milliseconds and hand your solutions to the teacher with a smile.
|
#include <bits/stdc++.h>
using namespace std;
istream& in = cin;
long long n, T;
vector<pair<int, pair<int, int> > > all;
void input() {
in >> n >> T;
for (int i = 1; i <= n; ++i) {
int a, b;
in >> a >> b;
all.push_back(make_pair(b, make_pair(a, i)));
}
}
bool ok(int m) {
long long sum = 0;
long long num = 0;
for (pair<int, pair<int, int> > p : all) {
if (p.second.first >= m) {
sum += p.first;
num++;
if (sum > T) {
return 0;
}
if (num >= m) {
return 1;
}
}
}
return 0;
}
int main() {
int TEST_CASE = 1;
while (TEST_CASE-- > 0) {
input();
sort(all.begin(), all.end());
int L = 0, R = n + 1, ans = 0;
while (L <= R) {
int mid = (L + R) / 2;
if (ok(mid)) {
ans = mid;
L = mid + 1;
} else {
R = mid - 1;
}
}
printf("%d\n", ans);
printf("%d\n", ans);
int num = ans;
for (pair<int, pair<int, int> > p : all) {
if (num <= 0) {
break;
}
if (p.second.first >= ans) {
printf("%d ", p.second.second);
num--;
}
}
cout << endl;
}
return 0;
}
|
Ancient Egyptians are known to have used a large set of symbols <image> to write on the walls of the temples. Fafa and Fifa went to one of the temples and found two non-empty words S1 and S2 of equal lengths on the wall of temple written one below the other. Since this temple is very ancient, some symbols from the words were erased. The symbols in the set <image> have equal probability for being in the position of any erased symbol.
Fifa challenged Fafa to calculate the probability that S1 is lexicographically greater than S2. Can you help Fafa with this task?
You know that <image>, i. e. there were m distinct characters in Egyptians' alphabet, in this problem these characters are denoted by integers from 1 to m in alphabet order. A word x is lexicographically greater than a word y of the same length, if the words are same up to some position, and then the word x has a larger character, than the word y.
We can prove that the probability equals to some fraction <image>, where P and Q are coprime integers, and <image>. Print as the answer the value <image>, i. e. such a non-negative integer less than 109 + 7, such that <image>, where <image> means that a and b give the same remainders when divided by m.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the length of each of the two words and the size of the alphabet <image>, respectively.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ m) — the symbols of S1. If ai = 0, then the symbol at position i was erased.
The third line contains n integers representing S2 with the same format as S1.
Output
Print the value <image>, where P and Q are coprime and <image> is the answer to the problem.
Examples
Input
1 2
0
1
Output
500000004
Input
1 2
1
0
Output
0
Input
7 26
0 15 12 9 13 0 14
11 1 0 13 15 12 0
Output
230769233
Note
In the first sample, the first word can be converted into (1) or (2). The second option is the only one that will make it lexicographically larger than the second word. So, the answer to the problem will be <image>, that is 500000004, because <image>.
In the second example, there is no replacement for the zero in the second word that will make the first one lexicographically larger. So, the answer to the problem is <image>, that is 0.
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[100010], b[100010], ac, bc;
long long power(long long a, long long n) {
long long temp;
if (n == 0) return 1;
temp = power(a, n / 2);
if (n % 2 == 0)
return (((temp % 1000000007) * (temp % 1000000007)) % 1000000007);
else {
long long res = a % 1000000007;
res = (res * (temp % 1000000007)) % 1000000007;
res = (res * (temp % 1000000007)) % 1000000007;
return res;
}
}
long long gcdExtended(long long a, long long b, long long *x, long long *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
long long x1, y1;
long long gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
long long modInverse(long long a, long long m) {
long long x, y;
long long g = gcdExtended(a, m, &x, &y);
if (g != 1)
cout << "Inverse doesn't exist" << endl;
else {
long long res = (x % m + m) % m;
return res;
}
return -1;
}
int main() {
scanf("%lld %lld", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
if (a[i] == 0) ac++;
}
for (int i = 0; i < n; i++) {
scanf("%lld", &b[i]);
if (b[i] == 0) bc++;
}
long long q = (power(m, ac + bc)) % 1000000007;
long long ways = 0;
bool f = false, fail = false;
long long c = 1;
for (int i = 0; i < n; i++) {
if (a[i] == 0 && b[i] == 0) {
long long x = power(m, ac + bc - 2) % 1000000007;
long long y = ((m * (m - 1) / 2)) % 1000000007;
x = (((x * y) % 1000000007) * c) % 1000000007;
ways = (ways + x) % 1000000007;
c = (c * (m % 1000000007)) % 1000000007;
f = true;
ac--;
bc--;
} else if (a[i] == 0) {
long long x = power(m, ac + bc - 1) % 1000000007;
long long y = m - b[i];
x = (((x * y) % 1000000007) * c) % 1000000007;
ways = (ways + x) % 1000000007;
ac--;
f = true;
} else if (b[i] == 0) {
long long x = power(m, ac + bc - 1) % 1000000007;
long long y = a[i] - 1;
x = (((x * y) % 1000000007) * c) % 1000000007;
ways = (ways + x) % 1000000007;
bc--;
f = true;
} else if (a[i] > b[i]) {
long long x = power(m, ac + bc) % 1000000007;
long long y = 1;
x = (((x * y) % 1000000007) * c) % 1000000007;
ways = (ways + x) % 1000000007;
break;
} else if (a[i] < b[i]) {
if (!f) fail = true;
break;
}
}
if (fail)
printf("0\n");
else {
long long res = (ways * modInverse(q, 1000000007)) % 1000000007;
printf("%lld\n", res);
}
return 0;
}
|
Magnus decided to play a classic chess game. Though what he saw in his locker shocked him! His favourite chessboard got broken into 4 pieces, each of size n by n, n is always odd. And what's even worse, some squares were of wrong color. j-th square of the i-th row of k-th piece of the board has color ak, i, j; 1 being black and 0 being white.
Now Magnus wants to change color of some squares in such a way that he recolors minimum number of squares and obtained pieces form a valid chessboard. Every square has its color different to each of the neightbouring by side squares in a valid board. Its size should be 2n by 2n. You are allowed to move pieces but not allowed to rotate or flip them.
Input
The first line contains odd integer n (1 ≤ n ≤ 100) — the size of all pieces of the board.
Then 4 segments follow, each describes one piece of the board. Each consists of n lines of n characters; j-th one of i-th line is equal to 1 if the square is black initially and 0 otherwise. Segments are separated by an empty line.
Output
Print one number — minimum number of squares Magnus should recolor to be able to obtain a valid chessboard.
Examples
Input
1
0
0
1
0
Output
1
Input
3
101
010
101
101
000
101
010
101
011
010
101
010
Output
2
|
/* / ﾌﾌ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ム
/ )\⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ Y
(⠀⠀| ( ͡° ͜ʖ ͡°）⠀⌒(⠀ ノ
(⠀ ﾉ⌒ Y ⌒ヽ-く __／
| _⠀｡ノ| ノ｡ |/
(⠀ー '_人`ー ﾉ
⠀|\ ￣ _人'彡ﾉ
⠀ )\⠀⠀ ｡⠀⠀ /
⠀⠀(\⠀ #⠀ /
⠀/⠀⠀⠀/ὣ====================D-
/⠀⠀⠀/⠀ \ \⠀⠀\
( (⠀)⠀⠀⠀⠀ ) ).⠀)
(⠀⠀)⠀⠀⠀⠀⠀( | /
|⠀ /⠀⠀⠀⠀⠀⠀ | /
[_] ⠀⠀⠀⠀⠀[___] */
// Main Code at the Bottom
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
//Fast IO class
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
boolean env=System.getProperty("ONLINE_JUDGE") != null;
if(!env) {
try {
br=new BufferedReader(new FileReader("src\\input.txt"));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
else 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;
}
}
static long MOD=1000000000+7;
//Euclidean Algorithm
static long gcd(long A,long B){
if(B==0) return A;
return gcd(B,A%B);
}
//Modular Exponentiation
static long fastExpo(long x,long n){
if(n==0) return 1;
if((n&1)==0) return fastExpo((x*x)%MOD,n/2)%MOD;
return ((x%MOD)*fastExpo((x*x)%MOD,(n-1)/2))%MOD;
}
//Prime Number Algorithm
static boolean isPrime(long n){
if(n<=1) return false;
if(n<=3) return true;
if(n%2==0 || n%3==0) return false;
for(int i=5;i*i<=n;i+=6) if(n%i==0 || n%(i+2)==0) return false;
return true;
}
//Reverse an array
static <T> void reverse(T arr[],int l,int r){
Collections.reverse(Arrays.asList(arr).subList(l, r));
}
//Print array
static <T> void print1d(T arr[]) {
out.println(Arrays.toString(arr));
}
static <T> void print2d(T arr[][]) {
for(T a[]: arr) out.println(Arrays.toString(a));
}
// Pair
static class pair{
long x,y;
pair(long a,long b){
this.x=a;
this.y=b;
}
public boolean equals(Object obj) {
if(obj == null || obj.getClass()!= this.getClass()) return false;
pair p = (pair) obj;
return (this.x==p.x && this.y==p.y);
}
public int hashCode() {
return Objects.hash(x,y);
}
}
static FastReader sc=new FastReader();
static PrintWriter out=new PrintWriter(System.out);
//Main function(The main code starts from here)
public static void main (String[] args) throws java.lang.Exception {
int test=1;
while(test-->0) {
int n=sc.nextInt(),ans=0,visited[]=new int[4];
char s[][][]=new char[4][n][n];
for(int i=0;i<4;i++) {
for(int j=0;j<n;j++) s[i][j]=sc.nextLine().toCharArray();
sc.nextLine();
}
int start='0';
for(int itr=0;itr<2;itr++) {
char tmp[][]=new char[n][n];
for(int x=0;x<n;x++) {
for(int y=0;y<n;y++) tmp[x][y]=(char) (((x+y)%2==0)?start:('1'-start+'0'));
}
start='1';
//for(int i=0;i<n;i++) out.println(Arrays.toString(tmp[i]));
for(int i=0;i<2;i++) {
int min=Integer.MAX_VALUE,idx=-1;
for(int j=0;j<4;j++) {
if(visited[j]==1) continue;
int cnt=0;
for(int x=0;x<n;x++) {
for(int y=0;y<n;y++) if(tmp[x][y]!=s[j][x][y]) cnt++;
}
if(cnt<min) {
min=cnt;
idx=j;
}
}
ans+=min;
//System.out.println(idx+" "+min);
visited[idx]=1;
}
}
out.println(ans);
}
out.flush();
out.close();
}
}
|
Walking along a riverside, Mino silently takes a note of something.
"Time," Mino thinks aloud.
"What?"
"Time and tide wait for no man," explains Mino. "My name, taken from the river, always reminds me of this."
"And what are you recording?"
"You see it, tide. Everything has its own period, and I think I've figured out this one," says Mino with confidence.
Doubtfully, Kanno peeks at Mino's records.
The records are expressed as a string s of characters '0', '1' and '.', where '0' denotes a low tide, '1' denotes a high tide, and '.' denotes an unknown one (either high or low).
You are to help Mino determine whether it's possible that after replacing each '.' independently with '0' or '1', a given integer p is not a period of the resulting string. In case the answer is yes, please also show such a replacement to Mino.
In this problem, a positive integer p is considered a period of string s, if for all 1 ≤ i ≤ \lvert s \rvert - p, the i-th and (i + p)-th characters of s are the same. Here \lvert s \rvert is the length of s.
Input
The first line contains two space-separated integers n and p (1 ≤ p ≤ n ≤ 2000) — the length of the given string and the supposed period, respectively.
The second line contains a string s of n characters — Mino's records. s only contains characters '0', '1' and '.', and contains at least one '.' character.
Output
Output one line — if it's possible that p is not a period of the resulting string, output any one of such strings; otherwise output "No" (without quotes, you can print letters in any case (upper or lower)).
Examples
Input
10 7
1.0.1.0.1.
Output
1000100010
Input
10 6
1.0.1.1000
Output
1001101000
Input
10 9
1........1
Output
No
Note
In the first example, 7 is not a period of the resulting string because the 1-st and 8-th characters of it are different.
In the second example, 6 is not a period of the resulting string because the 4-th and 10-th characters of it are different.
In the third example, 9 is always a period because the only constraint that the first and last characters are the same is already satisfied.
Note that there are multiple acceptable answers for the first two examples, you can print any of them.
|
n, p = [int(i) for i in input().split()]
s = list(input())
k = 0
for index in range(n - p):
if k != 0:
break
if s[index] == s[index + p] and s[index] == ".":
s[index] = str(0)
s[index + p] = str(1)
k += 1
elif s[index] != s[index + p] and s[index] != "." and s[index + p] != ".":
k += 1
elif s[index] != s[index + p] and (s[index] == "." or s[index + p] == "."):
if s[index] == ".":
s[index] = str(int(not int(s[index + p])))
else:
s[index + p] = str(int(not int(s[index])))
k += 1
s = "".join(s)
print("No" if k == 0 else s.replace(".", str(0)))
|
Amit has been practicing "pattern printing" problems a lot. To test his ability Jitendra gives him a problem.He tells him to print the given matrix in the diagonal fashion.
Note: Direction of the diagonal is from the upper-right corner to lower-left corner.See sample test cases for more clarification.Imagine you are Amit. Write the code to prove your ability!
Input:
First line contain the values of N and M.
Next N lines contain M space separated numbers.
Output:
Print the given matrix in the diagonal fashion as described.
Constraints:
1 ≤ N,M ≤ 100
0 ≤ element of matrix ≤100
SAMPLE INPUT
3 3
1 2 3
5 6 7
0 1 2
SAMPLE OUTPUT
1
2 5
3 6 0
7 1
2
|
n,m = map(int,raw_input().split())
matrix = []
for x in range(n):
matrix.append(map(int,raw_input().split()))
maxsum = n + m - 2
for sums in range(maxsum+1):
for i in range(n):
for j in range(m):
if i + j - sums == 0:
print matrix[i][j],
print
|
Brian built his own car and was confused about what name he should keep for it. He asked Roman for help. Roman being his good friend, suggested a lot of names.
Brian only liked names that:
- Consisted of exactly three distinct characters, say C1, C2 and C3
- Satisfied the criteria that the string was of the form - C1^n C2^n C3^n : This means, first C1 occurs n times, then C2 occurs n times and then C3 occurs n times. For example, xyz, ccaarr, mmmiiiaaa satisfy the criteria, but xyzw, aabbbcccc don't.
Given N names suggested by Roman, print "OK" if Brian likes the name and "Not OK" if he doesn't.
Input:
First line contains a single positive integer N - the number of names.
N lines follow - each line contains a name.
Output:
For each name, Print "OK" if the name satisfies the criteria, else print "Not OK", on a new line.
Constraints:
1 ≤ N ≤ 100
1 ≤ Length of names ≤ 500
Names contain only lowercase English alphabets
SAMPLE INPUT
2
bbbrrriii
brian
SAMPLE OUTPUT
OK
Not OK
Explanation
First name satisfies the criteria as: C1 = b, C2 = r, C3 = i, n = 3.
Second name does not satisfy the criteria.
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
def validName(s):
seen = 0
seen_c = []
last_c = ""
n = 0
i = 0
for c in s:
if c != last_c:
last_c = c
seen += 1
if c in seen_c or i < n:
return "Not OK"
seen_c.append(c)
i=0
if seen==1:
n+=1
i+=1
if seen > 3 or i > n:
return "Not OK"
if seen == 3:
return "OK"
return "Not OK"
N = int(raw_input())
for _ in range(N):
s = raw_input()
print validName(s)
|
Frustrated from Mandark's challenges, Dexter plans an invasion in Mandark's lab. He knows that the underground entrance is the best way to get inside. But still, he needs to defuse the bombs hidden under the tiles of the floor. Dexter knows that the entrance has rectangular floor, divided in 1x1 tiles, so he numbered the rows of tiles from 0 to Height-1 and columns from 0 to Width-1.
Each tile can contain at most one bomb, and the Euclidean distance between each pair of bombs must not equal 2. The Euclidean distance between tile in row x1, column y1 and tile in row x2, column y2 is defined as the square root from (x1-x2) * (x1-x2) + (y1-y2) * (y1-y2).
INPUT
First line gives T, the number of test cases.
Each test case gives Width and Height of the floor.
OUTPUT
For each test case, print the maximal number of stones Mandark can plant in the floor.
CONSTRAINTS
1 ≤ T ≤ 50
1 ≤ Height, Width ≤ 1000
SAMPLE INPUT
2
3 2
3 3
SAMPLE OUTPUT
4
5
Explanation
For first case, Mandark can place four stones on the board. Here is one possible arrangement:
- * *
* * -
For second case, a possible arrangement can be:
* - -
* -
- *
|
t=int(raw_input())
for e in range(t):
s,x,=0,0
w,h=map(int,raw_input().split() )
s,x=2*(w//4),w%4
s1=s+(x//3)
if x==1:
s+=1
elif x!=0:
s+=2
k,x=(h//4),h%4
n=2*(s+s1)*k
if x==1:
n+=s
elif x==2:
n+=2*s
elif x==3:
n+=2*s+s1
print n
|
Given an array of size N of integers with each element denoted as array[i] .
In this problem we are given a parameter K and we are supposed to find the size of the largest contiguous subarray whose GCD is atleast K
If there is no subarray whose GCD is atleast K , print "0".
INPUT
The first line contains 2 integers N and K the size of the array and the parameter as described in the problem statement
The second line containts N space separated integers denoting the array.
OUTPUT
Print a single integer in a single line denoting the maximum contiguous subarray size whose GCD is atleast K.
Contraints
1 ≤ N ≤ 500000
1 ≤ array[i] , K ≤ 1000000
SAMPLE INPUT
5 9
10 20 5 15 45
SAMPLE OUTPUT
2
Explanation
GCD(10 , 20) is 10 and since its greater than 0 and there is no other subarray larger that this with GCD atleast 9 , so the answer is 2 . Alternatively the subarray (15 , 45) is also having GCD 15 but since it also has a size 2 the answer remains 2 only.
|
from fractions import gcd
n,m=map(int,raw_input().split())
a=map(int,raw_input().split())
z=[]
l=0
for x in xrange(n):
if a[x]<m:
continue
s=a[x]
q=0
for y in xrange(x+1,n):
if a[y]<m or s<m:
break
s=gcd(s,a[y])
if s>=m:
l=max(l,y-x+1)
if l==0:
print 0
else:
print l
|
Sidddharth is very kind-hearted. He doesn't want to give you any stupid problem statement that wastes your time.
Given an array of integers, find the sum of the ith largest and jth smallest number from the array.
Input Format:
First line of the input consists of a single integer T, number of test cases.
Each test case has 3 lines as input.
First line will have a single integer N, denoting number of elements in array(A).
Next line contains N integers.
Last line consists of integers i & j.
Output Format:
Print the required sum or for each test case
Constraints:
1 ≤ T ≤ 10
1 ≤ N ≤ 1000
1 ≤ A[i] ≤ 10^6
1 ≤ i,j ≤ n
Problem Setter : Siddharth Seth
SAMPLE INPUT
1
8
1 2 5 3 6 4 8 7
3 4
SAMPLE OUTPUT
10
|
t=input()
for i in range(t):
n=input()
a=map(int,raw_input().strip().split())
(i,j)=map(int,raw_input().strip().split())
a.sort()
result=a[n-i]+a[j-1]
print result
|
Monk was asked to answer some queries in an interview. He is given an empty array A. Queries are of 4 types:-
1. 1 X - Add number X to the array A.
2. 2 X - Remove a single instance of number X from the array A. If not possible, print "-1" without the quotes.
3. 3 - Find the maximum element in the array A.
4. 4 - Find the minimum element in the array A.
Input:
The first line contains the integer Q.
The next Q lines will each contain a query like the ones mentioned above.
Output:
For queries 3 and 4, print the answer in a new line. If the array is empty for query 3 and 4, then print "-1" without the quotes.
Constraints:
1 ≤ Q ≤ 100000
1 ≤ X ≤ 100000
SAMPLE INPUT
5
1 5
1 9
1 6
3
2 1
SAMPLE OUTPUT
9
-1
Explanation
There are 5 queries.
Query 1 - 5 is added to the array.
Query 2 - 9 is added to the array.
Query 3 - 6 is added to the array.
Query 4 - The maximum element in the array is 9.
Query 5 - Since there is no element in the array with value 1, so the output is -1.
|
from collections import defaultdict
n=input()
minn=1000001
maxx=0
a=defaultdict(int)
ans=[]
count=0
for i in range(0,n):
x=map(int,raw_input().split())
if x[0]==1:
if x[1]>maxx:
maxx=x[1]
if x[1]<minn:
minn=x[1]
a[x[1]]+=1
count+=1
elif x[0]==2:
if a[x[1]]>0:
a[x[1]]-=1
if a[x[1]]==0 and x[1]==maxx:
k=a.keys()
maxx=0
#print k
for j in range(0,len(k)):
if a[k[j]]>0 and k[j]>maxx:
maxx=k[j]
#print maxx
if a[x[1]]==0 and x[1]==minn:
k=a.keys()
minn=1000001
for j in range(0,len(k)):
if a[k[j]]>0 and k[j]<minn:
minn=k[j]
count-=1
else:
ans.append(-1)
elif x[0]==3:
if count>0:
ans.append(maxx)
else:
ans.append(-1)
elif x[0]==4:
if count>0:
ans.append(minn)
else:
ans.append(-1)
#print a
#print maxx
#print minn
for i in range(0,len(ans)):
print ans[i]
|
A particular name-recording system is used by N employees of a firm. Everyday, they have to enter their names into the system.
To make it easier to control the system, each employee has his/her name presented as a string of lowercase letters from 'a' to 'z' with the same length K. Therefore, the system is designed to have K slots. Each slot has one lowercase letter from 'a' - 'z', initially. It takes one second to rotate it either upwards or downwards. Note that the arrangement is not circular, and hence, 'z' cannot be changed into 'a' in one second.
Given the list of all employee names that need to be entered every morning, can you find the least lexicographically default starting string S to be presented in the system so that the total amount of time spent by all employees is minimized?
Note that after an employee has finished entering his/her name, the system resets to S.
Input:
The first line contains a single integer T, denoting the number of test cases. Each of the T test cases has this format:
- The first line contains two space-separated integers N and K.
- Each of the next N lines contains a string of length K representing the name of the respective employee in lowercase.
Output:
Output exactly T strings, each contains the answer to the corresponding test case.
Constraints:
1 ≤ T ≤ 10
1 ≤ N ≤ 10000
1 ≤ K ≤ 20
SAMPLE INPUT
2
3 3
aaa
ccc
ddd
5 1
a
a
b
b
a
SAMPLE OUTPUT
ccc
a
|
for testCases in range(input()):
matrix = []
n,m = map(int,raw_input().split())
for i in range(n):
a = raw_input()
b = []
for j in a:
b.append(ord(j))
matrix.append(b)
mat = []
for i in range(m):
res = []
for j in range(n):
res.append(matrix[j][i])
res = sorted(res)
mat.append(res)
res = []
for i in mat:
foo = min(i[n/2],i[(n-1)/2])
res.append(chr(foo))
print ''.join(res)
|
Roy has played a lot of Mario that he got bored of playing it again and again. So now he wants to design a stage of Mario game.
Right now he is simply designing a group of walls using bricks that little Mario has to cross over. Little Mario cannot jump more than 3 bricks' height, so Roy cannot create a wall of height more than 3.
Roy has N number of bricks. Roy wants to make a group of walls such that height of no single wall exceeds 3.
For example if N = 8, one of the group of walls can be as follows:
Now Roy wonders how many different groups of walls can he generate for a given number of bricks.
(See Sample Test Case Explanation for clarification)
Input:
First line contains integer T, number of Test Cases.
Next T lines each will contain integer N, number of bricks Roy has.
Output:
Print an integer in new line for each test case, number of different groups of walls.
Since answer can be very large, print it modulo 1000000007
Constraints:
1 ≤ T ≤ 10
1 ≤ N ≤ 100000
Sample Test Case Explanation: For N = 3SAMPLE INPUT
1
3
SAMPLE OUTPUT
4
|
MOD = 1000000007
def TribSeries(n,t1,t2,t3):
if n==1:
ans=t1
if n==2:
ans=t2
if n==3:
ans=t3
if n>3:
for j in range(n-3):
ans=(t1+t2+t3)%MOD
t1=t2
t2=t3
t3=ans
print ans
def main():
T=int(raw_input())
trib=[]
for i in range(T):
n=int(raw_input())
t1=1
t2=2
t3=4
TribSeries(n,t1,t2,t3)
main()
|
Anton and Artur are old friends. Today they practice in writing strings. Anton must write each string with the lengths exactly N , based on the alphabet of size M . And Arthur, on the contrary, should write each string with the lengths exactly M , based on the alphabet of size N . Guys spend 1 second to write a single string.
They start writing at the same time.
And now boys are interested in one question. Is it true, that they will finish together? (It is assumed that the guys don't pause during the writing of strings).
Input
First line of the input contains the number of test cases T . It is followed by T tets cases. Each test case has 1 line. Line contains two integer numbers N and M separated by a single space.
Output
For each test case output "YES" if Anton and Artur will finish at the same time. Else print "NO"
Constraits
1 ≤ T ≤ 50
1 ≤ N, M ≤ 10^10000
SAMPLE INPUT
3
1 1
1 3
100 500
SAMPLE OUTPUT
YES
NO
NO
Explanation
In the second case Anton should write three strings. But Artur should write only one string, and he will finish earlier.
|
T = int(raw_input())
while(T):
T -= 1
N,M = raw_input().split()
n = int(N)
m = int(M)
if n == m :
print "YES"
elif n==2 and m==4 or n==4 and m==2:
print "YES"
else:
print "NO"
|
Problem :
Chotu's father is the owner of a Vada Pav shop. One Sunday, his father takes him to the shop. Father tells him that at the end of the day, Chotu has to give him a list consisting of the names of all the customers on that day who bought Vada Pav(s) from the shop. The list should not have the names of any of the customers being repeated and it should be such that the lexicographically smallest name comes first, ie., the names should be sorted in dictionary order.
As and when a particular customer buys a Vada Pav, Chotu writes down the name of that particular customer. Chotu's initial list is ready, but, he is confused as to how to make the list Father expects from him. Chotu comes to you for help. Your job now is to create the final list, as Father expects from Chotu.
Input :
First line consists of N, the number of names of customers in Chotu's initial list. The next N lines are such that each line consists of a customer's name.
Output :
On the first line, print the total number of names appearing in Chotu's final list. Then print the list such that every customer's name is printed on a new line.
Constraints :
1 ≤ N ≤ 10^6
1 ≤ Length of names of customers ≤ 5
Customers' names consist only of lower case English alphabets (a-z).
Note : Some test files contain large data. Use scanf/printf instead of cin/cout .
SAMPLE INPUT
11
babu
anand
rani
aarti
nandu
rani
rani
ap
anand
babu
nandu
SAMPLE OUTPUT
6
aarti
anand
ap
babu
nandu
rani
|
listi = []
for i in range(input()):
s = raw_input()
listi.append(s)
ans = list(set(listi))
ans.sort()
print len(ans)
for i in ans:
print i
|
M-kun is a competitor in AtCoder, whose highest rating is X.
In this site, a competitor is given a kyu (class) according to his/her highest rating. For ratings from 400 through 1999, the following kyus are given:
* From 400 through 599: 8-kyu
* From 600 through 799: 7-kyu
* From 800 through 999: 6-kyu
* From 1000 through 1199: 5-kyu
* From 1200 through 1399: 4-kyu
* From 1400 through 1599: 3-kyu
* From 1600 through 1799: 2-kyu
* From 1800 through 1999: 1-kyu
What kyu does M-kun have?
Constraints
* 400 \leq X \leq 1999
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the kyu M-kun has, as an integer. For example, if he has 8-kyu, print `8`.
Examples
Input
725
Output
7
Input
1600
Output
2
|
import java.util.Scanner;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int X = Integer.parseInt(sc.next());
if(X >= 400 && X <= 599) {
System.out.println(8);
}else if(X <= 799) {
System.out.println(7);
}else if(X <= 999) {
System.out.println(6);
}else if(X <= 1199) {
System.out.println(5);
}else if(X <= 1399) {
System.out.println(4);
}else if(X <= 1599) {
System.out.println(3);
}else if(X <= 1799) {
System.out.println(2);
}else if(X <= 1999) {
System.out.println(1);
}
}
}
|
Given is a positive integer L. Find the maximum possible volume of a rectangular cuboid whose sum of the dimensions (not necessarily integers) is L.
Constraints
* 1 ≤ L ≤ 1000
* L is an integer.
Input
Input is given from Standard Input in the following format:
L
Output
Print the maximum possible volume of a rectangular cuboid whose sum of the dimensions (not necessarily integers) is L. Your output is considered correct if its absolute or relative error from our answer is at most 10^{-6}.
Examples
Input
3
Output
1.000000000000
Input
999
Output
36926037.000000000000
|
N=int(input())
print((N**3)/27)
|
We will create an artwork by painting black some squares in a white square grid with 10^9 rows and N columns.
The current plan is as follows: for the i-th column from the left, we will paint the H_i bottommost squares and will not paint the other squares in that column.
Before starting to work, you can choose at most K columns (possibly zero) and change the values of H_i for these columns to any integers of your choice between 0 and 10^9 (inclusive).
Different values can be chosen for different columns.
Then, you will create the modified artwork by repeating the following operation:
* Choose one or more consecutive squares in one row and paint them black. (Squares already painted black can be painted again, but squares not to be painted according to the modified plan should not be painted.)
Find the minimum number of times you need to perform this operation.
Constraints
* 1 \leq N \leq 300
* 0 \leq K \leq N
* 0 \leq H_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
H_1 H_2 ... H_N
Output
Print the minimum number of operations required.
Examples
Input
4 1
2 3 4 1
Output
3
Input
6 2
8 6 9 1 2 1
Output
7
Input
10 0
1 1000000000 1 1000000000 1 1000000000 1 1000000000 1 1000000000
Output
4999999996
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i=0; i < n; i ++)
#define rep1(i, n) for (int i=1; i <= n; i ++)
#define _min(x, y) x = min(x, y)
#define _max(x, y) x = max(x, y)
using namespace std;
vector<vector<long long> > dp(305, vector<long long>(305, 300000000000));
int main() {
int N, K; cin >> N >> K;
vector<int> H;
H.push_back(0);
dp[0][0] = 0;
dp[0][1] = 0;
rep(i, N) {
int h; cin >> h;
H.push_back(h);
dp[i + 1][1] = h;
dp[i + 1][0] = 0;
}
for (int y = 2; y <= N; y ++) {
rep1(x, N) {
for (int i = 1; i < x; i ++) {
_min(dp[x][y], dp[i][y - 1] + max(0, H[x] - H[i]));
}
}
}
long long ans = 300000000000;
//rep(i, N + 1) {
// rep(j, N + 1) {
// cout << dp[i][j] << " " ;
// }
// cout << endl;
//}
rep1(i, N) {
_min(ans, dp[i][N - K]);
}
cout << ans << endl;
return 0;
}
|
X and A are integers between 0 and 9 (inclusive).
If X is less than A, print 0; if X is not less than A, print 10.
Constraints
* 0 \leq X, A \leq 9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
X A
Output
If X is less than A, print 0; if X is not less than A, print 10.
Examples
Input
3 5
Output
0
Input
7 5
Output
10
Input
6 6
Output
10
|
import java.util.*;
import java.util.stream.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println(in.nextInt() < in.nextInt() ? 0 : 10);
}
}
|
You are given three strings A, B and C. Each of these is a string of length N consisting of lowercase English letters.
Our objective is to make all these three strings equal. For that, you can repeatedly perform the following operation:
* Operation: Choose one of the strings A, B and C, and specify an integer i between 1 and N (inclusive). Change the i-th character from the beginning of the chosen string to some other lowercase English letter.
What is the minimum number of operations required to achieve the objective?
Constraints
* 1 \leq N \leq 100
* Each of the strings A, B and C is a string of length N.
* Each character in each of the strings A, B and C is a lowercase English letter.
Input
Input is given from Standard Input in the following format:
N
A
B
C
Output
Print the minimum number of operations required.
Examples
Input
4
west
east
wait
Output
3
Input
9
different
different
different
Output
0
Input
7
zenkoku
touitsu
program
Output
13
|
import java.io.PrintWriter;
import java.util.*;
public class Main {
public static String implementation(List<String> array){
int n = Integer.parseInt(array.get(0));
String a = array.get(1);
String b = array.get(2);
String c = array.get(3);
int count = 0;
for(int i=0; i<n; i++){
if(a.charAt(i)==b.charAt(i) && a.charAt(i)==c.charAt(i)){
// Do nothing
} else if (a.charAt(i)==b.charAt(i) || b.charAt(i)==c.charAt(i) || c.charAt(i)==a.charAt(i)) {
count += 1;
} else {
count +=2;
}
}
return String.valueOf(count);
}
public static void main(String[] args){
// Input
Scanner sc = new Scanner(System.in);
// Read input and execute method
String tmp;
List<String> array = new ArrayList<String>();
while(true) {
try {
tmp = sc.nextLine();
if (tmp.length() == 0) {
exec(array);
array.clear();
} else {
array.add(tmp);
}
} catch (Exception e){
exec(array);
break;
}
}
}
public static void exec(List<String> array){
// Output variable
String out = implementation(array);
// Output
PrintWriter stdOut = new PrintWriter(System.out);
stdOut.println(out);
stdOut.flush();
// Debug
if(array.get(array.size()-1).startsWith("a:")) {
if (!array.get(array.size() - 1).substring(2).equals(out)) {
System.out.println("error included");
System.out.println("output : " + out);
System.out.println("expected : " + array.get(array.size()-1).substring(2));
} else {
System.out.println("correct answer!!");
}
System.out.println("");
}
}
}
|
Takahashi has decided to distribute N AtCoder Crackers to K users of as evenly as possible. When all the crackers are distributed, find the minimum possible (absolute) difference between the largest number of crackers received by a user and the smallest number received by a user.
Constraints
* 1 \leq N,K \leq 100
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
Output
Print the minimum possible (absolute) difference between the largest number of crackers received by a user and the smallest number received by a user.
Examples
Input
7 3
Output
1
Input
100 10
Output
0
Input
1 1
Output
0
|
#include<bits/stdc++.h>
using namespace std;
int a,b;
int main()
{
cin>>a>>b;
cout << bool(a%b) << endl;
}
|
You are given a forest with N vertices and M edges. The vertices are numbered 0 through N-1. The edges are given in the format (x_i,y_i), which means that Vertex x_i and y_i are connected by an edge.
Each vertex i has a value a_i. You want to add edges in the given forest so that the forest becomes connected. To add an edge, you choose two different vertices i and j, then span an edge between i and j. This operation costs a_i + a_j dollars, and afterward neither Vertex i nor j can be selected again.
Find the minimum total cost required to make the forest connected, or print `Impossible` if it is impossible.
Constraints
* 1 ≤ N ≤ 100,000
* 0 ≤ M ≤ N-1
* 1 ≤ a_i ≤ 10^9
* 0 ≤ x_i,y_i ≤ N-1
* The given graph is a forest.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M
a_0 a_1 .. a_{N-1}
x_1 y_1
x_2 y_2
:
x_M y_M
Output
Print the minimum total cost required to make the forest connected, or print `Impossible` if it is impossible.
Examples
Input
7 5
1 2 3 4 5 6 7
3 0
4 0
1 2
1 3
5 6
Output
7
Input
5 0
3 1 4 1 5
Output
Impossible
Input
1 0
5
Output
0
|
# -*- coding: utf-8 -*-
from collections import defaultdict
from heapq import merge
import sys
sys.setrecursionlimit(10**7)
def inpl(): return tuple(map(int, input().split()))
N, M = inpl()
A = inpl()
tree = [[-1, 1] for _ in range(N)] # [next, rank]
def find(i):
if tree[i][0] == -1:
group = i
else:
group = find(tree[i][0])
tree[i][0] = group
return group
def unite(x, y):
px = find(x)
py = find(y)
if tree[px][1] == tree[py][1]: # rank is same
tree[py][0] = px
tree[px][1] += 1
else:
if tree[px][1] < tree[py][1]:
px, py = py, px
tree[py][0] = px
for _ in range(M):
x, y = tuple(map(int, input().split()))
if not int(find(x) == find(y)):
unite(x, y)
D = defaultdict(list)
for n in range(N):
D[find(n)].append(A[n])
H = []
res = 0
for k, v in D.items():
v = sorted(v)
res += v[0]
H.append(v[1:])
if N < 2*(N-M-1):
print("Impossible")
elif M == N-1:
print(0)
else:
res += sum(list(merge(*H))[:2*(N-M-1) - len(D.keys())])
print(res)
|
There are N balls in the xy-plane. The coordinates of the i-th of them is (x_i, i). Thus, we have one ball on each of the N lines y = 1, y = 2, ..., y = N.
In order to collect these balls, Snuke prepared 2N robots, N of type A and N of type B. Then, he placed the i-th type-A robot at coordinates (0, i), and the i-th type-B robot at coordinates (K, i). Thus, now we have one type-A robot and one type-B robot on each of the N lines y = 1, y = 2, ..., y = N.
When activated, each type of robot will operate as follows.
* When a type-A robot is activated at coordinates (0, a), it will move to the position of the ball on the line y = a, collect the ball, move back to its original position (0, a) and deactivate itself. If there is no such ball, it will just deactivate itself without doing anything.
* When a type-B robot is activated at coordinates (K, b), it will move to the position of the ball on the line y = b, collect the ball, move back to its original position (K, b) and deactivate itself. If there is no such ball, it will just deactivate itself without doing anything.
Snuke will activate some of the 2N robots to collect all of the balls. Find the minimum possible total distance covered by robots.
Constraints
* 1 \leq N \leq 100
* 1 \leq K \leq 100
* 0 < x_i < K
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
K
x_1 x_2 ... x_N
Outputs
Print the minimum possible total distance covered by robots.
Examples
Input
1
10
2
Output
4
Input
2
9
3 6
Output
12
Input
5
20
11 12 9 17 12
Output
74
|
n=int(input())
k=int(input())
x=list(map(int,input().split()))
ans=0
for i in range(n):
ans+=2*min(x[i],k-x[i])
print(ans)
|
Three poles stand evenly spaced along a line. Their heights are a, b and c meters, from left to right. We will call the arrangement of the poles beautiful if the tops of the poles lie on the same line, that is, b-a = c-b.
Determine whether the arrangement of the poles is beautiful.
Constraints
* 1 \leq a,b,c \leq 100
* a, b and c are integers.
Input
Input is given from Standard Input in the following format:
a b c
Output
Print `YES` if the arrangement of the poles is beautiful; print `NO` otherwise.
Examples
Input
2 4 6
Output
YES
Input
2 5 6
Output
NO
Input
3 2 1
Output
YES
|
#include <iostream>
using namespace std;
int main() {
int A,B,C;
cin >> A >> B>> C;
cout << (B-A==C-B ? "YES" : "NO");
return 0;
}
|
On a planet far, far away, M languages are spoken. They are conveniently numbered 1 through M.
For CODE FESTIVAL 20XX held on this planet, N participants gathered from all over the planet.
The i-th (1≦i≦N) participant can speak K_i languages numbered L_{i,1}, L_{i,2}, ..., L_{i,{}K_i}.
Two participants A and B can communicate with each other if and only if one of the following conditions is satisfied:
* There exists a language that both A and B can speak.
* There exists a participant X that both A and B can communicate with.
Determine whether all N participants can communicate with all other participants.
Constraints
* 2≦N≦10^5
* 1≦M≦10^5
* 1≦K_i≦M
* (The sum of all K_i)≦10^5
* 1≦L_{i,j}≦M
* L_{i,1}, L_{i,2}, ..., L_{i,{}K_i} are pairwise distinct.
Input
The input is given from Standard Input in the following format:
N M
K_1 L_{1,1} L_{1,2} ... L_{1,{}K_1}
K_2 L_{2,1} L_{2,2} ... L_{2,{}K_2}
:
K_N L_{N,1} L_{N,2} ... L_{N,{}K_N}
Output
If all N participants can communicate with all other participants, print `YES`. Otherwise, print `NO`.
Examples
Input
4 6
3 1 2 3
2 4 2
2 4 6
1 6
Output
YES
Input
4 4
2 1 2
2 1 2
1 3
2 4 3
Output
NO
|
#include <bits/stdc++.h>
using namespace std;
int g[200005];
int f(int x) {
return g[x] == x ? x : g[x] = f(g[x]);
}
int main() {
for (int i = 1; i <= 200000; i++) {
g[i] = i;
}
int n, m, k, x;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &k);
for (int j = 1; j <= k; j++) {
scanf("%d", &x);
int y = f(100000 + x);
int z = f(i);
if (y != z) {
g[y] = z;
}
}
}
for (int i = 1; i <= n; i++) {
if (f(i) != f(1)) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
return 0;
}
|
Given a sequence of numbers a1, a2, a3, ..., an, find the maximum sum of a contiguous subsequence of those numbers. Note that, a subsequence of one element is also a contiquous subsequence.
Input
The input consists of multiple datasets. Each data set consists of:
n
a1
a2
.
.
an
You can assume that 1 ≤ n ≤ 5000 and -100000 ≤ ai ≤ 100000.
The input end with a line consisting of a single 0.
Output
For each dataset, print the maximum sum in a line.
Example
Input
7
-5
-1
6
4
9
-6
-7
13
1
2
3
2
-2
-1
1
2
3
2
1
-2
1
3
1000
-200
201
0
Output
19
14
1001
|
while 1:
n=input()
if n==0:break
r=[input()for i in xrange(n)]
#print r
for i in xrange(1,n):
r[i]=max(r[i-1]+r[i],r[i])
#print r
print max(r)
|
Create a program to determine the positional relationship between a triangle and a circle on a plane. All target figures shall include boundaries. The triangle is given the position of three vertices, and the circle is given the position of the center and the radius. The position is given by a set of two integers in a Cartesian coordinate system. The radius is also given as an integer.
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:
x1 y1
x2 y2
x3 y3
xc yc
r
The first to third lines are given the coordinates xi, yi of the i-th vertex of the triangle. The coordinates of the center of the circle xc, yc are given on the 4th line, and the radius r of the circle is given on the 5th line. All inputs given are integers greater than or equal to 1 and less than or equal to 10,000.
The number of datasets does not exceed 100.
Output
The judgment result is output to one line in the following format for each input data set.
If the circle is included in the triangle a
If the triangle is included in the circle b
In other cases, if there is an intersection, c
D if there is no intersection
Example
Input
1 1
3 1
3 3
3 2
3
3 12
9 3
11 12
8 7
5
15 3
17 7
22 5
7 6
4
6 11
8 2
16 9
10 8
2
0 0
Output
b
c
d
a
|
#include<bits/stdc++.h>
using namespace std;
//objects-----------------------------------------------------------------
typedef complex<double>Point;
typedef Point Vector;
typedef vector<Point>Polygon;
struct Segment{
Point p1,p2;
Segment(const Point &p1=Point(),const Point &p2=Point()):p1(p1),p2(p2){}
};
struct Line{
Point p1,p2;
Line(const Point &p1=Point(),const Point &p2=Point()):p1(p1),p2(p2){}
};
struct Circle{
Point p;
double r;
Circle(const Point &p=Point(),double r=0.0):p(p),r(r){}
};
//constants---------------------------------------------------------------
const double PI=acos(-1);
const double EPS=1e-12;
const double INF=1e16;
const int COUNTER_CLOCKWISE=1;
const int CLOCKWISE=-1;
const int ONLINE_BACK=2;
const int ONLINE_FRONT=-2;
const int ON_SEGMENT=0;
const int IN=2;
const int ON=1;
const int OUT=0;
//calculations------------------------------------------------------------
inline double square(double a){return a*a;}
inline double norm(const Point &a){return square(a.real())+square(a.imag());}
inline double dot(const Point &a,const Point &b){return (conj(a)*b).real();}
inline double cross(const Point &a,const Point &b){return (conj(a)*b).imag();}
inline double toDeg(double t){return t/PI*180.0;}
inline double toRad(double t){return t/180.0*t;}
inline double arg(Vector p){return atan2(imag(p),real(p));}
inline Vector polar(double a,double r){return Vector(cos(r),sin(r))*a;}
#define equals(a,b) (fabs((a)-(b))<EPS)
#define equalsv(a,b) (equals(real(a),real(b))&&equals(imag(a),imag(b)))
#define curr(P,i) P[(i)%P.size()]
#define next(P,i) P[(i+1)%P.size()]
#define prev(P,i) P[(i-1+P.size())%P.size()]
int ccw(Point p0,Point p1,Point p2){
Vector a=p1-p0;
Vector b=p2-p0;
if(cross(a,b)>EPS)return COUNTER_CLOCKWISE;
if(cross(a,b)<-EPS)return CLOCKWISE;
if(dot(a,b)<EPS)return ONLINE_BACK;
if(norm(a)<norm(b))return ONLINE_FRONT;
return ON_SEGMENT;
}
//inputer-----------------------------------------------------------------
void inputPoint(Point &p){
double x,y;
scanf("%lf%lf",&x,&y);
p=Point(x,y);
}
void inputSegment(Segment &s){
inputPoint(s.p1);
inputPoint(s.p2);
}
void inputLine(Line &l){
inputPoint(l.p1);
inputPoint(l.p2);
}
void inputCircle(Circle &c){
inputPoint(c.p);
scanf("%lf",&c.r);
}
void inputPolygon(Polygon &g,int n){
g.resize(n);
for(int i=0;i<n;i++)inputPoint(g[i]);
}
//orthogonal--------------------------------------------------------------
bool orthogonal(Vector a,Vector b){
return equals(dot(a,b),0.0);
}
bool orthogonal(Point a1,Point a2,Point b1,Point b2){
return orthogonal(a1-a2,b1-b2);
}
bool orthogonal(Segment s1,Segment s2){
return orthogonal(s1.p1-s1.p2,s2.p1-s2.p2);
}
bool orthogonal(Line l1,Line l2){
return orthogonal(l1.p1-l1.p2,l2.p1-l2.p2);
}
//parallel----------------------------------------------------------------
bool parallel(Vector a,Vector b){
return equals(cross(a,b),0.0);
}
bool parallel(Point a1,Point a2,Point b1,Point b2){
return parallel(a1-a2,b1-b2);
}
bool parallel(Segment s1,Segment s2){
return parallel(s1.p1-s1.p2,s2.p1-s2.p2);
}
bool parallel(Line l1,Line l2){
return parallel(l1.p1-l1.p2,l2.p1-l2.p2);
}
//project&reflect---------------------------------------------------------
Point project(Line s,Point p){
Vector base=s.p2-s.p1;
double r=dot(p-s.p1,base)/norm(base);
return s.p1+base*r;
}
Point reflect(Line s,Point p){
return p+(project(s,p)-p)*2.0;
}
//distance----------------------------------------------------------------
double distancePP(Point a,Point b){
return abs(a-b);
}
double distanceLP(Line l,Point p){
return fabs(cross(l.p2-l.p1,p-l.p1)/abs(l.p2-l.p1));
}
double distanceLL(Line l,Line m){
if(parallel(l,m))return distanceLP(l,m.p1);
return 0.0;
}
double distanceSP(Segment s,Point p){
if(dot(s.p2-s.p1,p-s.p1)<0.0)return distancePP(p,s.p1);
if(dot(s.p1-s.p2,p-s.p2)<0.0)return distancePP(p,s.p2);
return distanceLP(Line(s.p1,s.p2),p);
}
double distanceSS(Segment s1,Segment s2){
if(ccw(s1.p1,s1.p2,s2.p1)*ccw(s1.p1,s1.p2,s2.p2)<=0&&
ccw(s2.p1,s2.p2,s1.p1)*ccw(s2.p1,s2.p2,s1.p2)<=0)return 0;
return min(min(distanceSP(s1,s2.p1),distanceSP(s1,s2.p2)),
min(distanceSP(s2,s1.p1),distanceSP(s2,s1.p2)));
}
double distanceCS(Circle c,Segment s){
return distanceSP(s,c.p)-c.r;
}
//intersect----------------------------------------------------------------
bool intersectSS(Point p1,Point p2,Point p3,Point p4){
return ccw(p1,p2,p3)*ccw(p1,p2,p4)<=0&&
ccw(p3,p4,p1)*ccw(p3,p4,p2)<=0;
}
bool intersectSS(Segment s1,Segment s2){
return intersectSS(s1.p1,s1.p2,s2.p1,s2.p2);
}
bool intersectCL(Circle c,Line l){
return fabs(cross(l.p2-l.p1,c.p-l.p1)/abs(l.p2-l.p1))<=c.r+EPS;
}
bool intersectCC(Circle c1,Circle c2){
return abs(c1.p-c2.p)<=c1.r+c2.r+EPS;
}
bool intersectCS(Circle c,Segment s){
return distanceSP(s,c.p)<=c.r+EPS;
}
//crossPoint--------------------------------------------------------------
Point crossPoint(Segment s1,Segment s2){
double crs=cross(s1.p2-s1.p1,s2.p2-s2.p1);
return s2.p1+(s2.p2-s2.p1)*cross(s1.p2-s1.p1,s1.p2-s2.p1)*(1.0/crs);
}
pair<Point,Point>crossPoints(Circle c,Line l){
assert(intersectCL(c,l));
Vector pr=project(l,c.p);
Vector e=(l.p2-l.p1)/abs(l.p2-l.p1);
double base=sqrt(square(c.r)-norm(pr-c.p));
return make_pair(pr+e*base,pr-e*base);
}
pair<Point,Point>crossPoints(Circle c1,Circle c2){
assert(intersectCC(c1,c2));
double d=abs(c1.p-c2.p);
double a=acos((square(c1.r)+square(d)-square(c2.r))/(2*c1.r*d));
double t=arg(c2.p-c1.p);
return make_pair(c1.p+polar(c1.r,t+a),c1.p+polar(c1.r,t-a));
}
//polygon------------------------------------------------------------------
double area(Polygon &g){
const int sz=g.size();
double res=cross(g[sz-1],g[0]);
for(int i=1;i<sz;i++)res+=cross(g[i-1],g[i]);
return fabs(res)*0.5;
}
bool convex(Polygon &g){
for(int i=0;i<g.size();i++){
if(ccw(prev(g,i),curr(g,i),next(g,i))==CLOCKWISE)return false;
}
return true;
}
//other-------------------------------------------------------------------
int contains(Circle c,Point p){
double d=distancePP(c.p,p);
if(equals(d,c.r))return ON;
return d<c.r?IN:OUT;
}
int contains(Polygon g,Point p){
int n=g.size();
bool x=false;
for(int i=0;i<n;i++){
Point a=g[i]-p,b=next(g,i)-p;
if(abs(cross(a,b))<EPS&&dot(a,b)<EPS)return ON;
if(imag(a)>imag(b))swap(a,b);
if(imag(a)<EPS&&EPS<imag(b)&&cross(a,b)>EPS)x=!x;
}
return x?IN:OUT;
}
int contains(Circle c,Polygon g){
for(int i=0;i<g.size();i++){
if(contains(c,g[0])==OUT)return OUT;
}
return IN;
}
int contains(Polygon g,Circle c){
if(contains(g,c.p)!=IN)return OUT;
for(int i=0;i<g.size();i++){
if(distanceCS(c,Segment(g[i],next(g,i)))<-EPS)return OUT;
}
return IN;
}
//end---------------------------------------------------------------------
int main(){
while(true){
Polygon g(3);
Circle c;
inputPoint(g[0]);
if(real(g[0])==0&&imag(g[0])==0)break;
inputPoint(g[1]);
inputPoint(g[2]);
inputCircle(c);
bool f=true;
for(int i=0;i<g.size();i++){
if(!contains(c,g[i]))f=false;
}
if(f){
puts("b");
continue;
}
f=true;
for(int i=0;i<g.size();i++){
Segment s(g[i],next(g,i));
if(distanceCS(c,s)<-EPS)f=false;
}
if(f&&contains(g,c.p)){
puts("a");
continue;
}
f=false;
for(int i=0;i<g.size();i++){
Segment s(g[i],next(g,i));
if(intersectCS(c,s)){
f=true;
}
}
if(f){
puts("c");
}
else puts("d");
}
return 0;
}
|
Welcome to PC Koshien, players. At PC Koshien, competitions are currently being held in a total of three categories: programming category, mobile category, and Ichimai's picture CG category.
Given the number of participants in each department, create a program that calculates the total number of participants.
Input
The input is given in the following format.
p m c
The input is one line, the number of participants in the programming department p (0 ≤ p ≤ 10000), the number of participants in the mobile department m (0 ≤ m ≤ 10000), the number of participants in the Ichimai picture CG department c (0) ≤ c ≤ 10000) is given.
Output
Output the total number of participants on one line.
Examples
Input
10 10 20
Output
40
Input
100 0 0
Output
100
Input
1000 1000 1000
Output
3000
|
#include <stdio.h>
#include <string>
#include <iostream>
#include <map>
#include <algorithm>
using namespace std;
int main(void){
int a,b,c;
cin >> a >> b >> c;
cout << (a+b+c) << endl;
return 0;
}
|
problem
There are fine icicles under the eaves of JOI's house in Canada. Because of this, JOI decided to investigate the icicles.
There are N (2 ≤ N ≤ 100000 = 105) icicles under the eaves of JOI's house. These icicles are aligned and i cm (1 ≤ i ≤ N) from the left edge of the eaves. There are i-th icicles at the position of. The length of the i-th icicle is initially ai cm (ai is an integer greater than or equal to 1). These icicles grow according to the following rule:
* The i-th icicles grow by 1 cm per hour only if they are longer than both the i − 1st icicles and the i + 1st icicles (however, consider only one icicle next to one end). That is, the first icicle grows if it is longer than the second icicle, and the Nth icicle grows if it is longer than the N − 1st icicle).
* All icicles break from the root the moment they reach L cm (2 ≤ L ≤ 50000) (the broken icicles are subsequently considered to be 0 cm long icicles).
In the first stage, the lengths of the two adjacent icicles are all different. At this time, if enough time has passed, all N icicles will break to a length of 0 cm. JOI, I wanted to know how long it would take for the icicles to reach this state.
Given the initial length of N icicles and the limit length L of the icicles, write a program that finds the time it takes for all the icicles to break.
output
The output consists of one line containing only one integer that represents the time it takes for all the icicles to break.
Input / output example
Input example 1
4 6
Four
2
3
Five
Output example 1
8
In the case of Example 1, the 1, 2, 3, and 4 icicles break after 2, 8, 4, and 1 hour, respectively. Therefore, it takes 8 hours for all the icicles to break. Output 8.
Input example 2
6 10
3
Four
1
9
Five
1
Output example 2
15
The above question sentences and the data used for the automatic referee are the question sentences created and published by the Japan Committee for Information Olympics and the test data for scoring.
input
On the first line of the input, the integer N, which represents the number of icicles, and the integer L, which represents the limit length of the icicles, are written in this order, separated by blanks. Input i + line 1 (1 ≤ i) In ≤ N), the integer ai (1 ≤ ai <L) representing the first length of the i-th icicle is written.
Of the scoring data, 30% of the points are N ≤ 500 and L ≤ 1000.
Example
Input
4 6
4
2
3
5
Output
8
|
def loadIcicle():
icicles = []
line = input().strip().split(" ")
N, L = int(line[0]), int(line[1])
while True:
icicles.append(int(input().strip()))
if len(icicles) == N: break
return icicles, N, L
icicles, N, L = loadIcicle()
def calcDiff(icicles, N):
diff_2times = [0]*N
for idx in range(N):
dif_right = icicles[idx+1] - icicles[idx] if idx != N-1 else -icicles[idx]
dif_left = icicles[idx] - icicles[idx-1] if idx != 0 else icicles[idx]
dif_right = 1 if dif_right > 0 else -1
dif_left = 1 if dif_left > 0 else -1
if dif_right - dif_left < 0: diff_2times[idx] = -1
elif dif_right - dif_left > 0: diff_2times[idx] = 1
else: diff_2times[idx] = 0
return diff_2times
diff_2times = calcDiff(icicles, N)
time = [-1]*N
peakX = [i for i in range(N) if diff_2times[i]==-1]
for i in peakX:
time[i] = L - icicles[i]
isLocalMinL, isLocalMinR = False, False
posL, posR = i, i
while not (isLocalMinL and isLocalMinR):
posL -= 1
if posL < 0:
isLocalMinL = True
if not isLocalMinL:
if time[posL] == -1:
time[posL] = (L-icicles[posL]) + time[posL+1]
else:
time[posL] = (L-icicles[posL]) + max(time[posL-1], time[posL+1])
if diff_2times[posL] == 1:
isLocalMinL = True
posR += 1
if posR >= N:
isLocalMinR = True
if not isLocalMinR:
if time[posR] == -1:
time[posR] = (L-icicles[posR]) + time[posR-1]
else:
time[posR] = (L-icicles[posR]) + max(time[posR-1], time[posR+1])
if diff_2times[posR] == 1:
isLocalMinR = True
print(max(time))
|
Evil organizations that attempt to conquer the world are everywhere, regardless of age, east or west fiction, non-fiction, but what on earth did they try to conquer the world? I suddenly thought about that because I was also planning to conquer the world. The only reason I want to conquer the world is to show the world that I am the best in the field of robotics in the world. I'm not interested in the world after the conquest, and I don't mind giving it to dogs everywhere.
I regret to say that there are researchers who are considered to be better than me. The person has an idea. Whoever it is, Dr. Synchronous R in my school days. I admit his achievements, but I don't think he was better than that of mine. However, he was well received by the professors because he was saying something sloppy, such as using robots for peace. Although I missed the president, I'm actually much better.
A simple example of its excellence is the combat robot prepared for this world domination. Combat robots have their own weapons according to their characteristics, and the weapons are contained in chips, but this chip has strong compatibility. It's not just compatible with the developers' own other combat robots (that's already achieved by none other than Dr. R). The great thing about my chip is that it's also compatible with Dr. R's housework robot. The housework robot is a one-off model not for sale, so I developed a compatible chip without knowing the robot's design. I have to say that it is a divine work. Some people call this spec a wasteful spec for the enemy, but it's a silly idea. I'm developing a combat robot to show my excellence. It's not just about winning.
Let's return to the world domination plan. I built n combat robots, each with one different weapon chip installed. He intends to use it to seize the world's major facilities, but Dr. R will send in a robot to help with his housework to thwart the plan. The domestic help robot challenges my combat robot with its own weapon, but each battle takes a unit of time, and as a result of the battle, one of the robots is defeated and destroyed.
If my robot is destroyed as a result of a battle, the robot's weapon chips will be stolen by the opponent. The weapon chip of one of my robots is the weakness of one of my other robots, and every my robot has only one weakness of the weapon chip. For each of my robots, I can estimate the probability of defeat if the opponent has the weakness weapon of that robot and the probability of defeat if they do not.
If the opponent's housework robot is destroyed as a result of the battle, Dr. R will send the same housework robot through the spare body transfer system. At this time, the weapon chips already obtained by the opponent's robot are not lost. Dr. R uses the spare body transfer system indefinitely, but I can repair my combat robot in the meantime, so the probability of defeat described above does not change no matter how many times I fight. Also, the spare body transfer system can only be used where the housework robot was destroyed when it was destroyed, so the housework robot cannot challenge another of my combat robots immediately after being defeated.
It's only a matter of time before all n combat robots are destroyed, as Dr. R has unlimited spare body transfer systems. So, behind the scenes of fighting combat robots, I will work on developing more robots that can destroy the entire spare body transfer system. But how much time do I have left? How long would it take for Dr. R's robot to take the fastest strategy to destroy my n robots? You have to calculate it first. By the way, I would like to confirm how many such robots are defeated.
Input
The input consists of multiple cases. Each case is given in the following format.
n
p0 id0 w0
p1 id1 w1
..
..
..
p1 idn-1 wn-1
pi represents the probability that the i-th combat robot will be defeated when the opponent does not have a weak weapon.
idi represents a combat robot that has a weapon that is the weakness of the i-th combat robot.
wi represents the probability that the i-th combat robot will be defeated when the opponent has a weak weapon.
The end of the input is given by n = 0.
Each value meets the following conditions
2 ≤ n ≤ 100
pi and wi are represented by numbers with three decimal places.
0.001 ≤ pi <wi ≤ 1.000
idi! = i
The number of test cases does not exceed 500.
Output
Output the expected value of the time until the n combat robots are destroyed and the remainder of dividing the number of combinations of the destruction order by 1000000007 with a blank.
The expected value has an error of up to 1e-9 from the answer prepared by the judge.
Example
Input
4
0.200 3 0.500
0.100 0 0.400
0.900 1 1.000
0.400 2 0.600
2
0.600 1 0.800
0.500 0 1.000
9
0.200 7 0.600
0.400 0 0.500
0.700 8 1.000
0.100 4 0.400
0.200 2 0.600
0.100 6 0.400
0.100 5 0.400
0.600 3 0.900
0.500 1 0.900
9
0.300 8 0.900
0.700 3 0.800
0.300 0 0.900
0.700 6 0.800
0.200 5 0.700
0.200 2 0.700
0.700 4 0.800
0.700 1 0.800
0.300 7 0.900
0
Output
7.27777777778 1
2.66666666667 1
23.98412698413 72
11.36904761905 4
|
#include<cstdio>
#include<iostream>
#include<cmath>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
int n;
int id[100];
double p[100],w[100];
bool use[100];
long long int pascal[101][101];
for(int i=0;i<=100;i++){
pascal[i][0] = 1;
pascal[0][i] = 1;
}
for(int i=1;i<=100;i++){
for(int j=1;j<=100;j++)pascal[i][j] = (pascal[i-1][j] + pascal[i][j-1]) % 100000007;
}
for(;;){
scanf("%d",&n);
if(!n)break;
for(int i=0;i<n;i++){
scanf("%lf %d %lf",&p[i],&id[i],&w[i]);
use[i] = false;
}
double ans = 0.0;
int rem = n;
long long int pattern = 1;
for(int i=0;i<n;i++){
if(!use[i]){
use[i] = true;
int tmp = i;
vector<int> loop;
loop.push_back(tmp);
for(;;){
tmp = id[tmp];
if(tmp==i)break;
use[tmp] = true;
loop.push_back(tmp);
}
int num = 1;
double m = 1.0/p[loop[0]] - 1.0/w[loop[0]];
ans += 1.0/w[loop[0]];
for(int j=1;j<(int)loop.size();j++){
ans += 1.0/w[loop[j]];
if(abs(m-1.0/p[loop[j]] + 1.0/w[loop[j]])<1e-10){
num++;
}else if(m > 1.0/p[loop[j]] - 1.0/w[loop[j]]){
m = 1.0/p[loop[j]] - 1.0/w[loop[j]];
num = 1;
}
}
ans += m;
pattern = (pattern * num) % 100000007;
//cout << rem << " " << loop.size() << " " << pascal[rem-(int)loop.size()][loop.size()] << endl;
rem -= loop.size();
pattern = (pattern * pascal[rem][(int)loop.size()]) % 100000007;
}
}
printf("%.11lf %lld\n",ans,pattern);
}
}
|
Let's play a traditional game Nim. You and I are seated across a table and we have a hundred stones on the table (we know the number of stones exactly). We play in turn and at each turn, you or I can remove one to four stones from the heap. You play first and the one who removed the last stone loses.
In this game, you have a winning strategy. To see this, you first remove four stones and leave 96 stones. No matter how I play, I will end up with leaving 92-95 stones. Then you will in turn leave 91 stones for me (verify this is always possible). This way, you can always leave 5k + 1 stones for me and finally I get the last stone, sigh. If we initially had 101 stones, on the other hand, I have a winning strategy and you are doomed to lose.
Let's generalize the game a little bit. First, let's make it a team game. Each team has n players and the 2n players are seated around the table, with each player having opponents at both sides. Turns round the table so the two teams play alternately. Second, let's vary the maximum number ofstones each player can take. That is, each player has his/her own maximum number ofstones he/she can take at each turn (The minimum is always one). So the game is asymmetric and may even be unfair.
In general, when played between two teams of experts, the outcome of a game is completely determined by the initial number ofstones and the minimum number of stones each player can take at each turn. In other words, either team has a winning strategy.
You are the head-coach of a team. In each game, the umpire shows both teams the initial number of stones and the maximum number of stones each player can take at each turn. Your team plays first. Your job is, given those numbers, to instantaneously judge whether your team has a winning strategy.
Incidentally, there is a rumor that Captain Future and her officers of Hakodate-maru love this game, and they are killing their time playing it during their missions. You wonder where the stones are?. Well, they do not have stones but do have plenty of balls in the fuel containers!.
Input
The input is a sequence of lines, followed by the last line containing a zero. Each line except the last is a sequence of integers and has the following format.
n S M1 M2 ... M2n
where n is the number of players in a team, S the initial number of stones, and Mi the maximum number of stones i th player can take. 1st, 3rd, 5th, ... players are your team's players and 2nd, 4th, 6th, ... the opponents. Numbers are separated by a single space character. You may assume 1 ≤ n ≤ 10, 1 ≤ Mi ≤ 16, and 1 ≤ S ≤ 213.
Output
The out put should consist of lines each containing either a one, meaning your team has a winning strategy, or a zero otherwise.
Example
Input
1 101 4 4
1 100 4 4
3 97 8 7 6 5 4 3
0
Output
0
1
1
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> Pl;
#define vi vector<int>
#define vl vector<long long>
#define vvi vector< vector<int> >
#define vvl vector< vector<ll> >
#define vp vector<P>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define REPD(i, n) for (int i = (int)(n-1); i >= 0; i--)
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define FORD(i, a, b) for (int i = (int)(a); i >= (int)(b); i--)
#define INF 1e18
#define INFTY 1e9
const int mod = 1000000007;
#define SIZE_OF_ARRAY(array) (sizeof(array)/sizeof(array[0]))
template<class T> bool chmax(T &a, const T & b) {
if (a<b) {
a = b;
return true;
}
return false;
}
template<class T> bool chmin(T &a, const T & b) {
if (a>b) {
a = b;
return true;
}
return false;
}
//cout << fixed << setprecision(10) << y << endl;
struct edge {int to, cost;};
vector< vector<edge> > es;
int gcd(int a, int b) {
int r = a % b;
if (r == 0) return b;
return gcd(b, r);
}
ll lcm(ll a, ll b) {
return a/gcd(a, b)*b;
}
int main() {
while (true) {
int n, s;
cin >> n;
if (n == 0) break;
cin >> s;
int p[2*n];
REP(i, 2*n) {
cin >> p[i];
}
int dp[2*n][s+1];
REP(i, 2*n) {
REP(j, s+1) {
dp[i][j] = -1;
}
}
FOR(j, 1, s+1) {
REP(i, 2*n) {
if (j == 1) dp[i][j] = 0;
else {
FOR(k, 1, p[i]+1) {
if (j - k < 1) break;
else if (dp[(i+1)%(2*n)][j-k] == 0) dp[i][j] = 1;
}
if (dp[i][j] == -1) dp[i][j] = 0;
}
}
}
cout << dp[0][s] << endl;
}
return 0;
}
|
Example
Input
2 2 7
3 4
3 2
1 3
1 1
2 2
1 2
2 1
1 2
2 2
1 1
Output
5
|
#include <bits/stdc++.h>
#define fi first
#define se second
#define mp make_pair
using namespace std;
typedef pair <int, int> pii;
int p, r, t;
int l[310], nl[310];
int n[310][310], nn[310][310];
pii a[200010];
int cnt[310];
bool check(int mid){
for (int i = 1; i <= r; i++){
nl[i] = l[i];
}
for (int i = 1; i <= p; i++){
cnt[i] = 0;
for (int j = 1; j <= r; j++){
nn[i][j] = n[i][j], cnt[i] += n[i][j];
}
}
for (int i = 0; i <= mid; i++){
int P = a[i].fi, R = a[i].se;
nl[R]--, nn[P][R]--, cnt[P]--;
if (cnt[P] == 0){
for (int j = 1; j <= r; j++){
nl[j] += n[P][j];
}
}
}
int pd = 1;
while (pd){
pd = 0;
for (int i = 1; i <= p; i++){
int flag = 1, ppp = 1;
for (int j = 1; j <= r; j++){
if (nl[j] < nn[i][j]){
flag = 0;
break;
}
if (nn[i][j]) ppp = 0;
}
if (!flag || ppp) continue;
for (int j = 1; j <= r; j++){
nl[j] += n[i][j] - nn[i][j];
nn[i][j] = 0;
}
pd = 1;
}
}
for (int i = 1; i <= p; i++){
for (int j = 1; j <= r; j++){
if (nn[i][j]) return 1;
}
}
return 0;
}
int main(){
scanf("%d%d%d", &p, &r, &t);
for (int i = 1; i <= r; i++){
scanf("%d", &l[i]);
}
for (int i = 1; i <= p; i++){
for (int j = 1; j <= r; j++){
scanf("%d", &n[i][j]);
}
}
for (int i = 0; i < t; i++){
scanf("%d%d", &a[i].fi, &a[i].se);
}
if (!check(t - 1)){
printf("-1\n");
return 0;
}
int l = 0, r = t - 1;
while (l < r){
int mid = l + r >> 1;
if (!check(mid)) l = mid + 1;
else r = mid;
}
printf("%d\n", l + 1);
return 0;
}
|
Problem
Gaccho owns an N-sided field and M potatoes. Each field is numbered from 1 to N. Gaccho wants to increase the number of potatoes by planting and harvesting potatoes in the field.
Gaccho lives alone and can only manage fields up to the K side. In addition, the soil condition and area of each field vary, and the number of potatoes harvested and the number of potatoes that can be planted also vary. When potatoes are planted in field i, ai potatoes can be harvested for each potato planted in field i one year later. However, only bi potatoes can be planted in the field i at the maximum.
When you plant M or less potatoes in a field within K side, please find the maximum number of potatoes you can own one year later.
Constraints
* 1 ≤ N ≤ 15
* 1 ≤ M ≤ 104
* 1 ≤ K ≤ min (N, 3)
* 1 ≤ ai ≤ 103
* 1 ≤ bi ≤ 104
Input
The input is given in the following format.
NMK
a1 a2 ... aN
b1 b2 ... bN
Three integers N, M, K are given on the first line, separated by blanks.
N integers ai are given on the second line, separated by blanks.
N integers bi are given on the third line, separated by blanks.
Output
Output the maximum number of potatoes in one line.
Examples
Input
5 100 3
2 3 4 5 6
50 40 20 10 5
Output
280
Input
5 100 3
2 3 4 5 100
50 40 20 10 1
Output
339
|
#include <iostream>
#include <vector>
template<class T>
using vec = std::vector<T>;
int rec(int S, int N, int K, int money, vec<int> &a, vec<int> &b)
{
if (__builtin_popcount(S) == K) {
return money;
}
int res = 0;
for (int i = 0; i < N; i++) {
if (S >> i & 1) continue;
int m = std::min(b[i], money);
res = std::max(res,
rec(S | (1 << i), N, K, money - m, a, b) + a[i] * m);
}
return res;
}
int main()
{
int N, M, K;
std::cin >> N >> M >> K;
vec<int> a(N), b(N);
for (int i = 0; i < N; i++) {
std::cin >> a[i];
}
for (int i = 0; i < N; i++) {
std::cin >> b[i];
}
std::cout << rec(0, N, K, M, a, b) << std::endl;
return 0;
}
|
Hit and blow is a popular code-breaking game played by two people, one codemaker and one codebreaker. The objective of this game is that the codebreaker guesses correctly a secret number the codemaker makes in his or her mind.
The game is played as follows. The codemaker first chooses a secret number that consists of four different digits, which may contain a leading zero. Next, the codebreaker makes the first attempt to guess the secret number. The guessed number needs to be legal (i.e. consist of four different digits). The codemaker then tells the numbers of hits and blows to the codebreaker. Hits are the matching digits on their right positions, and blows are those on different positions. For example, if the secret number is 4321 and the guessed is 2401, there is one hit and two blows where 1 is a hit and 2 and 4 are blows. After being told, the codebreaker makes the second attempt, then the codemaker tells the numbers of hits and blows, then the codebreaker makes the third attempt, and so forth. The game ends when the codebreaker gives the correct number.
Your task in this problem is to write a program that determines, given the situation, whether the codebreaker can logically guess the secret number within the next two attempts. Your program will be given the four-digit numbers the codebreaker has guessed, and the responses the codemaker has made to those numbers, and then should make output according to the following rules:
* if only one secret number is possible, print the secret number;
* if more than one secret number is possible, but there are one or more critical numbers, print the smallest one;
* otherwise, print “????” (four question symbols).
Here, critical numbers mean those such that, after being given the number of hits and blows for them on the next attempt, the codebreaker can determine the secret number uniquely.
Input
The input consists of multiple data sets. Each data set is given in the following format:
N
four-digit-number1 n-hits1 n-blows1
...
four-digit-numberN n-hitsN n-blowsN
N is the number of attempts that has been made. four-digit-numberi is the four-digit number guessed on the i-th attempt, and n-hitsi and n-blowsi are the numbers of hits and blows for that number, respectively. It is guaranteed that there is at least one possible secret number in each data set.
The end of input is indicated by a line that contains a zero. This line should not be processed.
Output
For each data set, print a four-digit number or “????” on a line, according to the rules stated above.
Example
Input
2
1234 3 0
1245 3 0
1
1234 0 0
2
0123 0 4
1230 0 4
0
Output
1235
????
0132
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<cstdio>
#include<cassert>
using namespace std;
#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n) REP(i,0,n)
typedef pair<int,int> pii;
const int N = 10000;
void compute(int i,int *buf){
buf[0]=i/1000%10;
buf[1]=i/100%10;
buf[2]=i/10%10;
buf[3]=i%10;
}
pii hitAndBlow(int n,int q){
int hit=0,blow=0;
int buf1[5],buf2[5];
compute(n,buf1);
compute(q,buf2);
rep(i,4){
rep(j,4){
if (buf1[i] == buf2[j]){
if (i == j)hit++;
else blow++;
}
}
}
return make_pair(hit,blow);
}
int solve(vector<int> &a){
if (a.size() > 15)return -1;
rep(i,N){
int buf[5];
bool isok=true;
compute(i,buf);
rep(j,4)REP(k,j+1,4)if (buf[j] == buf[k]){isok=false;}
int cnt[5][5]={0};
rep(j,a.size()){
pii tmp = hitAndBlow(a[j],i);
cnt[tmp.first][tmp.second]++;
if (cnt[tmp.first][tmp.second] > 1)isok=false;
}
if (isok)return i;
}
return -1;
}
int main(){
int n;
while(cin>>n && n){
vector<pii> in(n);
vector<int> cand,query(n);
rep(i,n)cin>>query[i]>>in[i].first>>in[i].second;
rep(i,N){
bool isok=true;
int buf[5];
compute(i,buf);
rep(j,4)REP(k,j+1,4)if (buf[j] == buf[k]){isok=false;}
rep(j,n){
pii tmp =hitAndBlow(i,query[j]);
if (tmp.first == in[j].first && tmp.second == in[j].second);
else {
isok=false;
}
}
if (isok)cand.push_back(i);
}
sort(cand.begin(),cand.end());
int ans = cand.size() == 1?cand[0]:solve(cand);
if (ans !=-1)printf("%04d\n",ans);
else puts("????");
}
return false;
}
|
In the west of Tokyo, there is a city named “Academy City.” There are many schools and laboratories to develop psychics in Academy City.
You are a psychic student of a school in Academy City. Your psychic ability is to give acceleration to a certain object.
You can use your psychic ability anytime and anywhere, but there are constraints. If the object remains stationary, you can give acceleration to the object in any direction. If the object is moving, you can give acceleration to the object only in 1) the direction the object is moving to, 2) the direction opposite to it, or 3) the direction perpendicular to it.
Today’s training menu is to move the object along a given course. For simplicity you can regard the course as consisting of line segments and circular arcs in a 2-dimensional space. The course has no branching. All segments and arcs are connected smoothly, i.e. there are no sharp corners.
In the beginning, the object is placed at the starting point of the first line segment. You have to move the object to the ending point of the last line segment along the course and stop the object at that point by controlling its acceleration properly. Before the training, a coach ordered you to simulate the minimum time to move the object from the starting point to the ending point.
Your task is to write a program which reads the shape of the course and the maximum acceleration amax you can give to the object and calculates the minimum time to move the object from the starting point to the ending point.
The object follows basic physical laws. When the object is moving straight in some direction, with acceleration either forward or backward, the following equations hold:
v = v0 + at
and
s = v0t + (1/2)at2
where v, s, v0, a, and t are the velocity, the distance from the starting point, the initial velocity (i.e. the velocity at the starting point), the acceleration, and the time the object has been moving in that direction, respectively. Note that they can be simplified as follows:
v2 − v02 = 2as
When the object is moving along an arc, with acceleration to the centroid, the following equations hold:
a = v2/r
wher v, a, and r are the velocity, the acceleration, and the radius of the arc, respectively. Note that the object cannot change the velocity due to the criteria on your psychic ability.
Input
The input has the following format:
N amax
xa,1 ya,1 xb,1 yb,1
xa,2 ya,2 xb,2 yb,2
.
.
.
N is the number of line segments; amax is the maximum acceleration you can give to the object; (xa,i, ya,i) and (xb,i, yb,i) are the starting point and the ending point of the i-th line segment, respectively. The given course may have crosses but you cannot change the direction there.
The input meets the following constraints: 0 < N ≤ 40000, 1 ≤ amax ≤ 100, and -100 ≤ xai, yai, xbi, ybi ≤ 100.
Output
Print the minimum time to move the object from the starting point to the ending point with an relative or absolute error of at most 10-6. You may output any number of digits after the decimal point.
Examples
Input
2 1
0 0 1 0
1 1 0 1
Output
5.2793638507
Input
1 1
0 0 2 0
Output
2.8284271082
Input
3 2
0 0 2 0
1 -1 1 2
0 1 2 1
Output
11.1364603512
|
#include<cstdio>
#include<complex>
#include<cmath>
#include<utility>
#include<algorithm>
using namespace std;
typedef double Real;
const Real eps=1e-9;
const Real PI=acos(-1.0);
typedef pair<Real,Real> P;
typedef complex<Real> Point;
typedef complex<Real> Vector;
typedef pair<Point,Point> Segment;
template<class T> bool eq(T a,T b){
return abs(a-b)<eps;
}
template<class T> int sgn(T a){
if(eq(a,0.0)) return 0;
if(a>0) return 1;
return -1;
}
Real doP(Vector a,Vector b){
return (conj(a)*b).real();
}
Real arg(Vector v){
return atan2(v.imag(),v.real());
}
Real getAng(Segment s1,Segment s2){
//directed segments, res<=PI
Vector v1=s1.second-s1.first;
Vector v2=s2.second-s2.first;
Vector v=v2/v1;
Real ang=arg(v);
ang=abs(ang);
if(ang>PI) ang=PI*2-ang;
// printf("ang=%f\n",ang);
return ang;
}
P getCircle(Segment s1,Segment s2){
Real theta=getAng(s1,s2);
Real d=abs(s1.second-s2.first);
Real radius=1.0/sin(theta/2)*d/2;
// printf("d=%f,radius=%f\n",d,radius);
Point p=s1.first,q=s1.second,r=s2.first;
Real x=doP(p-q,r-q);
if(sgn(x)>0){
theta=PI*2-theta;
}
return P(radius,theta);
}
Segment segs[40400];
Real ls[40400],Mv[40400];
Real rs[40400],angs[40400];
int N;
Real Ma;
void input(){
scanf("%d%lf",&N,&Ma);
for(int i=0;i<N;i++){
double x1,y1,x2,y2;
scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
Point p1=Point(x1,y1);
Point p2=Point(x2,y2);
segs[i]=Segment(p1,p2);
}
}
P solveLine(Real v0,Real x,Real Mlast){
// printf("solve %f %f %f\n",v0,x,Mlast);
Real lb=0,ub=x;
P res;
bool ok=false;
for(int stage=0;stage<100;stage++){
Real mid=(ub+lb)/2;
Real m=sqrt(v0*v0+2.0*Ma*mid);
Real t=(m-v0)/Ma;
Real u2=m*m-2.0*Ma*(x-mid);
if(u2<-eps){
lb=mid;
continue;
}
u2=max(u2,0.0);
Real u=sqrt(u2);
Real t2=(m-u)/Ma;
if(sgn(Mlast-u)>=0){
res=P(u,t+t2);
lb=mid;
ok=true;
}else{
ub=mid;
}
}
if(ok==false){
Real t=(v0-Mlast)/Ma;
return P(Mlast,t);
}
return res;
}
Real solve(){
for(int i=0;i<N-1;i++){
P p=getCircle(segs[i],segs[i+1]);
rs[i]=p.first;
angs[i]=p.second;
Mv[i]=sqrt(Ma*rs[i]);
// printf("r=%f,ang=%f,mv=%f\n",rs[i],angs[i],Mv[i]);
}
for(int i=0;i<N;i++){
ls[i]=abs(segs[i].second-segs[i].first);
}
Mv[N-1]=0;
for(int i=N-1;i>=1;i--){
Real val=2.0*Ma*ls[i];
Real v0=Mv[i]*Mv[i]+val;
v0=sqrt(v0);
Mv[i-1]=min(Mv[i-1],v0);
}
Real t=0;
Real prevv=0;
for(int i=0;i<N;i++){
P p=solveLine(prevv,ls[i],Mv[i]);
t+=p.second;
prevv=p.first;
if(isinf(t)){
printf("%f %f %f\n",prevv,ls[i],Mv[i]);
}
// printf("t+=%f\n",p.second);
if(i!=N-1){
Real len=angs[i]*rs[i];
// printf("ang=%f,r=%f,v=%f\n",angs[i],rs[i],prevv);
Real t2=len/prevv;
t+=t2;
if(isinf(t)){
printf("ang=%f,r=%f,v=%f Mv=%f\n",angs[i],rs[i],prevv,Mv[i]);
return 0;
}
}
}
return t;
}
int main(){
input();
Real ans=solve();
printf("%.9f\n",ans);
return 0;
}
|
There is a grid that consists of W \times H cells. The upper-left-most cell is (1, 1). You are standing on the cell of (1,1) and you are going to move to cell of (W, H). You can only move to adjacent lower-left, lower or lower-right cells.
There are obstructions on several cells. You can not move to it. You cannot move out the grid, either. Write a program that outputs the number of ways to reach (W,H) modulo 1,000,000,009. You can assume that there is no obstruction at (1,1).
Input
The first line contains three integers, the width W, the height H, and the number of obstructions N. (1 \leq W \leq 75, 2 \leq H \leq 10^{18}, 0 \leq N \leq 30) Each of following N lines contains 2 integers, denoting the position of an obstruction (x_i, y_i).
The last test case is followed by a line containing three zeros.
Output
For each test case, print its case number and the number of ways to reach (W,H) modulo 1,000,000,009.
Example
Input
2 4 1
2 1
2 2 1
2 2
0 0 0
Output
Case 1: 4
Case 2: 0
|
#include <cstdio>
#include <vector>
#include <map>
#define repeat(i,n) for (int i = 0; (i) < (n); ++(i))
#define repeat_from(i,m,n) for (int i = (m); (i) < (n); ++(i))
typedef long long ll;
using namespace std;
const int mod = 1e9+9;
vector<vector<ll> > operator * (vector<vector<ll> > const & p, vector<vector<ll> > const & q) {
int n = p.size();
vector<vector<ll> > r(n, vector<ll>(n));
repeat (y,n) {
repeat (z,n) {
repeat (x,n) {
r[y][x] += p[y][z] * q[z][x] % mod;
r[y][x] %= mod;
}
}
}
return r;
}
vector<ll> operator * (vector<vector<ll> > const & p, vector<ll> const & q) {
int n = p.size();
vector<ll> r(n);
repeat (y,n) {
repeat (z,n) {
r[y] += p[y][z] * q[z] % mod;
r[y] %= mod;
}
}
return r;
}
vector<vector<ll> > unit_matrix(int n) {
vector<vector<ll> > e(n, vector<ll>(n));
repeat (i,n) e[i][i] = 1;
return e;
}
vector<vector<ll> > zero_matrix(int n) {
vector<vector<ll> > o(n, vector<ll>(n));
return o;
}
vector<vector<ll> > mul(vector<vector<ll> > const & p, vector<vector<ll> > const & q) { return p * q; }
template <typename T, typename F>
T powt(T x, ll y, T unit, F f) {
T z = unit;
for (ll i = 1; i <= y; i <<= 1) {
if (y & i) z = f(z, x);
x = f(x, x);
}
return z;
}
int main() {
for (int testcase = 1; ; ++ testcase) {
// input
int w; ll h; int n; scanf("%d%lld%d", &w, &h, &n);
if (w == 0 and h == 0 and n == 0) break;
map<ll,vector<int> > obsts;
repeat (i,n) {
int x; ll y; scanf("%d%lld", &x, &y);
-- x; -- y;
obsts[y].push_back(x);
}
// compute
vector<vector<ll> > f = zero_matrix(w);
repeat (i,w) {
for (int j : { i-1, i, i+1 }) if (0 <= j and j < w) {
f[i][j] = 1;
}
}
vector<ll> x(w);
x[0] = 1;
ll y = 0;
obsts[h-1].push_back(-1);
for (auto it : obsts) {
ll ny = it.first;
x = powt(f, ny-y, unit_matrix(w), mul) * x;
for (int obst : it.second) if (obst != -1) x[obst] = 0;
y = ny;
}
// output
printf("Case %d: %lld\n", testcase, x[w-1]);
}
return 0;
}
|
Problem Statement
Fox Ciel is practicing miniature golf, a golf game played with a putter club only. For improving golf skills, she believes it is important how well she bounces the ball against walls.
The field of miniature golf is in a two-dimensional plane and surrounded by $N$ walls forming a convex polygon. At first, the ball is placed at $(s_x, s_y)$ inside the field. The ball is small enough to be regarded as a point.
Ciel can shoot the ball to any direction and stop the ball whenever she wants. The ball will move in a straight line. When the ball hits the wall, it rebounds like mirror reflection (i.e. incidence angle equals reflection angle).
For practice, Ciel decided to make a single shot under the following conditions:
* The ball hits each wall of the field exactly once.
* The ball does NOT hit the corner of the field.
Count the number of possible orders in which the ball hits the walls.
Input
The input contains several datasets. The number of datasets does not exceed $100$. Each dataset is in the following format.
> $N$
> $s_x$ $s_y$
> $x_1$ $y_1$
> :
> :
> $x_N$ $y_N$
The first line contains an integer $N$ ($3 \leq N \leq 8$). The next line contains two integers $s_x$ and $s_y$ ($-50 \leq s_x, s_y \leq 50$), which describe the coordinates of the initial position of the ball. Each of the following $N$ lines contains two integers $x_i$ and $y_i$ ($-50 \leq x_i, y_i \leq 50$), which describe the coordinates of each corner of the field. The corners are given in counterclockwise order. You may assume given initial position $(s_x, s_y)$ is inside the field and the field is convex.
It is guaranteed that there exists a shoot direction for each valid order of the walls that satisfies the following condition: distance between the ball and the corners of the field $(x_i, y_i)$ is always greater than $10^{-6}$ until the ball hits the last wall.
The last dataset is followed by a line containing a single zero.
Output
For each dataset in the input, print the number of valid orders of the walls in a line.
Sample Input
4
0 0
-10 -10
10 -10
10 10
-10 10
0
Output for the Sample Input
8
Example
Input
4
0 0
-10 -10
10 -10
10 10
-10 10
0
Output
8
|
#include <set>
#include <cmath>
#include <cstdio>
#include <vector>
#include <cassert>
#include <algorithm>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
const double EPS=1e-8;
const double PI=acos(-1);
struct point{
double x,y;
point():x(0),y(0){}
point(double x,double y):x(x),y(y){}
point operator+(const point &a)const{ return point(x+a.x,y+a.y); }
point operator-(const point &a)const{ return point(x-a.x,y-a.y); }
bool operator==(const point &a)const{ return abs(x-a.x)<EPS && abs(y-a.y)<EPS; }
bool operator!=(const point &a)const{ return abs(x-a.x)>EPS || abs(y-a.y)>EPS; }
};
point operator*(double c,const point &a){ return point(c*a.x,c*a.y); }
inline double dot(const point &a,const point &b){ return a.x*b.x+a.y*b.y; }
inline double cross(const point &a,const point &b){ return a.x*b.y-a.y*b.x; }
inline point rot(const point &a,double theta){ return point(a.x*cos(theta)-a.y*sin(theta),a.x*sin(theta)+a.y*cos(theta)); }
inline double arg(const point &a){ double t=atan2(a.y,a.x); return t<0?t+2*PI:t; }
struct segment{
point a,b;
segment(){}
segment(const point &a,const point &b):a(a),b(b){}
};
typedef vector<point> polygon;
enum{CCW=1,CW=-1,ON=0};
inline int ccw(const point &a,const point &b,const point &c){
double rdir=cross(b-a,c-a);
if(rdir> EPS) return CCW;
if(rdir<-EPS) return CW;
return ON;
}
inline bool intersect(const segment &S1,const segment &S2){
if(max(S1.a.x,S1.b.x)+EPS<min(S2.a.x,S2.b.x)
|| max(S1.a.y,S1.b.y)+EPS<min(S2.a.y,S2.b.y)
|| max(S2.a.x,S2.b.x)+EPS<min(S1.a.x,S1.b.x)
|| max(S2.a.y,S2.b.y)+EPS<min(S1.a.y,S1.b.y)) return false;
return ccw(S1.a,S1.b,S2.a)*ccw(S1.a,S1.b,S2.b)<=0
&& ccw(S2.a,S2.b,S1.a)*ccw(S2.a,S2.b,S1.b)<=0;
}
inline bool cover(const segment &S,const point &p){
return abs(cross(S.a-p,S.b-p))<EPS && dot(S.a-p,S.b-p)<EPS;
}
inline point get_intersect(const segment &S1,const segment &S2){
double a1=cross(S1.b-S1.a,S2.b-S2.a);
double a2=cross(S1.b-S1.a,S1.b-S2.a);
if(abs(a1)<EPS){
if(cover(S1,S2.a)) return S2.a;
if(cover(S1,S2.b)) return S2.b;
if(cover(S2,S1.a)) return S1.a;
return S1.b;
}
return S2.a+a2/a1*(S2.b-S2.a);
}
bool is_perm(vector<int> a){
sort(a.begin(),a.end());
return unique(a.begin(),a.end())-a.begin()==a.size();
}
vector<int> simulate(point p,const polygon &F,double theta){
int n=F.size();
vector<int> res;
bool used[8]={};
while(res.size()<n){
point v(cos(theta),sin(theta));
segment S(p,p+200*v);
int i0=-1;
segment e; // 反射する辺
point q; // 反射する点
rep(i,n){
e=segment(F[i],F[(i+1)%n]);
if(intersect(S,e)){
q=get_intersect(S,e);
if(q!=p){
i0=i;
break;
}
}
}
assert(i0!=-1);
if(used[i0]) return res; // 同じ辺に二回反射したらダメ
used[i0]=true;
if(q==e.a || q==e.b) return res; // 角に当たったらダメ
res.push_back(i0);
// 反射角を求める
double phi=arg(e.b-e.a);
point dir=rot(q-p,-phi);
dir.y*=-1;
dir=rot(dir,phi);
theta=arg(dir);
p=q;
}
return res;
}
void dfs(point s,int cnt,int used,polygon G,vector<double> &theta){
int n=G.size();
if(cnt==n-1){
int i;
for(i=0;used&(1<<i);i++);
theta.push_back(arg(G[i]-s));
theta.push_back(arg(G[(i+1)%n]-s));
return;
}
rep(i,n) if(!(used&(1<<i))) {
theta.push_back(arg(G[i]-s));
theta.push_back(arg(G[(i+1)%n]-s));
segment e(G[i],G[(i+1)%n]);
polygon H(n);
rep(j,n){
point p=G[j];
// p を e に対称な位置に移す
double phi=arg(e.b-e.a);
point tmp=rot(p-e.a,-phi);
tmp.y*=-1;
H[j]=rot(tmp,phi)+e.a;
}
dfs(s,cnt+1,used|(1<<i),H,theta);
}
}
bool eq(double a,double b){ return abs(a-b)<EPS; }
int main(){
for(int n;scanf("%d",&n),n;){
point s; scanf("%lf%lf",&s.x,&s.y);
polygon F(n);
rep(i,n) scanf("%lf%lf",&F[i].x,&F[i].y);
vector<double> theta;
dfs(s,0,0,F,theta);
sort(theta.begin(),theta.end());
theta.erase(unique(theta.begin(),theta.end(),eq),theta.end());
theta.push_back(theta[0]+2*PI);
vector<double> phi;
rep(i,(int)theta.size()-1) phi.push_back((theta[i]+theta[i+1])/2);
set< vector<int> > ans;
// TLE が厳しいので 1 つ置きにシミュレーション. 2 つが同じ結果ならスキップしたものも同じ結果
vector<int> prev;
static bool skip[200000];
rep(i,phi.size()) skip[i]=false;
rep(i,phi.size()/2){
vector<int> hit=simulate(s,F,phi[2*i]);
if(hit.size()==n && is_perm(hit)){
ans.insert(hit);
if(hit==prev) skip[2*i-1]=true;
}
prev=hit;
}
rep(i,phi.size()/2+1){
if(2*i+1<phi.size() && !skip[2*i+1]){
vector<int> hit=simulate(s,F,phi[2*i+1]);
if(hit.size()==n && is_perm(hit)){
ans.insert(hit);
}
}
}
printf("%d\n",ans.size());
}
return 0;
}
|
Example
Input
3
0 1
0 0 0 1
0 1 0 2
0 2 0 3
Output
6.0000000000000000
|
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
constexpr ll TEN(int n) { return (n==0) ? 1 : 10*TEN(n-1); }
template<class T> using V = vector<T>;
template<class T> using VV = V<V<T>>;
template<class D>
struct Hungarian {
V<D> le, ri;
V<int> perm;
Hungarian(const VV<D> &c) {
int n = int(c.size()), m = int(c[0].size());
assert(n <= m);
le = V<D>(n, D(0)); ri = V<D>(m, D(0));
perm = V<int>(n);
V<int> to_r(n, -1), to_l(m, -1);
auto cost = [&](int l, int r) { return c[l][r] + le[l] + ri[r]; };
for (int l = 0; l < n; l++) {
V<bool> l_u(n), r_u(m);
V<int> tr(m, -1), min_l(m, l);
l_u[l] = true;
V<D> cost_buf(m);
for (int j = 0; j < m; j++) cost_buf[j] = cost(l, j);
while (true) {
int b = -1;
D d = numeric_limits<D>::max();
for (int j = 0; j < m; j++) {
assert(abs(cost_buf[j] - cost(min_l[j], j)) <= 1e-9);
if (!r_u[j] && cost(min_l[j], j) < d) {
b = j;
d = cost(min_l[j], j);
}
}
for (int i = 0; i < n; i++) if (l_u[i]) le[i] -= d;
for (int j = 0; j < m; j++) {
if (r_u[j]) ri[j] += d;
else cost_buf[j] -= d;
}
tr[b] = min_l[b];
int c = to_l[b];
if (c == -1) {
while (b != -1) {
int a = tr[b], z = to_r[a];
to_l[b] = a;
to_r[a] = b;
b = z;
}
break;
}
l_u[c] = r_u[b] = true;
for (int j = 0; j < m; j++) {
if (cost(c, j) < cost(min_l[j], j)) {
min_l[j] = c;
cost_buf[j] = cost(c, j);
}
}
}
}
perm = to_r;
}
};
using D = double;
const D PI = acos(D(-1)), EPS = 1e-10;
using P = complex<D>;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(20) << fixed;
D ans = 0;
int n;
cin >> n;
V<P> up(n), dw(n);
D x, y;
cin >> x >> y;
for (int i = 0; i < n; i++) {
cin >> x >> y; up[i] = P(x, y);
cin >> x >> y; dw[i] = P(x, y);
ans += abs(up[i]-dw[i]);
}
int l = int(up.size()), r = int(dw.size());
VV<D> cost(l, V<D>(r));
for (int i = 0; i < l; i++) {
for (int j = 0; j < r; j++) {
cost[i][j] = abs(up[i] - dw[j]);
}
}
auto perm = Hungarian<D>(cost).perm;
for (int i = 0; i < l; i++) {
ans += cost[i][perm[i]];
}
cout << ans << endl;
return 0;
}
|
You are given a tree $T$ and an integer $K$. You can choose arbitrary distinct two vertices $u$ and $v$ on $T$. Let $P$ be the simple path between $u$ and $v$. Then, remove vertices in $P$, and edges such that one or both of its end vertices is in $P$ from $T$. Your task is to choose $u$ and $v$ to maximize the number of connected components with $K$ or more vertices of $T$ after that operation.
Input
The input consists of a single test case formatted as follows.
$N$ $K$
$u_1$ $v_1$
:
$u_{N-1}$ $v_{N-1}$
The first line consists of two integers $N, K$ ($2 \leq N \leq 100,000, 1 \leq K \leq N$). The following $N-1$ lines represent the information of edges. The ($i+1$)-th line consists of two integers $u_i, v_i$ ($1 \leq u_i, v_i \leq N$ and $u_i \ne v_i $ for each $i$). Each $\\{u_i, v_i\\}$ is an edge of $T$. It's guaranteed that these edges form a tree.
Output
Print the maximum number of connected components with $K$ or more vertices in one line.
Examples
Input
2 1
1 2
Output
0
Input
7 3
1 2
2 3
3 4
4 5
5 6
6 7
Output
1
Input
12 2
1 2
2 3
3 4
4 5
3 6
6 7
7 8
8 9
6 10
10 11
11 12
Output
4
Input
3 1
1 2
2 3
Output
1
Input
3 2
1 2
2 3
Output
0
Input
9 3
1 2
1 3
1 4
4 5
4 6
4 7
7 8
7 9
Output
2
|
#include <bits/stdc++.h>
#define syosu(x) fixed<<setprecision(x)
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef pair<int,int> P;
typedef pair<double,double> pdd;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<string> vs;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef vector<pll> vpll;
typedef pair<int,P> pip;
typedef vector<pip> vip;
const int inf=1<<30;
const ll INF=1ll<<60;
const double pi=acos(-1);
const double eps=1e-8;
const ll mod=1e9+7;
const int dx[4]={-1,0,1,0},dy[4]={0,-1,0,1};
int n,m,res=0;
vi s;
vvi g;
int dfs(int v,int p){
vi a,b;
for(auto u:g[v]) if(u!=p){
a.push_back(dfs(u,v));
b.push_back((s[u]>=m?1:0));
s[v]+=s[u];
}
if(a.empty()) return 0;
int sum=0,N=b.size(),tmp=0;
for(auto i:b) sum+=i;
// cout<<a[0]<<' '<<b[0]<<endl;
for(int i=0;i<N;i++) tmp=max(tmp,sum-b[i]+a[i]);
// cout<<tmp<<endl;
res=max(res,tmp+(n-s[v]>=m?1:0));
vi c(N);
for(int i=0;i<N;i++) c[i]=a[i]-b[i];
if(N>=2){
sort(c.rbegin(),c.rend());
res=max(res,sum+c[0]+c[1]+(n-s[v]>=m?1:0));
}
// cout<<v+1<<' '<<tmp<<endl;
return max(tmp,sum);
}
int main(){
cin>>n>>m;
g=vvi(n);
s=vi(n,1);
for(int i=1;i<n;i++){
int u,v;
cin>>u>>v;
u--,v--;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(0,-1);
cout<<res<<endl;
}
|
BackGround
In the Demon's Plan, 108 demons who control the desire are competing in the programming contest day and night. The organizer, Patron, is trying to invite the demons to "Rix-Magna", a place where all the souls gather. Patron wants to send an invitation to a demon who hasn't sent an invitation yet, but he decides to let his familiars do it because the demons are all over the world and it's a hassle to go by himself. Patrons are smart and are trying to allocate which familiars are in charge of which demons so that the familiars work more equally.
Problem
There are N familiars and M demons. The distance between familiar i and devil j is Hi j.
I want each demon to have one familiar. Which familiar will visit which demon will be assigned according to the following conditions.
1. Minimize the maximum difference in the number of demons visited per familiar.
2. Minimize the maximum distance between the visiting demon and the familiar familiar after satisfying 1.
Output the maximum difference in the number of visiting demons per familiar on the first line, and the maximum distance between the demon and the familiar in charge on the second line.
Constraints
* 1 ≤ N ≤ 108
* 1 ≤ M ≤ 108
* 1 ≤ Hi j ≤ 109 (0 ≤ i <N, 0 ≤ j <M) (distance from familiar i to devil j)
Input
The input is given in the following format.
N M
H0 0 H0 1… H0 M−1
H1 0 H1 1… H1 M-1
..
..
HN−1 0 HN−1 1… HN−1 M−1
On the first line, the number N of familiars and the number M of demons are given as integers separated by blanks. The distance between the familiar and the devil is given as an integer in the following N lines. Hij represents the distance between familiar i and devil j.
Output
According to the conditions of the problem statement, output the maximum difference in the number of visiting demons per familiar on the first line, and the maximum distance between the demon and the familiar in charge on the second line.
Examples
Input
3 3
1 2 3
2 1 2
3 2 1
Output
0
1
Input
3 5
1 2 3 4 5
5 4 3 2 1
4 3 2 1 5
Output
1
2
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define EACH(i,a) for (auto& i : a)
#define FOR(i,a,b) for (ll i = (a); i < (b); ++i)
#define RFOR(i,a,b) for (ll i = (b)-1; i >= (a); --i)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) RFOR(i,0,n)
#define pb push_back
#define ALL(a) (a).begin(),(a).end()
const ll linf = 1e18;
const int inf = 1e9;
const double eps = 1e-12;
const double pi = acos(-1);
template<typename T>
istream& operator>>(istream& is, vector<T>& vec) {
EACH(x,vec)is>>x;
return is;
}
template<typename T>
ostream& operator<<(ostream& os, vector<T>& vec) {
REP(i, vec.size()) {
if(i) os << " ";
os << vec[i];
}
return os;
}
struct Edge {
ll to, cap, rev;
};
vector< vector<Edge> > G;
void add_edge(ll from, ll to, ll cap) {
G[from].pb({to, cap, (ll)G[to].size()});
G[to].pb({from, 0, (ll)G[from].size()-1});
}
ll dfs(ll v, ll t, ll f, const vector<ll>& dist) {
if (v == t) return f;
EACH(e, G[v]) {
if (e.cap > 0 && dist[e.to] == dist[v]+1) {
ll d = dfs(e.to, t, min(f, e.cap), dist);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
vector<ll> bfs(ll s) {
vector<ll> res(G.size(), linf);
res[s] = 0;
queue<ll> Q; Q.push(s);
while ( !Q.empty() ) {
ll v = Q.front(); Q.pop();
EACH(e, G[v]) {
if (e.cap > 0 && res[e.to] == linf) {
res[e.to] = res[v]+1;
Q.push(e.to);
}
}
}
return res;
}
ll max_flow(ll s, ll t) {
ll res = 0;
while (1) {
vector<ll> dist = bfs(s);
if (dist[t] == linf) break;
while (1) {
ll f = dfs(s, t, linf, dist);
if (f == 0) break;
res += f;
}
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m; cin >> n >> m;
int v1 = m / n;
int v2 = v1 + (m % n == 0 ? 0 : 1);
cout << v2-v1 << endl;
vector< vector<ll> > H(n, vector<ll>(m)); cin >> H;
ll ss = n + m, s = ss+1, t = s+1;
G.resize(t+1);
REP(i, m) {
add_edge(n+i, t, 1);
}
REP(i, n) {
add_edge(s, i, v1);
add_edge(ss, i, 1);
}
add_edge(s, ss, m-n*v1);
map<ll, vector<P>> ev;
REP(i, n) REP(j, m) {
ev[H[i][j]].pb({i, j});
}
ll f = 0;
ll ans = linf;
EACH(dt, ev) {
EACH(p, dt.second) {
assert(dt.first == H[p.first][p.second]);
add_edge(p.first, n+p.second, 1);
}
f += max_flow(s, t);
if (f == m) {
ans = dt.first;
break;
}
}
cout << ans << endl;
}
|
Find places where a string P is found within a text T. Print all indices of T where P found. The indices of T start with 0.
Constraints
* 1 ≤ length of T ≤ 1000
* 1 ≤ length of P ≤ 1000
* The input consists of alphabetical characters and digits
Input
In the first line, a text T is given. In the second line, a string P is given.
Examples
Input
aabaaa
aa
Output
0
3
4
Input
xyzz
yz
Output
1
Input
abc
xyz
Output
|
T = input()
P = input()
if len(P) > len(T):
pass
else:
p = len(P)
ans = []
for i in range(len(T)-len(P)+1):
tmp = ""
for j in range(i,i+p):
tmp += T[j]
if tmp == P:
ans.append(i)
for i in ans:
print(i)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.