input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
It is a balmy spring afternoon, and Farmer John's n cows are ruminating about link-cut cacti in their stalls. The cows, labeled 1 through n, are arranged so that the i-th cow occupies the i-th stall from the left. However, Elsie, after realizing that she will forever live in the shadows beyond Bessie's limelight, has formed the Mischievous Mess Makers and is plotting to disrupt this beautiful pastoral rhythm. While Farmer John takes his k minute long nap, Elsie and the Mess Makers plan to repeatedly choose two distinct stalls and swap the cows occupying those stalls, making no more than one swap each minute.
Being the meticulous pranksters that they are, the Mischievous Mess Makers would like to know the maximum messiness attainable in the k minutes that they have. We denote as pi the label of the cow in the i-th stall. The messiness of an arrangement of cows is defined as the number of pairs (i, j) such that i < j and pi > pj.
Input
The first line of the input contains two integers n and k (1 ≤ n, k ≤ 100 000) — the number of cows and the length of Farmer John's nap, respectively.
Output
Output a single integer, the maximum messiness that the Mischievous Mess Makers can achieve by performing no more than k swaps.
Examples
Input
5 2
Output
10
Input
1 10
Output
0
Note
In the first sample, the Mischievous Mess Makers can swap the cows in the stalls 1 and 5 during the first minute, then the cows in stalls 2 and 4 during the second minute. This reverses the arrangement of cows, giving us a total messiness of 10.
In the second sample, there is only one cow, so the maximum possible messiness is 0.
|
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.security.interfaces.DSAKey;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
public class a {
public static class in {
static BufferedReader reader;
static StringTokenizer tokenizer;
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
static String next() throws IOException {
while (!tokenizer.hasMoreTokens())
tokenizer = new StringTokenizer(reader.readLine());
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
static long nextLong() throws IOException {
return Long.parseLong(next());
}
}
public static long comp(int n, int r) {
r = Math.min(r, n - r);
long ans = 1;
for (int i = 1; i <= r; i++) {
ans = ans * (long) (n - r + i) / (long) i;
}
return ans;
}
public static class node {
long t;
long d;
int idx;
node(long t, long d, int idx) {
this.t = t;
this.d = d;
this.idx = idx;
}
}
public static long gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
public static int z[];
public static void Z_algorithm(char[] a, ArrayList<Long> arr) {
z = new int[a.length];
z[0] = a.length;
int l = 0, r = 0;
for (int i = 1; i < a.length; i++) {
if (i > r) {
l = r = i;
while (r < a.length && a[r - l] == a[r]
&& (long) arr.get(r - l) == (long) arr.get(r)) {
r++;
}
z[i] = r - l;
r--;
} else {
int k = i - l;
if (z[k] < r - i + 1)
z[i] = z[k];
else {
l = i;
while (r < a.length && a[r - l] == a[r]
&& (long) arr.get(r - l) == (long) arr.get(r))
r++;
z[i] = r - l;
r--;
}
}
}
}
public static int tree[];
public static int n;
public static void add(int idx, long val) {
while (idx <= n) {
tree[idx] += val;
idx += (idx & -idx);
}
}
public static int get(int idx) {
int g = 0;
while (idx > 0) {
g += tree[idx];
idx -= (idx & -idx);
}
return g;
}
public static void main(String[] args) throws IOException {
StringBuilder qq = new StringBuilder();
in.init(System.in);
PrintWriter out = new PrintWriter(System.out);
// source code
// String hostNamee = "http://";
// System.out.println(hostNamee.length());
n = in.nextInt();
int k = in.nextInt();
tree = new int[n + 1];
int a[] = new int[n + 1];
for (int i = 1; i <= n; i++) {
add(i, 1);
a[i] = i;
}
int o = 0;
for (int i = 0; i < Math.min(n / 2, k); i++) {
if (a[i + 1] == a[n - i])
break;
o++;
int temp = a[i + 1];
a[i + 1] = a[n - i];
a[n - i] = temp;
}
k -= o;
long ans = 0;
for (int i = 1; i <= n; i++) {
int f = get(a[i] - 1);
ans += (long) f;
add(a[i], -1);
}
System.out.println(ans);
out.close();
}
}
|
Kekoland is a country with n beautiful cities numbered from left to right and connected by n - 1 roads. The i-th road connects cities i and i + 1 and length of this road is wi kilometers.
When you drive in Kekoland, each time you arrive in city i by car you immediately receive gi liters of gas. There is no other way to get gas in Kekoland.
You were hired by the Kekoland president Keko to organize the most beautiful race Kekoland has ever seen. Let race be between cities l and r (l ≤ r). Race will consist of two stages. On the first stage cars will go from city l to city r. After completing first stage, next day second stage will be held, now racers will go from r to l with their cars. Of course, as it is a race, racers drive directly from start city to finish city. It means that at the first stage they will go only right, and at the second stage they go only left. Beauty of the race between l and r is equal to r - l + 1 since racers will see r - l + 1 beautiful cities of Kekoland. Cars have infinite tank so racers will take all the gas given to them.
At the beginning of each stage racers start the race with empty tank (0 liters of gasoline). They will immediately take their gasoline in start cities (l for the first stage and r for the second stage) right after the race starts.
It may not be possible to organize a race between l and r if cars will run out of gas before they reach finish.
You have k presents. Each time you give a present to city i its value gi increases by 1. You may distribute presents among cities in any way (also give many presents to one city, each time increasing gi by 1). What is the most beautiful race you can organize?
Each car consumes 1 liter of gas per one kilometer.
Input
The first line of the input contains two integers n and k (2 ≤ n ≤ 100 000, 0 ≤ k ≤ 109) — the number of cities in Kekoland and the number of presents you have, respectively.
Next line contains n - 1 integers. The i-th of them is wi (1 ≤ wi ≤ 109) — the length of the road between city i and i + 1.
Next line contains n integers. The i-th of them is gi (0 ≤ gi ≤ 109) — the amount of gas you receive every time you enter city i.
Output
Print a single line — the beauty of the most beautiful race you can organize.
Examples
Input
4 4
2 2 2
1 1 1 1
Output
4
Input
8 5
2 2 2 3 7 3 1
1 3 1 5 4 0 2 5
Output
7
Note
In first sample if you give one present to each city then it will be possible to make a race between city 1 and city 4.
In second sample you should add 1 to g5 and 4 to g6, then it will be possible to make a race between cities 2 and 8.
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch - '0' < 0 || ch - '0' > 9) {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch - '0' >= 0 && ch - '0' <= 9) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m, top;
int a[100010], b[100010], s[100010];
long long f[100010], g[100010];
struct Segment_Tree {
long long tg[100010 * 4], th[100010 * 4], tag[100010 * 4];
void update(int k) {
tg[k] = min(tg[k * 2], tg[k * 2 + 1]);
th[k] = min(th[k * 2], th[k * 2 + 1]);
}
void pushdown(int k) {
if (!tag[k]) return;
th[k * 2] += tag[k];
th[k * 2 + 1] += tag[k];
tag[k * 2] += tag[k];
tag[k * 2 + 1] += tag[k];
tag[k] = 0;
}
void build(int k, int l, int r) {
if (l == r) {
tg[k] = th[k] = 9999999999999999;
tag[k] = 0;
return;
}
int mid = (l + r) / 2;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
update(k);
}
void upgrade(int k, int l, int r, int x) {
if (l == r) {
tg[k] = th[k] = g[l];
return;
}
pushdown(k);
int mid = (l + r) / 2;
if (mid >= x)
upgrade(k * 2, l, mid, x);
else
upgrade(k * 2 + 1, mid + 1, r, x);
update(k);
}
void modi(int k, int l, int r, int x, int y, long long z) {
if (l >= x && r <= y) {
th[k] += z;
tag[k] += z;
return;
}
pushdown(k);
int mid = (l + r) / 2;
if (mid >= x) modi(k * 2, l, mid, x, y, z);
if (mid < y) modi(k * 2 + 1, mid + 1, r, x, y, z);
update(k);
}
int query(int k, int l, int r, int R, long long y) {
if (l > R) return -1;
if (l == r) return l;
pushdown(k);
int mid = (l + r) / 2;
long long tmp = min(y, th[k * 2]);
if (R > mid && tmp >= tg[k * 2 + 1] - m) {
int res = query(k * 2 + 1, mid + 1, r, R, tmp);
if (res != -1) return res;
}
if (tg[k * 2] - m <= y) return query(k * 2, l, mid, R, y);
return -1;
}
} T;
int ans;
int main() {
n = read();
m = read();
for (int i = 1; i < n; i++) b[i] = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++)
f[i] = f[i - 1] + a[i - 1] - b[i - 1], g[i] = g[i - 1] + b[i - 1] - a[i];
f[n + 1] = -9999999999999999;
s[0] = n + 1;
T.build(1, 1, n);
for (int i = n; i >= 1; i--) {
T.upgrade(1, 1, n, i);
while (top && f[s[top]] >= f[i]) {
if (top > 1)
T.modi(1, 1, n, s[top - 1] - 1, n, f[s[top]] - f[s[top - 1]]);
top--;
}
s[++top] = i;
if (top > 1) T.modi(1, 1, n, s[top - 1] - 1, n, f[s[top - 1]] - f[s[top]]);
int l = 0, r = top, pos = 0;
while (l <= r) {
int mid = (l + r) / 2;
if (f[i] - f[s[mid]] > m) {
pos = mid;
l = mid + 1;
} else
r = mid - 1;
}
int R = s[pos] - 1;
ans = max(ans, T.query(1, 1, n, R, 9999999999999999) - i + 1);
}
cout << ans << endl;
return 0;
}
|
Barney is standing in a bar and starring at a pretty girl. He wants to shoot her with his heart arrow but he needs to know the distance between him and the girl to make his shot accurate.
<image>
Barney asked the bar tender Carl about this distance value, but Carl was so busy talking to the customers so he wrote the distance value (it's a real number) on a napkin. The problem is that he wrote it in scientific notation. The scientific notation of some real number x is the notation of form AeB, where A is a real number and B is an integer and x = A × 10B is true. In our case A is between 0 and 9 and B is non-negative.
Barney doesn't know anything about scientific notation (as well as anything scientific at all). So he asked you to tell him the distance value in usual decimal representation with minimal number of digits after the decimal point (and no decimal point if it is an integer). See the output format for better understanding.
Input
The first and only line of input contains a single string of form a.deb where a, d and b are integers and e is usual character 'e' (0 ≤ a ≤ 9, 0 ≤ d < 10100, 0 ≤ b ≤ 100) — the scientific notation of the desired distance value.
a and b contain no leading zeros and d contains no trailing zeros (but may be equal to 0). Also, b can not be non-zero if a is zero.
Output
Print the only real number x (the desired distance value) in the only line in its decimal notation.
Thus if x is an integer, print it's integer value without decimal part and decimal point and without leading zeroes.
Otherwise print x in a form of p.q such that p is an integer that have no leading zeroes (but may be equal to zero), and q is an integer that have no trailing zeroes (and may not be equal to zero).
Examples
Input
8.549e2
Output
854.9
Input
8.549e3
Output
8549
Input
0.33e0
Output
0.33
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String s = scanner.next();
String[] s2 = s.split("e");
String pre = s2[0];
String sub = s2[1];
int subInt = Integer.valueOf(sub);
if (subInt == 0){
if (pre.endsWith(".0")){
System.out.println(pre.substring(0, pre.indexOf('.')));
}else{
System.out.println(pre);
}
return;
}
int pointIndex = pre.indexOf('.');
int needMoveStep = pre.length()-1-pointIndex;
int tailZero = subInt -needMoveStep;
if (tailZero > 0){
boolean isFirst = true;
for ( int i = 0; i < pre.length(); i++ ){
char c = pre.charAt(i);
if (c == '.'){
continue;
}
if (c == '0' && isFirst){
continue;
}
isFirst = false;
System.out.print(c);
}
for ( int i = 0; i < tailZero; i++ ){
System.out.print('0');
}
}else{
boolean first = true;
for ( int i = 0; i < pre.length(); i++ ){
char c = pre.charAt(i);
if (c == '.'){
continue;
}
if ( c == '0' ){
if (i < pointIndex + subInt && first
&& (! ( subInt == 0 && i+1 == pointIndex ) )){
continue;
}
}
first = false;
System.out.print(c);
if ( i == pointIndex + subInt
|| ( subInt == 0 && i+1 == pointIndex )){
if ( i != pre.length()-1 ){
System.out.print('.');
}
}
}
}
}
}
|
Cowboy Beblop is a funny little boy who likes sitting at his computer. He somehow obtained two elastic hoops in the shape of 2D polygons, which are not necessarily convex. Since there's no gravity on his spaceship, the hoops are standing still in the air. Since the hoops are very elastic, Cowboy Beblop can stretch, rotate, translate or shorten their edges as much as he wants.
For both hoops, you are given the number of their vertices, as well as the position of each vertex, defined by the X , Y and Z coordinates. The vertices are given in the order they're connected: the 1st vertex is connected to the 2nd, which is connected to the 3rd, etc., and the last vertex is connected to the first one. Two hoops are connected if it's impossible to pull them to infinity in different directions by manipulating their edges, without having their edges or vertices intersect at any point – just like when two links of a chain are connected. The polygons' edges do not intersect or overlap.
To make things easier, we say that two polygons are well-connected, if the edges of one polygon cross the area of the other polygon in two different directions (from the upper and lower sides of the plane defined by that polygon) a different number of times.
Cowboy Beblop is fascinated with the hoops he has obtained and he would like to know whether they are well-connected or not. Since he’s busy playing with his dog, Zwei, he’d like you to figure it out for him. He promised you some sweets if you help him!
Input
The first line of input contains an integer n (3 ≤ n ≤ 100 000), which denotes the number of edges of the first polygon. The next N lines each contain the integers x, y and z ( - 1 000 000 ≤ x, y, z ≤ 1 000 000) — coordinates of the vertices, in the manner mentioned above. The next line contains an integer m (3 ≤ m ≤ 100 000) , denoting the number of edges of the second polygon, followed by m lines containing the coordinates of the second polygon’s vertices.
It is guaranteed that both polygons are simple (no self-intersections), and in general that the obtained polygonal lines do not intersect each other. Also, you can assume that no 3 consecutive points of a polygon lie on the same line.
Output
Your output should contain only one line, with the words "YES" or "NO", depending on whether the two given polygons are well-connected.
Example
Input
4
0 0 0
2 0 0
2 2 0
0 2 0
4
1 1 -1
1 1 1
1 3 1
1 3 -1
Output
YES
Note
On the picture below, the two polygons are well-connected, as the edges of the vertical polygon cross the area of the horizontal one exactly once in one direction (for example, from above to below), and zero times in the other (in this case, from below to above). Note that the polygons do not have to be parallel to any of the xy-,xz-,yz- planes in general. <image>
|
#include <bits/stdc++.h>
using namespace std;
double eps(1e-10);
int sign(const double& x) { return (x > eps) - (x + eps < 0); }
bool equal(const double& x, const double& y) {
return x + eps > y && y + eps > x;
}
struct Point {
double x, y, z;
Point() {}
Point(const double& x, const double& y, const double& z) : x(x), y(y), z(z) {}
void print() const { printf("%f%f%f\n", x, y, z); }
void scan() { scanf("%lf%lf%lf", &x, &y, &z); }
double sqrlen() const { return x * x + y * y + z * z; }
double len() const { return sqrt(max(0., sqrlen())); }
bool operator<(const Point& b) const {
if (!equal(x, b.x)) {
return x < b.x;
}
if (!equal(y, b.y)) {
return y < b.y;
}
if (!equal(z, b.z)) {
return z < b.z;
}
return false;
}
double dirlen() const { return len() * ((*this) < Point(0, 0, 0) ? -1 : 1); }
Point operator+(const Point& b) const {
return Point(x + b.x, y + b.y, z + b.z);
}
Point operator-(const Point& b) const {
return Point(x - b.x, y - b.y, z - b.z);
}
double operator%(const Point& b) const { return x * b.x + y * b.y + z * b.z; }
Point operator*(const Point& b) const {
return Point(y * b.z - z * b.y, z * b.x - x * b.z, x * b.y - y * b.x);
}
Point zoom(const double& l) const {
double lambda(l / len());
return Point(lambda * x, lambda * y, lambda * z);
}
};
inline Point operator*(const double& x, const Point& a) {
return Point(x * a.x, x * a.y, x * a.z);
}
struct Plane {
Point o, norm;
};
struct Line {
Point s, d;
Line(const Point& s, const Point& d) : s(s), d(d) {}
};
Point intersection(const Line& a, const Line& b) {
double lambda(((b.s - a.s) * b.d).dirlen() / (a.d * b.d).dirlen());
return a.s + lambda * a.d;
}
vector<pair<Point, pair<int, int>>> evts;
void calc(const vector<Point>& points, const vector<Point>& q) {
Plane p1, p2;
p1.o = points[0];
p2.o = q[0];
p1.norm = (points[0] - points[1]) * (points[2] - points[0]);
p2.norm = (q[0] - q[1]) * (q[2] - q[0]);
p1.norm = p1.norm.zoom(1);
p2.norm = p2.norm.zoom(1);
if (sign((p1.norm * p2.norm).len()) == 0) {
return;
}
Point d(p1.norm * p2.norm);
Point g(d * p1.norm);
d = d.zoom(1);
g = g.zoom(1);
Line l(p1.o + (p2.o - p1.o) % p2.norm / (g % p2.norm) * g, d);
static vector<pair<Point, pair<int, int>>> vec;
vec.clear();
for (int i(0); i < (int)points.size(); i++) {
Point a(points[i]), b(points[(i + 1) % (int)points.size()]);
int da(sign((a - l.s) % g)), db(sign((b - l.s) % g));
if (da == db) {
} else {
Point crs(intersection(Line(a, b - a), l));
if (da != 0 && db != 0) {
evts.push_back(make_pair(crs, make_pair(da, 0)));
} else {
vec.push_back(make_pair(crs, make_pair(da, db)));
}
}
}
for (int i(0); i < (int)vec.size(); i++) {
if (vec[i].second.second == 0) {
if (vec[i].second.first != vec[(i + 1) % (int)vec.size()].second.second) {
evts.push_back(
make_pair(vec[i].first, make_pair(vec[i].second.first, 0)));
}
}
}
}
vector<Point> vec[2];
int main() {
for (int d(0); d < 2; d++) {
int n;
scanf("%d", &n);
for (int i(0); i < n; i++) {
Point p;
p.scan();
vec[d].push_back(p);
}
}
calc(vec[0], vec[1]);
for (auto& evt : evts) {
evt.second.second = 1;
}
calc(vec[1], vec[0]);
sort(evts.begin(), evts.end());
int ans(0);
int cur(0);
for (auto evt : evts) {
if (evt.second.second == 1) {
cur += evt.second.first;
} else {
if (cur != 0) {
ans += evt.second.first;
}
}
}
printf("%s\n", ans != 0 ? "YES" : "NO");
}
|
Gosha is hunting. His goal is to catch as many Pokemons as possible. Gosha has a Poke Balls and b Ultra Balls. There are n Pokemons. They are numbered 1 through n. Gosha knows that if he throws a Poke Ball at the i-th Pokemon he catches it with probability pi. If he throws an Ultra Ball at the i-th Pokemon he catches it with probability ui. He can throw at most one Ball of each type at any Pokemon.
The hunting proceeds as follows: at first, Gosha chooses no more than a Pokemons at which he will throw Poke Balls and no more than b Pokemons at which he will throw Ultra Balls. After that, he throws the chosen Balls at the chosen Pokemons. If he throws both Ultra Ball and Poke Ball at some Pokemon, he is caught if and only if he is caught by any of these Balls. The outcome of a throw doesn't depend on the other throws.
Gosha would like to know what is the expected number of the Pokemons he catches if he acts in an optimal way. In other words, he would like to know the maximum possible expected number of Pokemons can catch.
Input
The first line contains three integers n, a and b (2 ≤ n ≤ 2000, 0 ≤ a, b ≤ n) — the number of Pokemons, the number of Poke Balls and the number of Ultra Balls.
The second line contains n real values p1, p2, ..., pn (0 ≤ pi ≤ 1), where pi is the probability of catching the i-th Pokemon if Gosha throws a Poke Ball to it.
The third line contains n real values u1, u2, ..., un (0 ≤ ui ≤ 1), where ui is the probability of catching the i-th Pokemon if Gosha throws an Ultra Ball to it.
All the probabilities are given with exactly three digits after the decimal separator.
Output
Print the maximum possible expected number of Pokemons Gosha can catch. The answer is considered correct if it's absolute or relative error doesn't exceed 10 - 4.
Examples
Input
3 2 2
1.000 0.000 0.500
0.000 1.000 0.500
Output
2.75
Input
4 1 3
0.100 0.500 0.500 0.600
0.100 0.500 0.900 0.400
Output
2.16
Input
3 2 0
0.412 0.198 0.599
0.612 0.987 0.443
Output
1.011
|
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
int data = 0, m = 1;
char ch = 0;
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') {
m = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
data = (data << 1) + (data << 3) + (ch ^ 48);
ch = getchar();
}
return (m) ? data : -data;
}
const double eps = 1e-10;
const double inf = 1000000000.0;
int n, A, B;
double p[2][2005];
struct dp {
double v;
int c;
bool operator<(const dp &B) const { return (v != B.v) ? v < B.v : c > B.c; }
inline void reset() {
v = -inf;
c = 0;
}
} f[2005][2005], Ans;
void Solve(double md) {
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++) f[i][j].reset();
f[0][0] = (dp){0, 0};
for (int i = 0; i < n; i++)
for (int j = 0; j <= A; j++)
if (f[i][j].v != -inf) {
if (j ^ A) {
f[i + 1][j + 1] =
max(f[i + 1][j + 1], (dp){f[i][j].v + p[0][i + 1], f[i][j].c});
double c2 = 1.0 - ((1.0 - p[0][i + 1]) * (1.0 - p[1][i + 1]));
f[i + 1][j + 1] =
max(f[i + 1][j + 1], (dp){f[i][j].v + c2 - md, f[i][j].c + 1});
}
f[i + 1][j] =
max(f[i + 1][j], (dp){f[i][j].v + p[1][i + 1] - md, f[i][j].c + 1});
f[i + 1][j] = max(f[i + 1][j], (dp){f[i][j].v, f[i][j].c});
}
Ans = f[n][A];
return;
}
int main() {
n = gi();
A = gi();
B = gi();
double l = -2.0, r = 2.0, ret = 0;
for (int i = 0; i <= 1; i++)
for (int j = 1; j <= n; j++) scanf("%lf", &p[i][j]);
while (r - l > eps) {
double mid = (l + r) * 0.5;
Solve(mid);
if (Ans.c <= B)
ret = mid, r = mid - eps;
else
l = mid + eps;
}
Solve(ret);
printf("%.10lf\n", Ans.v + 1.0 * ret * (double)B);
return 0;
}
|
You are given a rectangular table 3 × n. Each cell contains an integer. You can move from one cell to another if they share a side.
Find such path from the upper left cell to the bottom right cell of the table that doesn't visit any of the cells twice, and the sum of numbers written in the cells of this path is maximum possible.
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of columns in the table.
Next three lines contain n integers each — the description of the table. The j-th number in the i-th line corresponds to the cell aij ( - 109 ≤ aij ≤ 109) of the table.
Output
Output the maximum sum of numbers on a path from the upper left cell to the bottom right cell of the table, that doesn't visit any of the cells twice.
Examples
Input
3
1 1 1
1 -1 1
1 1 1
Output
7
Input
5
10 10 10 -1 -1
-1 10 10 10 10
-1 10 10 10 10
Output
110
Note
The path for the first example:
<image>
The path for the second example:
<image>
|
#include <bits/stdc++.h>
using namespace std;
long long memo[5][100005];
int grid[5][100005];
int N;
long long DP(int start, int idx) {
if (idx == N) {
if (start == 2)
return 0;
else
return -1000000000000000;
}
if (idx > N) return -1000000000000000;
if (memo[start][idx] != -1) return memo[start][idx];
long long res = 0;
if (start == 0) {
res = DP(0, idx + 1);
res = max(res, DP(1, idx + 1) + grid[1][idx]);
res = max(res, DP(2, idx + 1) + grid[1][idx] + grid[2][idx]);
res = max(res, DP(2, idx + 2) + grid[1][idx] + grid[2][idx] +
grid[0][idx + 1] + grid[2][idx + 1] + grid[1][idx + 1]);
} else if (start == 1) {
res = DP(1, idx + 1);
res = max(res, DP(0, idx + 1) + grid[0][idx]);
res = max(res, DP(2, idx + 1) + grid[2][idx]);
} else {
res = DP(2, idx + 1);
res = max(res, DP(1, idx + 1) + grid[1][idx]);
res = max(res, DP(0, idx + 1) + grid[1][idx] + grid[0][idx]);
res = max(res, DP(0, idx + 2) + grid[1][idx] + grid[0][idx] +
grid[2][idx + 1] + grid[0][idx + 1] + grid[1][idx + 1]);
}
return memo[start][idx] = res + grid[start][idx];
}
int main() {
memset(memo, -1, sizeof memo);
ios_base::sync_with_stdio(0);
cin >> N;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < N; j++) {
cin >> grid[i][j];
}
}
cout << DP(0, 0);
}
|
Anton likes permutations, especially he likes to permute their elements. Note that a permutation of n elements is a sequence of numbers {a1, a2, ..., an}, in which every number from 1 to n appears exactly once.
One day Anton got a new permutation and started to play with it. He does the following operation q times: he takes two elements of the permutation and swaps these elements. After each operation he asks his friend Vanya, how many inversions there are in the new permutation. The number of inversions in a permutation is the number of distinct pairs (i, j) such that 1 ≤ i < j ≤ n and ai > aj.
Vanya is tired of answering Anton's silly questions. So he asked you to write a program that would answer these questions instead of him.
Initially Anton's permutation was {1, 2, ..., n}, that is ai = i for all i such that 1 ≤ i ≤ n.
Input
The first line of the input contains two integers n and q (1 ≤ n ≤ 200 000, 1 ≤ q ≤ 50 000) — the length of the permutation and the number of operations that Anton does.
Each of the following q lines of the input contains two integers li and ri (1 ≤ li, ri ≤ n) — the indices of elements that Anton swaps during the i-th operation. Note that indices of elements that Anton swaps during the i-th operation can coincide. Elements in the permutation are numbered starting with one.
Output
Output q lines. The i-th line of the output is the number of inversions in the Anton's permutation after the i-th operation.
Examples
Input
5 4
4 5
2 4
2 5
2 2
Output
1
4
3
3
Input
2 1
2 1
Output
1
Input
6 7
1 4
3 5
2 3
3 3
3 6
2 1
5 1
Output
5
6
7
7
10
11
8
Note
Consider the first sample.
After the first Anton's operation the permutation will be {1, 2, 3, 5, 4}. There is only one inversion in it: (4, 5).
After the second Anton's operation the permutation will be {1, 5, 3, 2, 4}. There are four inversions: (2, 3), (2, 4), (2, 5) and (3, 4).
After the third Anton's operation the permutation will be {1, 4, 3, 2, 5}. There are three inversions: (2, 3), (2, 4) and (3, 4).
After the fourth Anton's operation the permutation doesn't change, so there are still three inversions.
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e6 + 10;
int eli = 9;
int nozomi;
int n, Q;
int L[MAXN], R[MAXN], a[MAXN], b[MAXN];
long long change(int x, int u, int v) {
int p = x >> eli;
long long ret = 0;
for (int i = 0; i <= nozomi; i++) {
if (i < p) {
int pos = lower_bound(b + L[i], b + R[i] + 1, u) - b;
ret -= R[i] + 1 - pos;
pos = lower_bound(b + L[i], b + R[i] + 1, v) - b;
ret += R[i] + 1 - pos;
} else if (i > p) {
int pos = upper_bound(b + L[i], b + R[i] + 1, u) - b;
ret -= pos - L[i];
pos = upper_bound(b + L[i], b + R[i] + 1, v) - b;
ret += pos - L[i];
} else {
for (int i = L[p]; i <= R[p]; i++)
if (i < x) {
ret -= a[i] > u;
ret += a[i] > v;
} else if (i > x) {
ret -= a[i] < u;
ret += a[i] < v;
}
}
}
a[x] = v;
for (int i = L[p]; i <= R[p]; i++) b[i] = a[i];
sort(b + L[p], b + R[p] + 1);
return ret;
}
int main() {
scanf("%d%d", &n, &Q);
nozomi = n >> eli;
for (int i = 0; i <= (n >> eli); i++) L[i] = n + 1, R[i] = 0;
for (int i = 1; i <= n; i++) {
a[i] = b[i] = i;
L[i >> eli] = min(L[i >> eli], i);
R[i >> eli] = max(R[i >> eli], i);
}
long long ans = 0;
for (int i = 1; i <= Q; i++) {
int x, y;
scanf("%d%d", &x, &y);
int xx = a[x], yy = a[y];
ans += change(x, xx, yy);
ans += change(y, yy, xx);
printf("%lld\n", ans);
}
return 0;
}
|
It can be shown that any positive integer x can be uniquely represented as x = 1 + 2 + 4 + ... + 2k - 1 + r, where k and r are integers, k ≥ 0, 0 < r ≤ 2k. Let's call that representation prairie partition of x.
For example, the prairie partitions of 12, 17, 7 and 1 are:
12 = 1 + 2 + 4 + 5,
17 = 1 + 2 + 4 + 8 + 2,
7 = 1 + 2 + 4,
1 = 1.
Alice took a sequence of positive integers (possibly with repeating elements), replaced every element with the sequence of summands in its prairie partition, arranged the resulting numbers in non-decreasing order and gave them to Borys. Now Borys wonders how many elements Alice's original sequence could contain. Find all possible options!
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of numbers given from Alice to Borys.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1012; a1 ≤ a2 ≤ ... ≤ an) — the numbers given from Alice to Borys.
Output
Output, in increasing order, all possible values of m such that there exists a sequence of positive integers of length m such that if you replace every element with the summands in its prairie partition and arrange the resulting numbers in non-decreasing order, you will get the sequence given in the input.
If there are no such values of m, output a single integer -1.
Examples
Input
8
1 1 2 2 3 4 5 8
Output
2
Input
6
1 1 1 2 2 2
Output
2 3
Input
5
1 2 4 4 4
Output
-1
Note
In the first example, Alice could get the input sequence from [6, 20] as the original sequence.
In the second example, Alice's original sequence could be either [4, 5] or [3, 3, 3].
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long int n, cnt1;
vector<long long int> v(N);
map<long long int, long long int> m;
bool f(long long int x) {
m.clear();
for (long long int i = (long long int)0; i <= (long long int)n - 1; i++)
m[v[i]]++;
vector<long long int> last(x, 1);
long long int in = 2, cnt = x;
m[1] -= x;
while (m[in] > 0 && cnt > 0) {
long long int inc = m[in];
long long int cc = min(cnt, inc);
m[in] -= cc;
cnt = cc;
for (long long int i = (long long int)0; i <= (long long int)cc - 1; i++)
last[i] = in;
in *= 2;
}
multiset<long long int> la;
for (long long int i = (long long int)0; i <= (long long int)x - 1; i++)
la.insert(last[i]);
for (auto x : m) {
long long int in = x.first, cnt = x.second;
for (long long int i = (long long int)1; i <= (long long int)cnt; i++) {
auto it = la.lower_bound((in + 1) / 2);
if (it == la.end()) return false;
la.erase(it);
}
}
return true;
}
int main() {
cin >> n;
for (long long int i = (long long int)0; i <= (long long int)n - 1; i++)
cin >> v[i], cnt1 += (v[i] == 1);
long long int l = 0, r = cnt1 + 1;
while (l < r - 1) {
long long int m = l + (r - l) / 2;
if (f(m))
r = m;
else
l = m;
}
long long int mi = r;
if (mi > cnt1) {
cout << -1 << "\n";
return 0;
}
for (long long int i = (long long int)mi; i <= (long long int)cnt1; i++)
cout << i << " ";
}
|
Vladimir wants to modernize partitions in his office. To make the office more comfortable he decided to remove a partition and plant several bamboos in a row. He thinks it would be nice if there are n bamboos in a row, and the i-th from the left is ai meters high.
Vladimir has just planted n bamboos in a row, each of which has height 0 meters right now, but they grow 1 meter each day. In order to make the partition nice Vladimir can cut each bamboo once at any height (no greater that the height of the bamboo), and then the bamboo will stop growing.
Vladimir wants to check the bamboos each d days (i.e. d days after he planted, then after 2d days and so on), and cut the bamboos that reached the required height. Vladimir wants the total length of bamboo parts he will cut off to be no greater than k meters.
What is the maximum value d he can choose so that he can achieve what he wants without cutting off more than k meters of bamboo?
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 1 ≤ k ≤ 1011) — the number of bamboos and the maximum total length of cut parts, in meters.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the required heights of bamboos, in meters.
Output
Print a single integer — the maximum value of d such that Vladimir can reach his goal.
Examples
Input
3 4
1 3 5
Output
3
Input
3 40
10 30 50
Output
32
Note
In the first example Vladimir can check bamboos each 3 days. Then he will cut the first and the second bamboos after 3 days, and the third bamboo after 6 days. The total length of cut parts is 2 + 0 + 1 = 3 meters.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, a[N];
long long ans, k;
bool check(long long d, long long k) {
long long sum = 0;
for (int i = 1; i <= n; i++) sum += (a[i] + d - 1) / d;
return sum <= k;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i], k += a[i];
for (long long l = 1, r; l <= k; l = r + 1) {
r = k / (k / l);
if (check(r, k / r)) ans = max(ans, r);
}
cout << ans << endl;
return 0;
}
|
Smith wakes up at the side of a dirty, disused bathroom, his ankle chained to pipes. Next to him is tape-player with a hand-written message "Play Me". He finds a tape in his own back pocket. After putting the tape in the tape-player, he sees a key hanging from a ceiling, chained to some kind of a machine, which is connected to the terminal next to him. After pressing a Play button a rough voice starts playing from the tape:
"Listen up Smith. As you can see, you are in pretty tough situation and in order to escape, you have to solve a puzzle.
You are given N strings which represent words. Each word is of the maximum length L and consists of characters 'a'-'e'. You are also given M strings which represent patterns. Pattern is a string of length ≤ L and consists of characters 'a'-'e' as well as the maximum 3 characters '?'. Character '?' is an unknown character, meaning it can be equal to any character 'a'-'e', or even an empty character. For each pattern find the number of words that matches with the given pattern. After solving it and typing the result in the terminal, the key will drop from the ceiling and you may escape. Let the game begin."
Help Smith escape.
Input
The first line of input contains two integers N and M (1 ≤ N ≤ 100 000, 1 ≤ M ≤ 5000), representing the number of words and patterns respectively.
The next N lines represent each word, and after those N lines, following M lines represent each pattern. Each word and each pattern has a maximum length L (1 ≤ L ≤ 50). Each pattern has no more that three characters '?'. All other characters in words and patters are lowercase English letters from 'a' to 'e'.
Output
Output contains M lines and each line consists of one integer, representing the number of words that match the corresponding pattern.
Example
Input
3 1
abc
aec
ac
a?c
Output
3
Note
If we switch '?' with 'b', 'e' and with empty character, we get 'abc', 'aec' and 'ac' respectively.
|
#include <bits/stdc++.h>
using namespace std;
int Trie[5000050][5], tz;
int N, M;
int leaf[5000050];
int cnt[5000050];
char B[55];
int lc;
int chk[5000010];
int v[100010], vz;
int ans;
void dfs(int x, int y) {
if (B[x] == 0) {
if (chk[y] == 0) {
chk[y] = 1;
v[vz++] = y;
ans += cnt[y];
}
return;
}
if (B[x] != '?') {
int c = B[x] - 'a';
if (Trie[y][c] > 0) dfs(x + 1, Trie[y][c]);
} else {
dfs(x + 1, y);
for (int i = 0; i < 5; i++)
if (Trie[y][i] > 0) dfs(x + 1, Trie[y][i]);
}
}
void solve() {
scanf("%d%d", &N, &M);
for (int i = 0; i < N; i++) {
char ch[55];
scanf("%s", ch);
int L = (int)strlen(ch);
int now = 0;
for (int a = 0; a < L; a++) {
int c = ch[a] - 'a';
if (Trie[now][c] == 0) Trie[now][c] = ++tz;
now = Trie[now][c];
}
cnt[now]++;
}
for (int i = 0; i < M; i++) {
scanf("%s", B);
ans = 0;
dfs(0, 0);
printf("%d\n", ans);
for (int a = 0; a < vz; a++) chk[v[a]] = 0;
vz = 0;
}
}
int main() {
int Tc = 1;
for (int tc = 1; tc <= Tc; tc++) {
solve();
}
return 0;
};
|
One day Nikita found the string containing letters "a" and "b" only.
Nikita thinks that string is beautiful if it can be cut into 3 strings (possibly empty) without changing the order of the letters, where the 1-st and the 3-rd one contain only letters "a" and the 2-nd contains only letters "b".
Nikita wants to make the string beautiful by removing some (possibly none) of its characters, but without changing their order. What is the maximum length of the string he can get?
Input
The first line contains a non-empty string of length not greater than 5 000 containing only lowercase English letters "a" and "b".
Output
Print a single integer — the maximum possible size of beautiful string Nikita can get.
Examples
Input
abba
Output
4
Input
bab
Output
2
Note
It the first sample the string is already beautiful.
In the second sample he needs to delete one of "b" to make it beautiful.
|
"""
Satwik_Tiwari ;) .
28 june , 2020 - Sunday
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
import bisect
from heapq import *
from math import *
from collections import deque
from collections import Counter as counter # Counter(list) return a dict with {key: count}
from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl
#If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
#If the element is already present in the list,
# the right most position where element has to be inserted is returned
#==============================================================================================
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
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 = os.read(self._fd, max(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 = os.read(self._fd, max(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:
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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
#some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n") #as stdout.write always print sring.
def testcase(t):
for p in range(t):
solve()
def printlist(a) :
for p in range(0,len(a)):
out(str(a[p]) + ' ')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(a,b):
ans = 1
while(b>0):
if(b%2==1):
ans*=a
a*=a
b//=2
return ans
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
def isPrime(n) : # Check Prime Number or not
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
#===============================================================================================
# code here ;))
def bs(a,l,h,x):
while(l<h):
# print(l,h)
mid = (l+h)//2
if(a[mid] == x):
return mid
if(a[mid] < x):
l = mid+1
else:
h = mid
return l
def sieve(a): #O(n loglogn) nearly linear
#all odd mark 1
for i in range(3,((10**6)+1),2):
a[i] = 1
#marking multiples of i form i*i 0. they are nt prime
for i in range(3,((10**6)+1),2):
for j in range(i*i,((10**6)+1),i):
a[j] = 0
a[2] = 1 #special left case
return (a)
def bfs(g,st):
visited = [0]*(len(g))
visited[st] = 1
queue = []
queue.append(st)
new = []
while(len(queue) != 0):
s = queue.pop()
new.append(s)
for i in g[s]:
if(visited[i] == 0):
visited[i] = 1
queue.append(i)
return new
def chck(a):
n = len(a)
chnge= 0
i = 1
while(i<n):
if(a[i] == a[i-1]):
i+=1
continue
else:
chnge+=1
i+=1
if(chnge == 2):
if(a[0] == 'a'):
return True
if(chnge<2):
return True
return False
def solve():
s = list(inp())
n = len(s)
prea = []
preb = []
for i in range(0,n):
if(i==0):
if(s[i] == 'a'):
prea.append(1)
preb.append(0)
else:
preb.append(1)
prea.append(0)
continue
if(s[i] == 'a'):
preb.append(preb[i-1])
prea.append(prea[i-1] + 1)
else:
preb.append(preb[i-1]+1)
prea.append(prea[i-1])
prea.append(0)
preb.append(0)
ans = 0
for i in range(0,n):
for j in range(i,n):
ans = max(ans,prea[i-1] + prea[n-1] - prea[j] + preb[j] - preb[i-1])
ans = max(ans,prea[n-1])
print(ans)
#bbabbbaabbbb
testcase(1)
# testcase(int(inp()))
|
You are given a permutation p of length n. Remove one element from permutation to make the number of records the maximum possible.
We remind that in a sequence of numbers a1, a2, ..., ak the element ai is a record if for every integer j (1 ≤ j < i) the following holds: aj < ai.
Input
The first line contains the only integer n (1 ≤ n ≤ 105) — the length of the permutation.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation. All the integers are distinct.
Output
Print the only integer — the element that should be removed to make the number of records the maximum possible. If there are multiple such elements, print the smallest one.
Examples
Input
1
1
Output
1
Input
5
5 1 2 3 4
Output
5
Note
In the first example the only element can be removed.
|
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import javax.sound.midi.Synthesizer;
public class Main
{
private InputStream is;
private PrintWriter out;
int time = 0, freq[], start[], end[], dist[], black[], MOD = (int) (1e9 + 7), arr[], weight[][], x[], y[], parent[];
int MAX = 1000001, N, K;
long red[], ans = Long.MAX_VALUE;
ArrayList<Integer>[] amp;
ArrayList<Pair>[] pmp;
boolean b[];
boolean boo[][], b1[];
Pair prr[];
HashMap<Pair, Integer> hm = new HashMap();
int Dp[][] = new int[1100][1100];
void soln()
{
is = System.in;
out = new PrintWriter(System.out);
long s = System.currentTimeMillis();
solve();
// out.close();
out.flush();
// tr(System.currentTimeMillis() - s + "ms");
}
class ST1 // min ST
{
int arr[], st[];
int size;
ST1(int a[]) {
arr = a.clone();
size = 10 * arr.length;
st = new int[size];
build(0, arr.length - 1, 1);
}
void build(int ss, int se, int si) {
if (ss == se) {
st[si] = arr[ss];
return;
}
int mid = (ss + se) / 2;
int val = 2 * si;
build(ss, mid, val);
build(mid + 1, se, val + 1);
st[si] = gcd(st[val], st[val + 1]);
}
/*void update(int ss, int se, int idx, long val, int si) {
if (ss == se) {
// if(si==idx+1)
st[si] = val;
return;
}
int mid = (ss + se) / 2;
if (ss <= idx && idx <= mid) {
update(ss, mid, idx, val, 2 * si);
} else {
update(mid + 1, se, idx, val, 2 * si + 1);
}
int v = 2 * si;
st[si] = Math.min(st[v], st[v + 1]);
}*/
int get(int ss, int se, int l, int r, int si) {
if (l > se || r < ss || l > r)
return 0;
if (l <= ss && r >= se)
return st[si];
int mid = (ss + se) / 2;
int val = 2 * si;
return gcd(get(ss, mid, l, r, val), get(mid + 1, se, l, r, val + 1));
}
}
public static void main(String[] args) throws Exception
{
new Thread(null, new Runnable()
{
public void run()
{
try
{
// new Main().soln();
} catch (Exception e)
{
System.out.println(e);
}
}
}, "1", 1 << 26).start();
new Main().soln();
}
int D[][];
char ch[][], ch1[];
int hash = 29;
int x2, y2;
HashSet<Integer>[] hs = (HashSet<Integer>[]) new HashSet[110];
cell[] c;
boolean ar[] = new boolean[1000];
Pair[] p = new Pair[4];
int a1[] = new int[7];
int a2[] = new int[7];
int a3[] = new int[7];
int a4[] = new int[7];
private static class Comp implements Comparable<Comp>{
int ind;
BigInteger v;
@Override
public int compareTo(Comp arg0) {
if(v==arg0.v)
return this.ind-arg0.ind;
return this.v.compareTo(arg0.v);
}
}
private static class Comp1 implements Comparable<Comp1>{
int ind;
String v;
@Override
public int compareTo(Comp1 arg0) {
if(v.equals(arg0.v))
return this.ind-arg0.ind;
return this.v.compareTo(arg0.v);
}
}
void solve()
{
int n = ni();
int arr[] = na(n);
TreeSet<Integer> ts = new TreeSet<>();
TreeSet<Integer> ts1 = new TreeSet<>();
int ans[] = new int[n+10];
int cum[] = new int[n+10];
ans[arr[0]] --;
ts.add(arr[0]);
for(int i = 1;i<n;i++) {
Integer g = ts.ceiling(arr[i]);
if(g!=null && g==ts.last()) {
ans[g]++;
}
else if(g==null) {
cum[i]++;
}
ans[arr[i]] -= cum[i];
ts.add(arr[i]);
}
int max = -n-10, an = arr[0];
for(int i = 1;i<=n;i++) {
// System.out.println(ans[i]+" "+cum[i]);
if(max<(ans[i])) {
max = ans[i];
an = i;
}
}
System.out.println(an);
}
String check(String[] s) {
char ch[] = new char[] {'a','a','a','a'};
boolean b = false;
for(int i = 0;i<4;i++) {
if(i>0) {
if(ch[i]=='a') continue;
}
for(int j = i+1;j<4;j++) {
if(!s[i].equals(s[j])) {
if(ch[i] == 'a' && ch[j]=='a') ch[j] = 'b';
else if(ch[j]=='a') continue;
else {
System.out.println("NO");
System.exit(0);
}
}
else b = true;
}
}
return new String(ch);
}
boolean isVowel(char c) {
if(c=='a' || c=='e' ||c=='i' ||c=='o' ||c=='u' ) return true;
return false;
}
void recur1(int[] a1, int[] a2) {
for(int i = 1; i< 7;i++) {
for(int j = 1; j< 7;j++) {
ar[a1[i]*10+a2[j]] = true;
ar[a2[j]*10+a1[i]] = true;
}
}
}
int dfs(int x) {
b[x] = true;
for(int i : amp[x]) {
if(!b[i]) {
dist[i] = dist[x]+1;
arr[x] += dfs(i);
}
}
return ++arr[x];
}
boolean binaryS(int a, int b, int c, int d) {
double l = 0, r = 90;
for(int count = 0;count<=300;count++)
{
double mid = (l + r) / 2;
double temp = mid * Math.PI / 180;
double x1 = Math.cos(temp) * c;
double x2 = Math.sin(temp) * c;
temp = Math.PI / 2 - temp;
double y1 = Math.cos(temp) * d;
double y2 = Math.sin(temp) * d;
if ((x1 + y1 <= a) && (x2 + y2 <= b)) return true;
else if (x1 + y1 > a) l = mid;
else r = mid;
}
return false;
}
/*void bfs(int s, int n) {
b = new boolean[n];
dist = new int[n];
Arrays.fill(dist, 1000000);
dist[s] = 0;
b[s] = true;
Queue<Integer> q = new LinkedList<>();
q.add(s);
while(!q.isEmpty()) {
int y = q.poll();
for(int i : amp[y]) {
dist[i] = min(dist[i],dist[y]+1);
if(!b[i]) {
b[i] = true;
q.add(i);
}
}
}
}*/
boolean check(String s, String s1) {
char ch1[] = s.toCharArray(), ch2[] = s1.toCharArray();
int arr[] = new int[10];
for(char c : ch1) {
arr[c-'0']++;
}
int ans = 0;
for(char c:ch2) {
arr[c-'0']--;
}
for(int i:arr) ans += ((i>0)?i:0);
return ans==3;
}
void seive(int n)
{
start = new int[n];
for(int i = 2;i<n;i++) {
if(start[i]==0) {
for(int j = 2*i;j<n;j+=i) {
start[j] = i;
}
}
}
}
void print(int[][] arr)
{
int seed = 110, n = arr.length - 220;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
System.out.print(arr[i + seed][j + seed] + " ");
}
System.out.println();
}
System.out.println();
}
class cell implements Comparable<cell>
{
int s, d, p, i;
cell(int t, int d, int p, int i) {
this.s = t;
this.p = p;
this.d = d;
this.i = i;
}
public int compareTo(cell other) {
// return Integer.compare(val, other.val);
return Long.compare(d, other.d) != 0 ? (Long.compare(d, other.d)): (Long.compare(i,other.i));
// other.v));//((Long.compare(u, other.u) != 0 ? (Long.compare(u, other.u)):
// (Long.compare(v, other.v)))
// &(Long.compare(u, other.v) != 0 ? (Long.compare(u, other.v)):
// (Long.compare(v, other.u))));
}
public String toString() {
return this.d + " " + this.s +" "+this.p+" "+this.i;
}
}
int abs(int x)
{
return ((x > 0) ? x : -x);
}
long ret(int p)
{
if (p >= 0)
return 0;
else
return 1;
}
long val(int p, int a, int b)
{
if (p >= 0) {
return (a * 1l * p);
}
return (b * 1l * p);
}
public int getParent(int x)
{
while (parent[x] != x) {
parent[x] = parent[parent[x]];
x = parent[x];
}
return x;
}
void getFactors(int n, int x)
{
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
hs[x].add(i);
hs[x].add(n / i);
}
}
}
void recur(int a, int b, int k)
{
if (k == 0) {
if (a == x2 && b == y2)
ans++;
return;
}
recur(a, b + 1, k - 1);
recur(a, b - 1, k - 1);
recur(a + 1, b, k - 1);
recur(a - 1, b, k - 1);
}
int min(int a, int b)
{
return (a < b) ? a : b;
}
/*private class Cell implements Comparable<Cell> {
int u, v, s;
public Cell(int u, int v, int s) {
this.u = u;
this.v = v;
this.s = s;
}
public int hashCode() {
return Objects.hash();
}
public int compareTo(Cell other) {
return (Long.compare(s, other.s) != 0 ? (Long.compare(s, other.s))
: (Long.compare(v, other.v) != 0 ? Long.compare(v, other.v) : Long.compare(u, other.u)))
& ((Long.compare(s, other.s) != 0 ? (Long.compare(s, other.s))
: (Long.compare(u, other.v) != 0 ? Long.compare(u, other.v) : Long.compare(v, other.u))));
}
public String toString() {
return this.u + " " + this.v;
}
}*/
class Pair implements Comparable<Pair>
{
int u ,v,i;
Pair(int u, int v) {
this.u = u;
this.i = v;
}
Pair(int u, int v, int i) {
this.u = u;
this.v = v;
this.i = i;
}
public int hashCode() {
return Objects.hash();
}
public boolean equals(Object o) {
Pair other = (Pair) o;
return ((u == other.u && v == other.v));
}
public int compareTo(Pair other) {
// return Integer.compare(val, other.val);
return Long.compare(u, other.u) != 0 ? (Long.compare(u, other.u)) : (Long.compare(i, other.i));// ((Long.compare(u,
}
public String toString() {
return this.u + " " + this.v +" "+this.i;
}
}
long max(long a, long b)
{
if (a > b)
return a;
return b;
}
static class FenwickTree
{
int[] array; // 1-indexed array, In this array We save cumulative
// information to perform efficient range queries and
// updates
public FenwickTree(int size) {
array = new int[size + 1];
}
public int rsq(int ind) {
assert ind > 0;
int sum = 0;
while (ind > 0) {
sum += array[ind];
// Extracting the portion up to the first significant one of the
// binary representation of 'ind' and decrementing ind by that
// number
ind -= ind & (-ind);
}
return sum;
}
public int rsq(int a, int b) {
assert b >= a && a > 0 && b > 0;
return rsq(b) - rsq(a - 1);
}
public void update(int ind, int value) {
assert ind > 0;
while (ind < array.length) {
array[ind] += value;
// Extracting the portion up to the first significant one of the
// binary representation of 'ind' and incrementing ind by that
// number
ind += ind & (-ind);
}
}
public int size() {
return array.length - 1;
}
}
void buildGraph(int n)
{
for (int i = 0; i < n; i++) {
int x1 = ni(), y1 = ni();
amp[x1-1].add(y1-1);
amp[y1-1].add(x1-1);
}
}
long modInverse(long a, long mOD2)
{
return power(a, mOD2 - 2, mOD2);
}
long power(long x, long y, long m)
{
if (y == 0)
return 1;
long p = power(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
public int gcd(int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
/*static class ST
{
int arr[], lazy[], n;
ST(int a) {
n = a;
arr = new int[10 * n];
lazy = new int[10 * n];
}
void up(int l, int r, int val) {
update(0, n - 1, 0, l, r, val);
}
void update(int l, int r, int c, int x, int y, int val) {
if (lazy[c] != 0) {
lazy[2 * c + 1] += lazy[c];
lazy[2 * c + 2] += lazy[c];
if (l == r)
arr[c] += lazy[c];
lazy[c] = 0;
}
if (l > r || x > y || l > y || x > r)
return;
if (x <= l && y >= r)
{
lazy[c] += val;
return;
}
int mid = l + r >> 1;
update(l, mid, 2 * c + 1, x, y, val);
update(mid + 1, r, 2 * c + 2, x, y, val);
arr[c] = Math.max(arr[2 * c + 1], arr[2 * c + 2]);
}
int an(int ind) {
return ans(0, n - 1, 0, ind);
}
int ans(int l, int r, int c, int ind) {
if (lazy[c] != 0) {
lazy[2 * c + 1] += lazy[c];
lazy[2 * c + 2] += lazy[c];
if (l == r)
arr[c] += lazy[c];
lazy[c] = 0;
}
if (l == r)
return arr[c];
int mid = l + r >> 1;
if (mid >= ind)
return ans(l, mid, 2 * c + 1, ind);
return ans(mid + 1, r, 2 * c + 2, ind);
}
}*/
public static int[] shuffle(int[] a, Random gen)
{
for (int i = 0, n = a.length; i < n; i++) {
int ind = gen.nextInt(n - i) + i;
int d = a[i];
a[i] = a[ind];
a[ind] = d;
}
return a;
}
long power(long x, long y, int mod)
{
long ans = 1;
while (y > 0) {
if (y % 2 == 0) {
x = (x * x) % mod;
y /= 2;
} else {
ans = (x * ans) % mod;
y--;
}
}
return ans;
}
// To Get Input
// Some Buffer Methods
private byte[] inbuf = new byte[1024];
public 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) && 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));
}
}
|
Alice and Bob begin their day with a quick game. They first choose a starting number X0 ≥ 3 and try to reach one million by the process described below.
Alice goes first and then they take alternating turns. In the i-th turn, the player whose turn it is selects a prime number smaller than the current number, and announces the smallest multiple of this prime number that is not smaller than the current number.
Formally, he or she selects a prime p < Xi - 1 and then finds the minimum Xi ≥ Xi - 1 such that p divides Xi. Note that if the selected prime p already divides Xi - 1, then the number does not change.
Eve has witnessed the state of the game after two turns. Given X2, help her determine what is the smallest possible starting number X0. Note that the players don't necessarily play optimally. You should consider all possible game evolutions.
Input
The input contains a single integer X2 (4 ≤ X2 ≤ 106). It is guaranteed that the integer X2 is composite, that is, is not prime.
Output
Output a single integer — the minimum possible X0.
Examples
Input
14
Output
6
Input
20
Output
15
Input
8192
Output
8191
Note
In the first test, the smallest possible starting number is X0 = 6. One possible course of the game is as follows:
* Alice picks prime 5 and announces X1 = 10
* Bob picks prime 7 and announces X2 = 14.
In the second case, let X0 = 15.
* Alice picks prime 2 and announces X1 = 16
* Bob picks prime 5 and announces X2 = 20.
|
import java.util.*;
public class Main{
public static void main(String[] args) {
// Use the Scanner class
Scanner sc = new Scanner(System.in);
/*
int n = sc.nextInt(); // read input as integer
long k = sc.nextLong(); // read input as long
double d = sc.nextDouble(); // read input as double
String str = sc.next(); // read input as String
String s = sc.nextLine(); // read whole line as String
*/
int N = sc.nextInt();
int[] p = new int[N+1];
for(int i=2; i<=N; i++){
if(p[i]==0){
for(int j=i*2; j<=N; j+=i){
p[j]=i;
}
}
}
for(int i=0; i<=N; i++){
p[i]=i-p[i]+1;
}
int res = Integer.MAX_VALUE;
for(int i=p[N]; i<=N; i++){
res = Math.min(p[i], res);
}
System.out.println(res);
}
}
|
Oleg writes down the history of the days he lived. For each day he decides if it was good or bad. Oleg calls a non-empty sequence of days a zebra, if it starts with a bad day, ends with a bad day, and good and bad days are alternating in it. Let us denote bad days as 0 and good days as 1. Then, for example, sequences of days 0, 010, 01010 are zebras, while sequences 1, 0110, 0101 are not.
Oleg tells you the story of days he lived in chronological order in form of string consisting of 0 and 1. Now you are interested if it is possible to divide Oleg's life history into several subsequences, each of which is a zebra, and the way it can be done. Each day must belong to exactly one of the subsequences. For each of the subsequences, days forming it must be ordered chronologically. Note that subsequence does not have to be a group of consecutive days.
Input
In the only line of input data there is a non-empty string s consisting of characters 0 and 1, which describes the history of Oleg's life. Its length (denoted as |s|) does not exceed 200 000 characters.
Output
If there is a way to divide history into zebra subsequences, in the first line of output you should print an integer k (1 ≤ k ≤ |s|), the resulting number of subsequences. In the i-th of following k lines first print the integer li (1 ≤ li ≤ |s|), which is the length of the i-th subsequence, and then li indices of days forming the subsequence. Indices must follow in ascending order. Days are numbered starting from 1. Each index from 1 to n must belong to exactly one subsequence. If there is no way to divide day history into zebra subsequences, print -1.
Subsequences may be printed in any order. If there are several solutions, you may print any of them. You do not have to minimize nor maximize the value of k.
Examples
Input
0010100
Output
3
3 1 3 4
3 2 5 6
1 7
Input
111
Output
-1
|
#include <bits/stdc++.h>
using std::endl;
using std::map;
using std::priority_queue;
using std::string;
using std::vector;
int main(void) {
using std::cin;
using std::cout;
std::ios_base::sync_with_stdio(false);
cin.tie(0);
string S;
cin >> S;
const int N = S.size();
int lastInd = -1;
priority_queue<int> closed;
priority_queue<int> unclosed;
map<int, vector<int>> seqs;
for (int pos = 0; pos < N; ++pos) {
if (S[pos] == '0') {
if (unclosed.empty()) {
++lastInd;
closed.push(lastInd);
assert(seqs[lastInd].empty());
seqs[lastInd].push_back(pos);
} else {
const int ind = unclosed.top();
unclosed.pop();
seqs[ind].push_back(pos);
closed.push(ind);
}
} else {
assert(S[pos] == '1');
if (closed.empty()) {
unclosed.push(-1);
break;
}
const int ind = closed.top();
closed.pop();
seqs[ind].push_back(pos);
unclosed.push(ind);
}
}
if (!unclosed.empty()) {
cout << "-1\n";
} else {
cout << closed.size() << '\n';
while (!closed.empty()) {
const int ind = closed.top();
closed.pop();
cout << seqs[ind].size() << ' ';
for (const auto& index : seqs[ind]) cout << (index + 1) << ' ';
cout << '\n';
}
}
cout.flush();
return 0;
}
|
In BerSoft n programmers work, the programmer i is characterized by a skill r_i.
A programmer a can be a mentor of a programmer b if and only if the skill of the programmer a is strictly greater than the skill of the programmer b (r_a > r_b) and programmers a and b are not in a quarrel.
You are given the skills of each programmers and a list of k pairs of the programmers, which are in a quarrel (pairs are unordered). For each programmer i, find the number of programmers, for which the programmer i can be a mentor.
Input
The first line contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 0 ≤ k ≤ min(2 ⋅ 10^5, (n ⋅ (n - 1))/(2))) — total number of programmers and number of pairs of programmers which are in a quarrel.
The second line contains a sequence of integers r_1, r_2, ..., r_n (1 ≤ r_i ≤ 10^{9}), where r_i equals to the skill of the i-th programmer.
Each of the following k lines contains two distinct integers x, y (1 ≤ x, y ≤ n, x ≠ y) — pair of programmers in a quarrel. The pairs are unordered, it means that if x is in a quarrel with y then y is in a quarrel with x. Guaranteed, that for each pair (x, y) there are no other pairs (x, y) and (y, x) in the input.
Output
Print n integers, the i-th number should be equal to the number of programmers, for which the i-th programmer can be a mentor. Programmers are numbered in the same order that their skills are given in the input.
Examples
Input
4 2
10 4 10 15
1 2
4 3
Output
0 0 1 2
Input
10 4
5 4 1 5 4 3 7 1 2 5
4 6
2 1
10 8
3 5
Output
5 4 0 5 3 3 9 0 2 5
Note
In the first example, the first programmer can not be mentor of any other (because only the second programmer has a skill, lower than first programmer skill, but they are in a quarrel). The second programmer can not be mentor of any other programmer, because his skill is minimal among others. The third programmer can be a mentor of the second programmer. The fourth programmer can be a mentor of the first and of the second programmers. He can not be a mentor of the third programmer, because they are in a quarrel.
|
from bisect import *
n, k = map(int, input().split())
r = list(map(int, input().split()))
s = sorted(r)
l = [0] * n
for i in range(n):
l[i] = bisect_left(s, r[i])
for i in range(k):
x, y = map(int, input().split())
x -= 1
y -= 1
if r[x] < r[y]:
l[y] -= 1
elif r[x] > r[y]:
l[x] -= 1
print(*l)
|
On one of the planets of Solar system, in Atmosphere University, many students are fans of bingo game.
It is well known that one month on this planet consists of n^2 days, so calendars, represented as square matrix n by n are extremely popular.
Weather conditions are even more unusual. Due to the unique composition of the atmosphere, when interacting with sunlight, every day sky takes one of three colors: blue, green or red.
To play the bingo, you need to observe the sky for one month — after each day, its cell is painted with the color of the sky in that day, that is, blue, green or red.
At the end of the month, students examine the calendar. If at least one row or column contains only cells of one color, that month is called lucky.
Let's call two colorings of calendar different, if at least one cell has different colors in them. It is easy to see that there are 3^{n ⋅ n} different colorings. How much of them are lucky? Since this number can be quite large, print it modulo 998244353.
Input
The first and only line of input contains a single integer n (1 ≤ n ≤ 1000 000) — the number of rows and columns in the calendar.
Output
Print one number — number of lucky colorings of the calendar modulo 998244353
Examples
Input
1
Output
3
Input
2
Output
63
Input
3
Output
9933
Note
In the first sample any coloring is lucky, since the only column contains cells of only one color.
In the second sample, there are a lot of lucky colorings, in particular, the following colorings are lucky:
<image>
While these colorings are not lucky:
<image>
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1000005;
const long long MOD = 998244353;
const long long inv3 = 332748118;
long long n, ans;
long long Read() {
long long x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x * 10) + (c ^ 48);
c = getchar();
}
return x * f;
}
template <typename T>
void Put1(T x) {
if (x > 9) Put1(x / 10);
putchar(x % 10 ^ 48);
}
template <typename T>
void Put(T x, char c = -1) {
if (x < 0) putchar('-'), x = -x;
Put1(x);
if (c >= 0) putchar(c);
}
template <typename T>
T Max(T x, T y) {
return x > y ? x : y;
}
template <typename T>
T Min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T Abs(T x) {
return x < 0 ? -x : x;
}
long long qpow(long long x, long long y) {
long long ret = 1;
while (y) {
if (y & 1) ret = 1ll * ret * x % MOD;
x = 1ll * x * x % MOD;
y >>= 1;
}
return ret;
}
long long fac[MAXN], ifac[MAXN];
void init(long long x) {
fac[0] = ifac[0] = 1;
for (long long i = 1; i <= x; ++i) fac[i] = 1ll * fac[i - 1] * i % MOD;
ifac[x] = qpow(fac[x], MOD - 2);
for (long long i = x - 1; i >= 1; --i)
ifac[i] = ifac[i + 1] * (i + 1ll) % MOD;
}
long long C(long long x, long long y) {
if (x < y || y < 0) return 0;
return 1ll * fac[x] * ifac[y] % MOD * ifac[x - y] % MOD;
}
signed main() {
n = Read();
init(n);
for (long long i = 1; i <= n; ++i)
ans = (ans + ((i & 1) ? 1 : -1) * C(n, i) * qpow(3, (n - i) * n + i)) % MOD;
ans = ans * 2ll % MOD;
for (long long i = 1; i <= n; ++i)
ans = (ans - ((i & 1) ? -1 : 1) * 3 * C(n, i) * qpow(3, (n - i) * n) % MOD *
(qpow(1 - qpow(inv3, n - i), n) - 1)) %
MOD;
Put((ans + MOD) % MOD);
return 0;
}
|
Rajat Singh , a student of Delhi University is learning the ways of finding the mean of N numbers. Rajat is a weak students as far as mathematics is concerned and his teacher gave lots of problem sets to find the means. Please help rajat with his homework.
Note:- Truncate the Fraction Part of result.
Input
First Line contains Number of testcases. First line of each test case contains single integer N and next line contains N integer.
Output
Output a single Integer mean of data set in a single line
Constraints
1 ≤ T ≤ 10
1 ≤ N ≤ 100
1 ≤ x ≤ 10^9
SAMPLE INPUT
1
4
10
12
23
24
SAMPLE OUTPUT
17
|
t = input();
while(t > 0):
n = input(); cp = n; s = 0;
while(n > 0):
no = input(); s += no;
n -= 1;
print s / cp;
t -= 1;
|
Chintu and Mintu are good friends and they have so many coins of different amount so they decided to play a game using a stack consisting of N coins.
In this game, anyone can alternatively remove 1, 2 or 3 from the top, and the amount on the removed coins are added to their score.
Players have to play so that they obtain the maximum possible score.Both will play optimally and chintu make the first move.
Input Format:
First line will contain an integer T,number of test cases.
Each test case is followed by 2 lines-first line will contain a number N i.e. number of coins in the stack and
next line will contain N numbers i.e. amount etched on coins from top to bottom.
Output Format:
For each test case, print a single line containing chintu's maximum score.
Constraints:
1 ≤ T ≤ 5
1 ≤ N ≤ 10^5
0 ≤ amount on coins ≤ 10^9
SAMPLE INPUT
2
5
58 952 23 0 12
5
0 1 1 1 999
SAMPLE OUTPUT
1033
999
Explanation
In first test case, chintu will pick 58,952,23. If he play in any other way, you will not get a score of 1033.
In second test case, best option for chintu will be to pick up the first coin (with 0 score) at first. Then mintu will choose the next three coins,
and chintu will get the last coin.
Register for IndiaHacks
|
import sys
t = int(sys.stdin.readline())
def solve(xs):
xn = len(xs)
ss = [(0, 0)]
for ix in range(xn):
eix = xn - ix - 1
best = None
for dx in (1, 2, 3):
if eix + dx > xn:
continue
p = sum(xs[eix:eix + dx])
a, b = ss[ix + 1 - dx]
r = (b + p, a)
if best is None or best[0] < r[0]:
best = r
ss.append(best)
return ss[-1][0]
for tix in range(t):
sys.stdin.readline()
xs = map(int, sys.stdin.readline().split(' '))
print solve(xs)
|
From the childhood we are taught that a comes before b then b comes before c and so on.So whenever we try to sort any given string we sort it in that manner only placing a before b and so on.But what happens if we initially change the pattern of sorting .This question arrived in Arav's young mind. He thought what would the final string be like if z comes before a and a comes after c and so on. He got really puzzled in finding out the final sorted string.So he asks you for help.
He gives you two strings.One the pattern string P which decides the order of alphabets and the second that is the final string F which needs to be sorted. Help him by telling him the final sorted string.
Input:
The first line contains T denoting the number of test cases.Each test case consists of two lines.The first line contains the pattern string P indicating the relative ordering of alphabets and the second line contains the final string F to be sorted.
Output:
Print T lines where each line contains the sorted string.
Constraints:
1 ≤ T ≤ 10
|P| = 26
1 ≤ |F| ≤ 10^5
Both the string consists only of characters 'a'-'z'.
SAMPLE INPUT
2
wcyuogmlrdfphitxjakqvzbnes
jcdokai
miruqopsxthzdcnvkfbglwayje
wgfsyvno
SAMPLE OUTPUT
codijak
osnvfgwy
|
n = int(input())
for _ in range(n):
key = raw_input()
st = raw_input()
freq = [0 for i in range(26)]
for s in st : freq[ord(s)-ord('a')]+=1;
ans = ""
for i in key:
ans+=i * freq[ord(i)-ord('a')]
print(ans)
|
There are K lemurs on Madagascar and Kevin has N bananas. He has to give away all his bananas to lemurs. Lemurs are happy if all of them get the same number of bananas (even if they don't get any). In one minute Kevin can do one of the following:
Find one banana.
Discard one banana (eat).
Increase a population of lemurs on Madagascar by one.
If there are at least two lemurs remove one of them from Madagascar (don't ask how).
Help Kevin and find the minimum number of minutes Kevin needs to satisfy all the lemurs.
Input format:
The only line of the input contains two space-separated integers N and K.
Output format:
Output the single integer -- the minimum number of minutes.
Constraints:
1 ≤ K,N ≤ 10^5
K, N ≤ 50 in test data worth 33% of all points
SAMPLE INPUT
47 17
SAMPLE OUTPUT
2
|
s=f=1000000
n,k=map(int,raw_input().split())
if(n%k==0):
print 0
else:
j=k
for i in range(1000000):
a=n//k
b=(n//k)+1
x=b*k-n
y=n-(a*k)
g=min(x,y)
d=k-j
if((g+d)<f):
f=g+d
#print g,d
k+=1
k=j
for l in range(1000000):
#print "tatti"
if k<=0:
break
#print k
a=n//k
b=(n//k)+1
x=(b*k)-n
y=n-(a*k)
g=min(x,y)
d=j-k
if((g+d)<f):
f=g+d
#print g,d
k-=1
print f
|
A palindrome is a word that reads the same forward and backward. Given a string s, you need to make it a palindrome by adding 0 or more characters to the end of s, and remember, we want the palindrome to be as short as possible.
INPUT
First line is T, the number of test cases.
T strings follow, every string s needs to be converted to palindrome.
OUTPUT
Print the shortest possible length of a palindrome that John can generate.
CONSTRAINTS
1 ≤ T ≤ 50
s will contain between 1 and 50 characters, inclusive, palindrome can be larger in length.
Each character of s will be a lowercase letter ('a' - 'z').
SAMPLE INPUT
3
abab
abacaba
qwerty
SAMPLE OUTPUT
5
7
11
Explanation
CASE 1: "ababa" is the shortest palindrome that we can get.
CASE 2: Already a palindrome.
CASE 3: All characters are different.
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
n = int(raw_input())
i = 0
pal = ""
while i < n:
try:
s = raw_input()
except (EOFError):
break
if s == s[::-1]:
print len(s)
continue
j = 1
while j <= len(s):
pal = s+s[0:j][::-1]
if pal == pal[::-1]:
print len(pal)
pal = ""
break
j = j + 1
i = i + 1
|
Shinchan and Kazama both are playing with numbers. Shinchan gives Kazama an array of numbers and asks him to tell the minimum possible last number of a non decreasing sequence of length L.
Note- Check the sample I/O for more clarity.
INPUT-
Input consists of number of test cases T. Each test case contains size of array i.e N.
Next line contains N space separated elements of array.
Next line contains length of the non decreasing sequence i.e. L.
OUTPUT-
You have to print the minimum possible last number of a sequence and if their is no non-decreasing sequence of length L, then print "-1" without the quotes.
CONSTRAINTS-
1 ≤ T ≤ 100
1 ≤ N ≤ 10^6
1 ≤ a[i] ≤ 10^6
1 ≤ L ≤ N
SAMPLE INPUT
1
7
9 7 2 5 4 11 12
3
SAMPLE OUTPUT
11
Explanation
In sample input, possible non-decreasing sequences of length L=3 are
(9,11,12) , (7,11,12) , (2,5,11) , (2,4,11) , (2,5,12) , (2,4,12) , (2,11,12) , (5,11,12) , (4,11,12)
and the minimum last number is 11 for the sequences (2,5,11) and (2,4,11). Hence, the answer is 11.
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
def binarysearch(arr,target):
if target<=arr[0]:
return 0
if target>=arr[-1]:
return len(arr)-1
low=0
high=len(arr)-1
while low<=high:
mid=(low+high)/2
if arr[mid]==target:
return mid
elif arr[mid]<target:
low=mid+1
else:
high=mid-1
return low
if False:
a=input()
target=input()
print "inputs",a,target
print binarysearch(a,target)
def NonDecreaseMin(arr,length):
n=len(arr)
stack=[arr[0]]
for a in arr[1:]:
if a>=stack[-1]:
stack.append(a)
else:
relocation=binarysearch(stack,a)
stack[relocation]=a
if len(stack)<length:
return -1
else:
return stack[length-1]
T=int(raw_input())
for i in range(T):
raw_input()
arr=map(int,raw_input().split())
length=int(raw_input())
print NonDecreaseMin(arr,length)
|
Russian Translation Available
It is very important to understand relationship between variables to draw the right conclusion from a statistical analysis. The relationship between variables determines how the right conclusions are reached. Without an understanding of this, you can fall into many pitfalls that accompany statistical analysis and infer wrong results from your data.
Linear programming (LP; also called linear optimization) is a method to achieve the best outcome (such as maximum profit or lowest cost) in a mathematical model whose requirements are represented by linear relationships. More formally, linear programming is a technique for the optimization of a linear objective function, subject to linear equality and linear inequality constraints.
We are not going to present some LP theory, but let's have a look at combinatorial problem related to this theory.
Suppose you have a set of N variables. There are M relationships of some pairs of these variables. More formally, you have M relationships of type ai, bi, ci which means that variables ai and bi are in a relationship with quantitative coefficient ci. Quantitative coefficient of a connected set S of variables is a product of all relationship quantitative coefficients in this set.
Set S of variables is called connected if any two variables in this set are connected. Variables x and y are called connected if at least one of the following conditions is satisfied:
x and y are put in relationship directly
there is such a variable z that x and z are connected and y and z are connected too.
You are given a connected set S of N variables and M relationships. Your task is to leave some of these relationships in such a way that S is still connected and its quantitative coefficient is minimal possible.
Input
The first line contains one integer T denoting the number of test cases.
Each test case starts with a line containing 2 space-separated integer: N and M. Each of the following M lines contain description of one relationship: three different space-separated integers: a, b and c. a and b are different and from 1 to N each and denote numbers of vertices that are connected by this edge. c denotes quantitative coefficient of this relationship. It's guaranteed that the given set is initially connected.
Output
For each test case output one integer - minimal possible quantitative coefficient. As the the answer can be very big output it modulo 10^9 + 7.
Constraints
1 ≤ T ≤ 20
1 ≤ N ≤ 1500
1 ≤ M ≤ 31313
1 ≤ ai, bi ≤ N
1 ≤ ci ≤ 10^9
SAMPLE INPUT
1
3 3
1 2 1234567
2 3 2345678
1 3 3456789
SAMPLE OUTPUT
896631161
|
import collections
import heapq
MOD = 1000000007
def mst(graph, n):
total = 1
seen = set([1])
q = graph[1]
heapq.heapify(q)
while q:
cost, node = heapq.heappop(q)
if node in seen: continue
seen.add(node)
total = (total * cost) % MOD
if len(seen) == n: break
for child in graph[node]:
heapq.heappush(q, child)
return total
def solve(n, mss):
graph = collections.defaultdict(list)
for a, b, cost in mss:
graph[a].append((cost, b))
graph[b].append((cost, a))
return mst(graph, n)
if __name__ == '__main__':
for _ in range(int(raw_input())):
n, m = map(int, raw_input().split())
mss = [map(int, raw_input().split()) for _ in range(m)]
print solve(n, mss)
|
Shil decided to go for hill climbing on this weekend, but he doesn't have the map of all the hills. However, he's smart enough to make his own map.
There are N hills arranged on a line, each in the form of a vertical line segment with one endpoint on the ground. The hills are numbered with numbers from 1 to N from left to right. The i^th hill stands at the position xi with its top at height yi.
A pair (a, b) ( where a < b ) is called beautiful if and only if Shil will be able to see the peak of b^th hill standing on the top of a^th hill.
In order to make his own map, Shil needs total number of beautiful pairs. As Shil is not a very good programmer, he asks for your help.
Assume that Shil's height is very small as compared to the height of hills. (Really!) Thus, we can assume that Shil's eyes are exactly at the height of peak if he is standing at peak of some hill.
You can also assume that Shil is able to see peak of certain hills if distance between peak and Shil's sight is less than 10^-4.
Input format:
The first line of the input contains a single integer N , the number of hills. The next N lines describe the hills. The i^th of them contains two space-separated integers xi, yi , the position and the height of the i^th hill. The hills are given in the ascending order of xi, i.e., xi < xj for i < j.
Output format:
Print the total number of beautiful pairs.
Constraints:
2 ≤ N ≤ 1000
1 ≤ xi , yi ≤ 10^9
SAMPLE INPUT
4
1 9
2 3
3 7
4 1SAMPLE OUTPUT
4
Explanation
All the beautiful pairs are (1,2),(1,3),(2,3),(3,4)
|
n=input()
hills=[]
for _ in range(n):
hills.append(map(int,raw_input().split()))
count=0
for a in range(n):
x1=hills[a][0]
y1=hills[a][1]
mcurr=(100000000,1)
for b in range(a+1,n):
#if (hills[b][0]-hills[a][0]>10000):
# break
#if hills[b][1]>hills[a][1]:
# count+=1
#print a,b
# break
x2=hills[b][0]
y2=hills[b][1]
m=((y1-y2),(x2-x1))
if m[0]*mcurr[1]<=mcurr[0]*m[1]:
mcurr=m
count+=1
#print a,b
#else: print "missed",a,b,m,mcurr
print count
|
Tanmay is a legendary spammer - everyone in the spamming world knows and admires his abilities to spam anyone, anytime, anywhere. He decided to guide one of his mentors, named Arjit, as part of the Apex body of spamming.
Tanmay has no doubts on his skills of teaching and making his mentor, Arjit, learn about the art of spamming. But, he surely has serious doubt on Arjit's skills of learning, implementing and executing whatever he has decided to teach him as part of the syllabus of spamming.
Tanmay has sent Arjit to test his skills, but he's getting extremely anxious about the performance of his mentee. So, to calm himself down he asks you to help him find out the maximum and the minimum productivity attained by Arjit in his travel.
Arjit has the option to visit N Facebook groups - where every Facebook group has some potential which can be negative, zero or positive. Now, he can decide to visit a group if he wants to or not. (Depending on the lessons taught to him by the great master!) The total productivity attained by Arjit is the product of all the groups he decides to visit.
Given the values of all the groups, find out the maximum and minimum spamming potential he can achieve and let Tanmay know about it, so that he calm himself down.
Input format:
The first line contains an integer, T, denoting the number of test cases. Each line of the test case contains an integer, N, denoting the size of the array. The next line contains N integers, denoting the value of the numbers in the array.
Output format:
Print the maximum product you can obtain followed by the minimum product. A space separates both these outputs. Answer to each test case is on a new line.
Constraints:
1 ≤ T ≤ 500
1 ≤ N ≤ 18
-10 ≤ Ni ≤ 10
Note:
In some cases only one element may be considered for minimum or maximum product.
If the array is (1, 2, 3), minimum product is 1 whereas maximum product is 6.
When the array is (-1, -2), minimum product is -2 whereas maximum product is 2.
SAMPLE INPUT
2
4
1 0 2 10
3
0 0 0
SAMPLE OUTPUT
20 0
0 0
Explanation
In the first test case, the maximum product is the product of all the numbers except 0, whereas the minimum product is the product of all numbers including 0.
In the second test case, the maximum and minimum product both are 0 as 0 is the only available number.
|
def prod(xs):
p = 1
for x in xs:
p *= x
return p
def solve(xs):
negatives = sorted(x for x in xs if x < 0)
positives = sorted(x for x in xs if x > 0)
zeros = [0] if 0 in xs else []
if len(negatives) % 2 == 0: maxi = negatives + positives
else: maxi = negatives[:-1] + positives
if not maxi and zeros : maxi = zeros
elif not maxi: maxi = negatives[-1:]
if len(negatives) % 2 == 1: mini = negatives + positives
elif len(negatives) >= 2: mini = negatives[:-1] + positives
else: mini = (zeros + positives)[:1]
return '{} {}'.format(prod(maxi), prod(mini))
if __name__ == '__main__':
for _ in range(int(raw_input())):
raw_input()
print solve(map(int, raw_input().split()))
|
Zeke loves to spend time with Penny and likes her. Penny is having an issue to solve a mathematics problem and is confused. She seeks Zeke's help as she feels he could help her with the problem. He finds this problem very simple. The problem is to count the number of unique triplets of different numbers (N1, N2, N3), where Ni could be any positive integer from 1 to Ni, inclusive (i = 1, 2, 3). Here the numbers can not be repeated in a triplet set.
This looks simple right?
But oops !!!! There is a catch here which was missed by Zeke that the numbers N1, N2, N3 could be well up to 10^18.
Zeke finds it difficult due to large numbers in stake and needs your help for them so that he can give a solution to Penny. You need to find an optimal solution of the number of unique triplets possible which the above conditions satisfied.
Since, the answer could be quite large. Hence you should output it modulo 10^9 + 7.
Input:
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
Each line of a test case contains three space-separated integers N1, N2, N3.
Output:
For each test case, output a single line containing the number of required triples modulo 10^9 + 7.
Constraints
1 ≤ T ≤ 10^3
1 ≤ Ni ≤ 10^18
Sample Input:
5
3 3 3
2 3 2
29 11 1994
1 2 3
1 1 50
Sample Output:
6
2
613536
1
0
Explanation
Case 1. We have the following triples composed of different numbers up to 3:
(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)
Case 2. Here the triplets are:
(1, 3, 2)
(2, 3, 1)
Case 3. 613536 triplets exist
Case 4. Here the only triplet is (1, 2, 3).
Case 5. The only choice for N1 and for is N2 is 1, so any such triple will have the same numbers which does not satisfy the conditions. Hence, no triplets are possible.
SAMPLE INPUT
5
3 3 3
2 3 2
29 11 1994
1 2 3
1 1 50
SAMPLE OUTPUT
6
2
613536
1
0
|
for _ in range(int(raw_input())):
a = sorted(map(int, raw_input().split()))
ans = a[0]
for i in range(1, 3):
a[i] -= i
if a[i] < 1:
ans = 0
ans *= a[i]
print ans % 1000000007
|
Given are a sequence of N positive integers A_1, A_2, \ldots, A_N and another positive integer S.
For a non-empty subset T of the set \\{1, 2, \ldots , N \\}, let us define f(T) as follows:
* f(T) is the number of different non-empty subsets \\{x_1, x_2, \ldots , x_k \\} of T such that A_{x_1}+A_{x_2}+\cdots +A_{x_k} = S.
Find the sum of f(T) over all 2^N-1 subsets T of \\{1, 2, \ldots , N \\}. Since the sum can be enormous, print it modulo 998244353.
Constraints
* All values in input are integers.
* 1 \leq N \leq 3000
* 1 \leq S \leq 3000
* 1 \leq A_i \leq 3000
Input
Input is given from Standard Input in the following format:
N S
A_1 A_2 ... A_N
Output
Print the sum of f(T) modulo 998244353.
Examples
Input
3 4
2 2 4
Output
6
Input
5 8
9 9 9 9 9
Output
0
Input
10 10
3 1 4 1 5 9 2 6 5 3
Output
3296
|
N, S = map(int, input().split())
A = list(map(int, input().split()))
mod = 998244353
L = [[0 for i in range(S+1)] for j in range(N+1)]
L[0][0] = 1
for j, a in enumerate(A):
for i in range(S+1):
if i < a:
L[j+1][i] = (2 * L[j][i]) % mod
else:
L[j+1][i] = (2 * L[j][i] + L[j][i-a]) % mod
print(L[N][S])
|
Given is a permutation P_1, \ldots, P_N of 1, \ldots, N. Find the number of integers i (1 \leq i \leq N) that satisfy the following condition:
* For any integer j (1 \leq j \leq i), P_i \leq P_j.
Constraints
* 1 \leq N \leq 2 \times 10^5
* P_1, \ldots, P_N is a permutation of 1, \ldots, N.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1 ... P_N
Output
Print the number of integers i that satisfy the condition.
Examples
Input
5
4 2 5 1 3
Output
3
Input
4
4 3 2 1
Output
4
Input
6
1 2 3 4 5 6
Output
1
Input
8
5 7 4 2 6 8 1 3
Output
4
Input
1
1
Output
1
|
#include<bits/stdc++.h>
using namespace std;
int n,r,x,m=0x3f3f3f3f;
int main()
{
cin>>n;
for(int i=1;i<=n;i++,r+=(m>x),m=min(m,x))cin>>x;
cout<<r;
return 0;
}
|
Today is August 24, one of the five Product Days in a year.
A date m-d (m is the month, d is the date) is called a Product Day when d is a two-digit number, and all of the following conditions are satisfied (here d_{10} is the tens digit of the day and d_1 is the ones digit of the day):
* d_1 \geq 2
* d_{10} \geq 2
* d_1 \times d_{10} = m
Takahashi wants more Product Days, and he made a new calendar called Takahashi Calendar where a year consists of M month from Month 1 to Month M, and each month consists of D days from Day 1 to Day D.
In Takahashi Calendar, how many Product Days does a year have?
Constraints
* All values in input are integers.
* 1 \leq M \leq 100
* 1 \leq D \leq 99
Input
Input is given from Standard Input in the following format:
M D
Output
Print the number of Product Days in a year in Takahashi Calender.
Examples
Input
15 40
Output
10
Input
12 31
Output
5
Input
1 1
Output
0
|
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
int M = sc.nextInt();
int D = sc.nextInt();
int count = 0;
for(int i = 1; i <= M; i++){
for(int j = 22; j <= D; j++){
String dd = "" + j;
int x = Integer.parseInt(dd.substring(0,1));
int y = Integer.parseInt(dd.substring(1,2));
if(i==x*y && y >= 2 && x >= 2){
count++;
}
}
}
System.out.println(count);
}
}
|
There are N integers, A_1, A_2, ..., A_N, arranged in a row in this order.
You can perform the following operation on this integer sequence any number of times:
Operation: Choose an integer i satisfying 1 \leq i \leq N-1. Multiply both A_i and A_{i+1} by -1.
Let B_1, B_2, ..., B_N be the integer sequence after your operations.
Find the maximum possible value of B_1 + B_2 + ... + B_N.
Constraints
* All values in input are integers.
* 2 \leq N \leq 10^5
* -10^9 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the maximum possible value of B_1 + B_2 + ... + B_N.
Examples
Input
3
-10 5 -4
Output
19
Input
5
10 -4 -8 -11 3
Output
30
Input
11
-1000000000 1000000000 -1000000000 1000000000 -1000000000 0 1000000000 -1000000000 1000000000 -1000000000 1000000000
Output
10000000000
|
import java.util.*;
import java.lang.*;
public class Main {
static long mod = 998244353;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
long[] a = new long[n];
int count = 0;
for (int i = 0; i < n; i++) {
a[i] = sc.nextLong();
if (a[i] < 0) {
count++;
}
}
long ans = 0;
if (count % 2 == 0) {
for (int i = 0; i < n; i++) {
ans += Math.abs(a[i]);
}
} else {
long min = 1000000001;
for (int i = 0; i < n; i++) {
if (Math.abs(a[i]) < min) {
min = Math.abs(a[i]);
}
}
for (int i = 0; i < n; i++) {
ans += Math.abs(a[i]);
}
ans -= min * 2;
}
System.out.println(ans);
}
}
|
In some other world, today is December D-th.
Write a program that prints `Christmas` if D = 25, `Christmas Eve` if D = 24, `Christmas Eve Eve` if D = 23 and `Christmas Eve Eve Eve` if D = 22.
Constraints
* 22 \leq D \leq 25
* D is an integer.
Input
Input is given from Standard Input in the following format:
D
Output
Print the specified string (case-sensitive).
Examples
Input
25
Output
Christmas
Input
22
Output
Christmas Eve Eve Eve
|
D = int(input())
a = "Christmas"
print(a + " Eve"*(25-D))
|
You are given a string s. Among the different substrings of s, print the K-th lexicographically smallest one.
A substring of s is a string obtained by taking out a non-empty contiguous part in s. For example, if s = `ababc`, `a`, `bab` and `ababc` are substrings of s, while `ac`, `z` and an empty string are not. Also, we say that substrings are different when they are different as strings.
Let X = x_{1}x_{2}...x_{n} and Y = y_{1}y_{2}...y_{m} be two distinct strings. X is lexicographically larger than Y if and only if Y is a prefix of X or x_{j} > y_{j} where j is the smallest integer such that x_{j} \neq y_{j}.
Constraints
* 1 ≤ |s| ≤ 5000
* s consists of lowercase English letters.
* 1 ≤ K ≤ 5
* s has at least K different substrings.
Input
Input is given from Standard Input in the following format:
s
K
Output
Print the K-th lexicographically smallest substring of K.
Examples
Input
aba
4
Output
b
Input
atcoderandatcodeer
5
Output
andat
Input
z
1
Output
z
|
#include <iostream>
#include <set>
using namespace std;
int main(void) {
string s;
int k;
cin >> s >> k;
set<string> st;
for (int i = 0; i < s.size(); ++i) {
string subs;
for (int j = i; j < s.size(); ++j) {
subs += s[j];
if (subs.size() > k) break;
st.insert(subs);
}
}
int cnt = 0;
for (auto x : st) {
++cnt;
if (cnt == k) {
cout << x << endl;
break;
}
}
return 0;
}
|
There are N islands floating in Ringo Sea, and M travel agents operate ships between these islands. For convenience, we will call these islands Island 1, 2, …, N, and call these agents Agent 1, 2, …, M.
The sea currents in Ringo Sea change significantly each day. Depending on the state of the sea on the day, Agent i (1 ≤ i ≤ M) operates ships from Island a_i to b_i, or Island b_i to a_i, but not both at the same time. Assume that the direction of the ships of each agent is independently selected with equal probability.
Now, Takahashi is on Island 1, and Hikuhashi is on Island 2. Let P be the probability that Takahashi and Hikuhashi can travel to the same island in the day by ships operated by the M agents, ignoring the factors such as the travel time for ships. Then, P × 2^M is an integer. Find P × 2^M modulo 10^9 + 7.
Constraints
* 2 ≤ N ≤ 15
* 1 ≤ M ≤ N(N-1)/2
* 1 ≤ a_i < b_i ≤ N
* All pairs (a_i, b_i) are distinct.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_M b_M
Output
Print the value P × 2^M modulo 10^9 + 7.
Examples
Input
4 3
1 3
2 3
3 4
Output
6
Input
5 5
1 3
2 4
3 4
3 5
4 5
Output
18
Input
6 6
1 2
2 3
3 4
4 5
5 6
1 6
Output
64
|
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
template<class T = int> using V = vector<T>;
template<class T = int> using VV = V< V<T> >;
template<unsigned P> struct ModInt {
using M = ModInt;
unsigned v;
constexpr ModInt() : v(0) {}
constexpr ModInt(unsigned _v, int) : v(_v) {}
template<class Z> ModInt(const Z& a) : v((a < 0 ? P - -a % P : a) % P) {}
static constexpr unsigned p() { return P; }
M operator+() const { return *this; }
M operator-() const { return {v ? P - v : 0, 0}; }
explicit operator bool() const noexcept { return v; }
bool operator!() const noexcept { return !(bool)*this; }
M& operator*=(M r) { v = (uint64_t)v * r.v % P; return *this; }
M& operator/=(M r) { return *this *= r.inv(); }
M& operator+=(M r) { if ((v += r.v) >= P) v -= P; return *this; }
M& operator-=(M r) { if ((v += P - r.v) >= P) v -= P; return *this; }
M inv() const {
int a = v, b = P, x = 1, u = 0;
while (b) {
int q = a / b;
swap(a -= q * b, b);
swap(x -= q * u, u);
}
assert(a == 1);
return x;
}
template<class Z> M pow(Z n) const {
if (n < 0) return pow(-n).inv();
M res = 1;
for (M a = *this; n; a *= a, n >>= 1) if (n & 1) res *= a;
return res;
}
friend M operator*(M l, M r) { return M(l) *= r; }
friend M operator/(M l, M r) { return M(l) /= r; }
friend M operator+(M l, M r) { return M(l) += r; }
friend M operator-(M l, M r) { return M(l) -= r; }
friend ostream& operator<<(ostream& os, M r) { return os << r.v; }
friend bool operator==(M l, M r) { return l.v == r.v; }
friend bool operator!=(M l, M r) { return !(l == r); }
};
using Mint = ModInt<(unsigned)1e9 + 7>;
int main() {
cin.tie(nullptr); ios::sync_with_stdio(false);
int n, m; cin >> n >> m;
V< bitset<15> > g(n);
for (int _ = 0; _ < m; ++_) {
int u, v; cin >> u >> v, --u, --v;
g[u][v] = g[v][u] = 1;
}
V<Mint> ipw(m + 1, 1);
for (int i = 1; i <= m; ++i) {
ipw[i] = ipw[i - 1] / 2;
}
auto fn = [&](int r) -> V<Mint> {
V<Mint> dp(1 << n);
for (int S = 0; S < 1 << n; ++S) if (S >> r & 1) {
int c = 0;
for (int u = 0; u < n; ++u) if (S >> u & 1) {
for (int v = 0; v < n; ++v) if (~S >> v & 1) {
c += g[u][v];
}
}
dp[S] = ipw[c];
V<> a(n);
for (int u = 0; u < n; ++u) if (~S >> u & 1) {
for (int v = 0; v < n; ++v) if (S >> v & 1) {
a[v] += g[u][v];
}
}
for (int T = (S - 1) & S; ; T = (T - 1) & S) {
c = 0;
for (int v = 0; v < n; ++v) if ((S ^ T) >> v & 1) {
c += a[v];
}
dp[S] -= dp[T] * ipw[c];
if (!T) break;
}
}
return dp;
};
auto dp0 = fn(0);
auto dp1 = fn(1);
Mint res = 1;
for (int S = 0; S < 1 << n; ++S) {
int nS = S;
for (int u = 0; u < n; ++u) if (S >> u & 1) {
for (int v = 0; v < n; ++v) if (g[u][v]) {
nS |= 1 << v;
}
}
for (int T = nS ^ ~(~0U << n); ; T = (T - 1) & (nS ^ ~(~0U << n))) {
res -= dp0[S] * dp1[T];
if (!T) break;
}
}
res *= Mint(2).pow(m);
cout << res << '\n';
}
|
You are given an integer sequence of length n, a_1, ..., a_n. Let us consider performing the following n operations on an empty sequence b.
The i-th operation is as follows:
1. Append a_i to the end of b.
2. Reverse the order of the elements in b.
Find the sequence b obtained after these n operations.
Constraints
* 1 \leq n \leq 2\times 10^5
* 0 \leq a_i \leq 10^9
* n and a_i are integers.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print n integers in a line with spaces in between. The i-th integer should be b_i.
Examples
Input
4
1 2 3 4
Output
4 2 1 3
Input
3
1 2 3
Output
3 1 2
Input
1
1000000000
Output
1000000000
Input
6
0 6 7 6 7 0
Output
0 6 6 0 7 7
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from collections import deque
N,*A = map(int,read().split())
B = deque()
reverse = False
for x in A:
if reverse:
B.appendleft(x)
else:
B.append(x)
reverse = not reverse
B = list(B)
if reverse:
B = B[::-1]
print(' '.join(map(str,B)))
|
There are N towns on a line running east-west. The towns are numbered 1 through N, in order from west to east. Each point on the line has a one-dimensional coordinate, and a point that is farther east has a greater coordinate value. The coordinate of town i is X_i.
You are now at town 1, and you want to visit all the other towns. You have two ways to travel:
* Walk on the line. Your fatigue level increases by A each time you travel a distance of 1, regardless of direction.
* Teleport to any location of your choice. Your fatigue level increases by B, regardless of the distance covered.
Find the minimum possible total increase of your fatigue level when you visit all the towns in these two ways.
Constraints
* All input values are integers.
* 2≤N≤10^5
* 1≤X_i≤10^9
* For all i(1≤i≤N-1), X_i<X_{i+1}.
* 1≤A≤10^9
* 1≤B≤10^9
Input
The input is given from Standard Input in the following format:
N A B
X_1 X_2 ... X_N
Output
Print the minimum possible total increase of your fatigue level when you visit all the towns.
Examples
Input
4 2 5
1 2 5 7
Output
11
Input
7 1 100
40 43 45 105 108 115 124
Output
84
Input
7 1 2
24 35 40 68 72 99 103
Output
12
|
N,A,B = map(int,input().split())
X = [int(x) for x in input().split()]
ans = 0
for i in range(1,N):
d = X[i]-X[i-1]
ans += min(A*d, B)
print(ans)
|
There are N arrays. The length of each array is M and initially each array contains integers (1，2，...，M) in this order.
Mr. Takahashi has decided to perform Q operations on those N arrays. For the i-th (1≤i≤Q) time, he performs the following operation.
* Choose an arbitrary array from the N arrays and move the integer a_i (1≤a_i≤M) to the front of that array. For example, after performing the operation on a_i=2 and the array (5，4，3，2，1), this array becomes (2，5，4，3，1).
Mr. Takahashi wants to make N arrays exactly the same after performing the Q operations. Determine if it is possible or not.
Constraints
* 2≤N≤10^5
* 2≤M≤10^5
* 1≤Q≤10^5
* 1≤a_i≤M
Input
The input is given from Standard Input in the following format:
N M
Q
a_1 a_2 ... a_Q
Output
Print `Yes` if it is possible to make N arrays exactly the same after performing the Q operations. Otherwise, print `No`.
Examples
Input
2 2
3
2 1 2
Output
Yes
Input
3 2
3
2 1 2
Output
No
Input
2 3
3
3 2 1
Output
Yes
Input
3 3
6
1 2 2 3 3 3
Output
No
|
from sys import stdin
from itertools import repeat
def main():
n, m = map(int, stdin.readline().split())
q = int(stdin.readline())
a = map(int, stdin.readline().split(), repeat(10, q))
a = [x - 1 for x in a]
l = [[] for i in xrange(m)]
la = []
for i in xrange(q - 1, -1, -1):
x = a[i]
if not l[x]:
la.append(x)
l[x].append(i)
ok = 1
b = [q] * n
f = [0] * m
xt = 0
for i, x in enumerate(la):
j = 0
for y in l[x]:
if j < n and y < b[j]:
b[j] = y
j += 1
if j < n:
ok = 0
b[j] = -1
if not ok:
while f[xt]:
xt += 1
if x != xt:
print "No"
return
f[xt] = 1
else:
f[x] = 1
print "Yes"
main()
|
Internet search engines, such as Google, automatically sort and categorize web pages around the world to create a huge database. It also parses the search keywords entered by the user and creates an inquiry statement for database search.
In each case, complicated processing is performed to realize efficient search, but for the time being, all the basics are cutting out words from sentences.
So, please try to cut out the word from the sentence. This time, we will target English sentences with clear word breaks as follows.
* Target text: English text of 1024 characters or less, not including line breaks
* Delimiter: All are half-width characters, only spaces, periods, and commas.
* Words to cut out: Words with 3 to 6 letters (ignore words with 2 or less letters or 7 or more letters)
input
An English sentence consisting of delimiters and alphanumeric characters is given on one line (all half-width characters).
output
Please output the words separated by one space character (half-width) on one line.
Examples
Input
Rain, rain, go to Spain.
Output
Rain rain Spain
Input
Win today's preliminary contest and be qualified to visit University of Aizu.
Output
Win and visit Aizu
|
code = str(raw_input())
code = code.replace(",","")
code = code.replace(".","")
code = code.split()
list = []
for var in code:
if len(var) >= 3 and len(var) <= 6:
list.append(var)
for var in list:
print var,
|
Mr. Matsudaira is always careful about eco-friendliness in his life. Last month's water charge was 4280 yen, which exceeded the usual target of 4000 yen, so we have been trying to save water this month. How much have you saved on your water bill compared to last month?
Enter this month's water usage w [m3] and create a program that outputs how much water charges you have saved compared to last month's water charges of 4280 yen.
The water charge is calculated as follows.
(Water charge) = (Basic charge) + (Charge based on water volume)
The charge based on the amount of water is calculated according to the amount used as shown in the table below.
Stage | Water volume | Price
--- | --- | ---
1st stage charge | Up to 10 [m3] | Basic charge 1150 yen
Second stage fee | 10 [m3] Excess up to 20 [m3] | 125 yen per [m3]
Third stage charge | 20 [m3] Excess up to 30 [m3] | 140 yen per [m3]
4th stage charge | 30 [m3] excess | 160 yen per [m3]
For example, if the amount of water used is 40 [m3], the basic charge is 1150 yen (1st stage) + 10 [m3] x 125 yen (2nd stage) + 10 [m3] x 140 yen (3rd stage) + 10 [ m3] x 160 yen (4th stage) = 5400 yen.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of -1.
For each dataset, an integer w (0 ≤ w ≤ 100) representing the amount of water used this month is given on one line.
The number of datasets does not exceed 200.
Output
For each input dataset, the difference from last month's water charges is output on one line.
Example
Input
29
40
0
-1
Output
620
-1120
3130
|
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
for(int w;cin>>w,~w;){
int p=1150; w-=min(w,10);
p+=125*min(w,10); w-=min(w,10);
p+=140*min(w,10); w-=min(w,10);
p+=160*w;
cout<<4280-p<<endl;
}
return 0;
}
|
It’s still hot every day, but September has already come. It’s autumn according to the calendar. Looking around, I see two red dragonflies at rest on the wall in front of me. It’s autumn indeed.
When two red dragonflies’ positional information as measured from the end of the wall is given, make a program to calculate the distance between their heads.
Input
The input is given in the following format.
$x_1$ $x_2$
The input line provides dragonflies’ head positions $x_1$ and $x_2$ ($0 \leq x_1, x_2 \leq 100$) as integers.
Output
Output the distance between the two red dragonflies in a line.
Examples
Input
20 30
Output
10
Input
50 25
Output
25
Input
25 25
Output
0
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin >> a >> b;
cout << abs(b-a) << endl;
return 0;
}
|
On a clear night, a boy, Campanella looked up at the sky, there were many stars which have different colors such as red, yellow, green, blue, purple, etc. He was watching the stars and just lost track of time. Presently, he wondered,
| <image>
---|---
"There are many stars in the space. What color is the universe if I look up it from outside?"
Until he found the answer to this question, he couldn't sleep. After a moment's thought, he proposed a hypothesis,
"When I observe the stars in the sky, if more than half of the stars have the same color, that is the color of the universe."
He has collected data of stars in the universe after consistently observing them. However, when he try to count the number of star, he was in bed sick with a cold. You decided to help him by developing a program to identify the color of the universe.
You are given an array A. Let |A| be the number of element in A, and let Nm be the number of m in A. For example, if A = {3, 1, 2, 3, 3, 1, 5, 3}, |A| = 8, N3 = 4, N1 = 2, N5 = 1. Your program have to find m such that:
Nm > (|A| / 2 )
If there is no such m, you also have to report the fact. There is no such m for the above example, but for a array A = {5, 2, 5, 3, 4, 5, 5}, 5 is the answer.
Input
There are several test cases. For each test case, in the first line |A| is given. In the next line, there will be |A| integers. The integers are less than 231 and |A| < 1,000,000. The input terminate with a line which contains single 0.
Output
For each test case, output m in a line. If there is no answer, output "NO COLOR" in a line.
Example
Input
8
3 1 2 3 3 1 5 3
7
5 2 5 3 4 5 5
0
Output
NO COLOR
5
|
#include<stdio.h>
#include<map>
int main()
{
int n,x,i,f;
while(scanf("%d",&n),n)
{
typedef std::map<int,int>M;
M m;
for(f=i=0;i<n;++i)scanf("%d",&x),m[x]++;
for(M::iterator t=m.begin();t!=m.end();++t)
if(t->second>n/2)f=printf("%d\n",t->first);
if(!f)puts("NO COLOR");
}
return 0;
}
|
Today is the birthday of Mr. Bon Vivant, who is known as one of the greatest patissiers in the world. Those who are invited to his birthday party are gourmets from around the world. They are eager to see and eat his extremely creative cakes. Now a large box-shaped cake is being carried into the party. It is not beautifully decorated and looks rather simple, but it must be delicious beyond anyone's imagination. Let us cut it into pieces with a knife and serve them to the guests attending the party.
The cake looks rectangular, viewing from above (Figure C-1). As exemplified in Figure C-2, the cake will iteratively be cut into pieces, where on each cut exactly a single piece is cut into two smaller pieces. Each cut surface must be orthogonal to the bottom face and must be orthogonal or parallel to a side face. So, every piece shall be rectangular looking from above and every side face vertical.
<image>
Figure C-1: The top view of the cake
<image>
Figure C-2: Cutting the cake into pieces
Piece sizes in Figure C-2 vary significantly and it may look unfair, but you don't have to worry. Those guests who would like to eat as many sorts of cakes as possible often prefer smaller pieces. Of course, some prefer larger ones.
Your mission of this problem is to write a computer program that simulates the cutting process of the cake and reports the size of each piece.
Input
The input is a sequence of datasets, each of which is of the following format.
> n w d
> p1 s1
> ...
> pn sn
>
The first line starts with an integer n that is between 0 and 100 inclusive. It is the number of cuts to be performed. The following w and d in the same line are integers between 1 and 100 inclusive. They denote the width and depth of the cake, respectively. Assume in the sequel that the cake is placed so that w and d are the lengths in the east-west and north-south directions, respectively.
Each of the following n lines specifies a single cut, cutting one and only one piece into two. pi is an integer between 1 and i inclusive and is the identification number of the piece that is the target of the i-th cut. Note that, just before the i-th cut, there exist exactly i pieces. Each piece in this stage has a unique identification number that is one of 1, 2, ..., i and is defined as follows:
* The earlier a piece was born, the smaller its identification number is.
* Of the two pieces born at a time by the same cut, the piece with the smaller area (looking from above) has the smaller identification number. If their areas are the same, you may define as you like the order between them, since your choice in this case has no influence on the final answer.
Note that identification numbers are adjusted after each cut.
si is an integer between 1 and 1000 inclusive and specifies the starting point of the i-th cut. From the northwest corner of the piece whose identification number is pi, you can reach the starting point by traveling si in the clockwise direction around the piece. You may assume that the starting point determined in this way cannot be any one of the four corners of the piece. The i-th cut surface is orthogonal to the side face on which the starting point exists.
The end of the input is indicated by a line with three zeros.
Output
For each dataset, print in a line the areas looking from above of all the pieces that exist upon completion of the n cuts specified in the dataset. They should be in ascending order and separated by a space. When multiple pieces have the same area, print it as many times as the number of the pieces.
Example
Input
3 5 6
1 18
2 19
1 2
3 4 1
1 1
2 1
3 1
0 2 5
0 0 0
Output
4 4 6 16
1 1 1 1
10
|
#include<algorithm>
#include<cstdio>
#include<iostream>
#include<vector>
using namespace std;
typedef struct
{
int x,y;
}rect;
int area(rect r)
{
return r.x * r.y;
}
int main()
{
while(1)
{
int n,w,h;
cin >> n >> w >> h;
if(n == 0&&w == 0&&h == 0)break;
vector<rect> v;
v.resize(1);
v[0].x = w;
v[0].y = h;
for(int i= 0;i < n;i++)
{
int p,s;
scanf("%d %d",&p,&s);
p--;//o-index???????????????
//??????????????¢?????¨???
rect f = v[p];
//??????????????¢?????????
s%=(f.x+f.y)*2;
rect r1,r2;
if(s<f.x)
{
r1.x = s;r1.y = f.y;
r2.x = f.x - s;r2.y = f.y;
}
else if(s < f.x+f.y)
{
r1.x = f.x;r1.y = s - f.x;
r2.x = f.x;r2.y = f.x+f.y-s;
}
else if(s < 2*f.x + f.y)
{
r1.x = 2*f.x + f.y - s;r1.y = f.y;
r2.x = s - (f.x+f.y);r2.y = f.y;
}
else
{
r1.x = f.x;r1.y = 2*(f.x + f.y) - s;
r2.x = f.x;r2.y = s - (2* f.x + f.y);
}
v.erase(v.begin() + p);
if(area(r1)>area(r2))
{
v.push_back(r2);
v.push_back(r1);
}
else
{
v.push_back(r1);
v.push_back(r2);
}
}
vector<int> ans;
for(int i = 0;i < v.size();i++)
{
ans.push_back(area(v[i]));
}
sort(ans.begin(),ans.end());
for(int i= 0;i < ans.size();i++)
{
if(i)putchar(' ');
printf("%d",ans[i]);
}
puts("");
}
return 0;
}
|
The amount of information on the World Wide Web is growing quite rapidly. In this information explosion age, we must survive by accessing only the Web pages containing information relevant to our own needs. One of the key technologies for this purpose is keyword search. By using well-known search engines, we can easily access those pages containing useful information about the topic we want to know.
There are many variations in keyword search problems. If a single string is searched in a given text, the problem is quite easy. If the pattern to be searched consists of multiple strings, or is given by some powerful notation such as regular expressions, the task requires elaborate algorithms to accomplish efficiently.
In our problem, a number of strings (element strings) are given, but they are not directly searched for. Concatenations of all the element strings in any order are the targets of the search here.
For example, consider three element strings aa, b and ccc are given. In this case, the following six concatenated strings are the targets of the search, i.e. they should be searched in the text.
aabccc
aacccb
baaccc
bcccaa
cccaab
cccbaa
The text may contain several occurrences of these strings. You are requested to count the number of occurrences of these strings, or speaking more precisely, the number of positions of occurrences in the text.
Two or more concatenated strings may be identical. In such cases, it is necessary to consider subtle aspects of the above problem statement. For example, if two element strings are x and xx, the string xxx is an occurrence of both the concatenation of x and xx and that of xx and x. Since the number of positions of occurrences should be counted, this case is counted as one, not two.
Two occurrences may overlap. For example, the string xxxx has occurrences of the concatenation xxx in two different positions. This case is counted as two.
Input
The input consists of a number of datasets, each giving a set of element strings and a text. The format of a dataset is as follows.
n m
e1
e2
.
.
.
en
t1
t2
.
.
.
tm
The first line contains two integers separated by a space. n is the number of element strings. m is the number of lines used to represent the text. n is between 1 and 12, inclusive.
Each of the following n lines gives an element string. The length (number of characters) of an element string is between 1 and 20, inclusive. The last m lines as a whole give the text. Since it is not desirable to have a very long line, the text is separated into m lines by newlines, but these newlines should be ignored. They are not parts of the text. The length of each of these lines (not including the newline) is between 1 and 100, inclusive. The length of the text is between 1 and 5000, inclusive.
The element strings and the text do not contain characters other than lowercase letters.
The end of the input is indicated by a line containing two zeros separated by a space.
CAUTION! Although the sample input contains only small datasets, note that 12! × 5000 is far larger than 231 .
Output
For each dataset in the input, one line containing the number of matched positions should be output. An output line should not contain extra characters.
Example
Input
3 1
aa
b
ccc
aabccczbaacccbaazaabbcccaa
3 1
a
b
c
cbbcbcbabaacabccaccbaacbccbcaaaccccbcbcbbcacbaacccaccbbcaacbbabbabaccc
3 4
aaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
0 0
Output
5
12
197
|
#include<iostream>
#include<cstring>
using namespace std;
#define REP(i, N) for(int i = 0; i < (int)(N); i++)
bool dp[32][1 << 12];
int main() {
for(int N, M; cin >> N >> M, (N || M); ) {
string str;
string word[12];
REP(i, N) cin >> word[i];
REP(i, M) {
string s;
cin >> s;
str += s;
}
int len = str.size();
memset(dp, 0, sizeof(dp));
REP(j, 32) dp[j][0] = true;
int mask = (1 << N) - 1;
int sum = 0;
REP(pos, len + 1) {
int j = pos & 31;
REP(i, N) if( word[i] == str.substr(pos, word[i].size()) ) {
int am = (pos + word[i].size()) & 31;
REP(state, mask) if( (state & (1 << i) ) == 0){
dp[am][state | (1 << i)] |= dp[j][state];
}
}
sum += dp[j][mask];
for(int state = 1; state < 1 << N; state++)
dp[j][state] = 0;
}
cout << sum << endl;
}
}
|
Problem
At a certain arcade, there is a game of playing Japanese drums according to the musical score that flows along with the song. The score consists of cells of length L, and each cell has a blank or note, a symbol that represents the action the player should take. There are two types of notes, each with a "ton" that hits the surface of the wadaiko and a "knack" that hits the edge of the wadaiko. You can get points by hitting the Japanese drum along with these notes. If the total score is 10,000 points or more, it will be cleared.
At this time, find the probability that the player can clear the song. However, the player always takes the best action.
There are 11 levels of accuracy for the player to hit the wadaiko according to the score, and there is a 0%, 10%, 20%, ..., 90%, 100% chance of hitting the wadaiko according to the score, respectively.
The above two types of movements can be performed with either the right arm or the left arm. As player information, 16 types of values that represent the stability rate of accuracy when performed with each arm are given as follows.
lt_lt lt_rt lt_lk lt_rk
rt_lt rt_rt rt_lk rt_rk
lk_lt lk_rt lk_lk lk_rk
rk_lt rk_rt rk_lk rk_rk
However, lt is the left arm ton, rt is the right arm ton, lk is the left arm and the knack, and rk is the right arm and the knack. For example, lt_rk indicates the degree of stability of accuracy when performing a knack with the right arm after a ton with the left arm, and this value changes the accuracy when performing a knack with the right arm after a ton with the left arm as follows. To do.
Player accuracy = max (0, (accuracy stability -10) * 10 + previous accuracy) (%)
The song information is as follows. It is indicated by L, which represents the length of the song, and L, which represents the musical score, si (0 ≤ i <L). The beginning of the score is s0. There are three values for si:
0 ... no notes
1 ton
2 ... Tips
The accuracy when the player first hits the Japanese drum is 100%. Players can also ignore the score. If there are no notes or if you ignore the notes, the player's accuracy will be 100%.
The score when you hit the Japanese drum according to each note is as follows.
Score = A + B * min (number of combos, 10)
The number of combos in this problem is the number of taiko drums that can be played in succession to the notes. If the player hits according to the note, the score will be scored based on the above formula, and then the number of combos will increase by 1. If you cannot hit the Japanese drum according to the note, the combo will be interrupted and the number of combos will be 0.
Constraints
The input meets the following conditions:
* 0 <L ≤ 100
* 0 ≤ Accuracy stability rate ≤ 10
* Accuracy stability is an integer
* 0 <A, B ≤ 10000
* Both A and B are multiples of 100
* No more than 100 datasets
Input
The input consists of multiple datasets. Each dataset is as follows.
lt_lt lt_rt lt_lk lt_rk
rt_lt rt_rt rt_lk rt_rk
lk_lt lk_rt lk_lk lk_rk
rk_lt rk_rt rk_lk rk_rk
L
s0 s1 s2… sL ―― 1
A B
The end of the input consists of four negative integers.
Output
For each input, output the probability of clearing in one line. However, the output may contain an error of 0.001 or less.
Example
Input
9 0 0 0
0 9 0 0
0 0 0 0
0 0 0 0
5
1 1 1 1 1
1000 500
10 10 10 10
10 10 10 10
10 10 10 10
10 10 10 10
5
1 0 2 0 1
1000 2000
3 8 6 10
0 1 6 8
10 2 4 7
8 6 6 8
19
2 2 0 2 2 0 2 1 0 1 2 0 1 2 0 1 0 2 2
200 100
-1 -1 -1 -1
Output
0.3024000000
0.0000000000
0.5120000000
|
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <vector>
using namespace std;
typedef vector<double> vec;
typedef vector<vec> vec2;
typedef vector<vec2> vec3;
typedef vector<vec3> vec4;
template<class T> inline void chmax(T& a, T b) { if(b > a) a = b; }
enum { LT, RT, LK, RK, NONE };
int main() {
for(;;) {
int acc[4][4];
for(int i = 0; i < 4; ++i)
scanf("%d", &acc[0][i]);
if(acc[0][0] < 0)
break;
for(int i = 1; i < 4; ++i)
for(int j = 0; j < 4; ++j)
scanf("%d", &acc[i][j]);
int l;
scanf("%d", &l);
vector<int> s(l);
for(int i = 0; i < l; ++i)
scanf("%d", &s[i]);
int a, b;
scanf("%d %d", &a, &b);
a /= 100;
b /= 100;
vec4 dp(101, vec3(5, vec2(11, vec(11, 0.0))));
for(int i = 0; i < 5; ++i)
for(int j = 0; j < 11; ++j)
for(int k = 0; k < 11; ++k)
dp[100][i][j][k] = 1.0;
for(int next = l - 1; next >= 0; --next) {
vec4 tmp(101, vec3(5, vec2(11, vec(11, 1.0))));
if(s[next] == 0) {
for(int sco = 0; sco < 100; ++sco)
for(int pre = 0; pre < 5; ++pre)
for(int com = 0; com <= 10; ++com)
for(int pac = 0; pac <= 10; ++pac)
tmp[sco][pre][com][pac] = dp[sco][NONE][com][10];
dp.swap(tmp);
continue;
}
const int start = (s[next] == 1 ? 0 : 2);
for(int sco = 0; sco < 100; ++sco) {
for(int pre = 0; pre < 4; ++pre) {
for(int pac = 0; pac <= 10; ++pac) {
for(int com = 0; com <= 10; ++com)
tmp[sco][pre][com][pac] = dp[sco][NONE][0][10];
for(int i = start; i < start + 2; ++i) {
const int ac = max(0, (acc[pre][i] - 10) + pac);
const double p = ac / 10.0;
for(int com = 0; com <= 10; ++com) {
const double buf = p * dp[min(100, sco + a + b * min(10, com))][i][min(10, com + 1)][ac] + (1.0 - p) * dp[sco][i][0][ac];
chmax(tmp[sco][pre][com][pac], buf);
}
}
}
}
for(int com = 0; com <= 10; ++com) {
for(int pac = 0; pac <= 10; ++pac) {
tmp[sco][NONE][com][pac] = dp[sco][NONE][0][10];
for(int i = start; i < start + 2; ++i) {
chmax(tmp[sco][NONE][com][pac], dp[min(100, sco + a + b * min(10, com))][i][min(10, com + 1)][10]);
}
}
}
}
dp.swap(tmp);
}
printf("%.5lf\n", dp[0][NONE][0][10]);
}
return EXIT_SUCCESS;
}
|
Peace, which was supposed to last forever, suddenly ended. The Demon King, who had been sealed long ago, has finally revived. But when the world was about to be covered in darkness, a brave man appeared. The hero then set out on a journey to collect legendary crystals scattered around the world. Legend has it that if you can collect all the crystals, you can summon the legendary dragon god who can fulfill any wish. With the help of the dragon god, it should be possible to defeat the Demon King.
Crystals are scattered all over the world. The hero needs to collect them one by one by his own hands. This is because if someone other than the hero gets the crystal, it may be stolen by the Demon King's minions. A hero can travel only one Euclidean distance per day.
But there is one serious problem here. The Demon King constantly disperses the darkness of the miasma, and the place contaminated with the miasma turns into a land of death that no one can enter. Even a brave man cannot enter the place. Furthermore, since the miasma spreads concentrically with time, the area where the hero can move decreases with the passage of time. Miasma has been confirmed to spread by an Euclidean distance of 1 per day. And the hero cannot take the crystal on the boundary line. We also know that the newly resurrected Demon King will not move to store power.
The hero must get the crystal as soon as possible. But if it's not possible to get all the crystals, you'll have to think of another way. Therefore, I would like you to create a program to find out if you can get all the crystals from the initial position of the hero, the place where the demon king was resurrected, and the position where the crystals exist.
By the way, the brave does not get tired. And I don't sleep. Keep moving and collect crystals until you collect all the crystals and save the world! !!
Input
The input consists of multiple test cases. The first line of each test case gives the five integers n (0 <n <= 20), hx, hy, dx, and dy. n is the number of crystals, (hx, hy) is the position of the hero at the moment the Demon King was resurrected, and (dx, dy) is the position where the Demon King was resurrected. The n lines that follow are given the two integers cx, cy, that represent the position of each crystal. Input ends when n = hx = hy = dx = dy = 0, which is not included in the test case.
All coordinates given in the input are guaranteed to be integers with an absolute value of 1000 or less.
Output
For each test case, output "YES" if you can collect all the crystals, and "NO" if not.
Example
Input
2 0 0 10 10
1 1
4 4
2 0 0 10 10
1 1
6 6
2 0 0 10 10
1 1
5 5
0 0 0 0 0
Output
YES
NO
NO
|
#define DEBUG_ON
#define CONDITION true
using namespace std;/*{{{*/
#include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/time.h>
#include <vector>
#define INF (1e9)
static const double PI = acos(-1.0);
static const double EPS = 1e-10;
typedef long long int LL;
typedef unsigned long long int ULL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef vector<bool> VB;
typedef vector<VB> VVB;
typedef vector<char> VC;
typedef vector<VC> VVC;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef complex<double> P;
#define FOR(i, b, e) for (typeof(e) i = (b); i != (e); i < (e)? ++i : --i)
#define REP(i, n) FOR(i, 0, n)
#define IFC(c) if(c) continue;
#define IFB(c) if(c) break;
#define IFR(c, r) if(c) return r;
#define OPOVER(_op, _type) inline bool operator _op (const _type &t) const
#define arrsz(a) ( sizeof(a) / sizeof(a[0]) )
#define F first
#define S second
#define MP(a, b) make_pair(a, b)
#define SZ(a) ((LL)a.size())
#define PB(e) push_back(e)
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EACH(c,it) for(__typeof((c).begin()) it=(c).begin(); it!=(c).end(); ++it)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define BIT(n) (1ULL << (n))
#define BITOF(n, m) ((ULL)(n) >> (m) & 1)
#define RANGE(a, b, c) ((a) <= (b) && (b) <= (c))
#define PQ priority_queue
#define SC static_cast
#ifdef DEBUG_ON
#define dprt(fmt, ...) if (CONDITION) fprintf(stderr, fmt, ##__VA_ARGS__)
#define darr(a) if (CONDITION) copy( (a), (a) + arrsz(a), ostream_iterator<int>(cerr, " ") ); cerr << endl
#define darr_range(a, f, t) if (CONDITION) copy( (a) + (f), (a) + (t), ostream_iterator<int>(cerr, " ") ); cerr << endl
#define dvec(v) if (CONDITION) copy( ALL(v), ostream_iterator<int>(cerr, " ") ); cerr << endl
#define darr2(a, n, m) if (CONDITION) FOR(i, 0, (n)){ darr_range( (a)[i], 0, (m) ); }
#define dvec2(v) if (CONDITION) FOR(i, 0, SZ(v)){ dvec( (v)[i] ); }
#define WAIT() if (CONDITION) { string _wait_; cerr << "(hit return to continue)" << endl; getline(cin, _wait_); }
#define dump(x) if (CONDITION) cerr << " [L" << __LINE__ << "] " << #x << " = " << (x) << endl;
#define dumpf() if (CONDITION) cerr << __PRETTY_FUNCTION__ << endl;
#define dumpv(x) if (CONDITION) cerr << " [L:" << __LINE__ << "] " << #x << " = "; REP(q, (x).size()) cerr << (x)[q] << " "; cerr << endl;
#define where() if (CONDITION) cerr << __FILE__ << ": " << __PRETTY_FUNCTION__ << " [L: " << __LINE__ << "]" << endl;
#define show_bits(b, s) if(CONDITION) { REP(i, s) { cerr << BITOF(b, s-1-i); if(i%4 == 3) cerr << ' '; } cerr << endl; }
#else
#define cerr if(0) cerr
#define dprt(fmt, ...)
#define darr(a)
#define darr_range(a, f, t)
#define dvec(v)
#define darr2(a, n, m)
#define dvec2(v)
#define WAIT()
#define dump(x)
#define dumpf()
#define dumpv(x)
#define where()
#define show_bits(b, s)
#endif
/* Inline functions */
inline int onbits_count(ULL b) { int c = 0; while(b != 0) { c += (b & 1); b >>= 1; } return c; }
inline int bits_count(ULL b) { int c = 0; while(b != 0) { ++c; b >>= 1; } return c; }
inline int toInt(string s) { int v; istringstream sin(s);sin>>v;return v; }
template<class T> inline string toString(T x) { ostringstream sout;sout<<x;return sout.str(); }
inline double now(){ struct timeval tv; gettimeofday(&tv, NULL); return (static_cast<double>(tv.tv_sec) + static_cast<double>(tv.tv_usec) * 1e-6); }
inline VS split(string s, char delimiter) { VS v; string t; REP(i, s.length()) { if(s[i] == delimiter) v.PB(t), t = ""; else t += s[i]; } v.PB(t); return v; }
/* Tweaks */
template<typename T1, typename T2> ostream& operator<<(ostream& s, const pair<T1, T2>& d) {return s << "(" << d.first << ", " << d.second << ")";}
/* Frequent stuffs */
int n_dir = 4;
enum direction {
UP, RIGHT, DOWN, LEFT
};
// int n_dir = 8;
// int dx[] = {0, 1, 1, 1, 0, -1, -1, -1}, dy[] = {-1, -1, 0, 1, 1, 1, 0, -1};
// enum direction {
// UP, UPRIGHT, RIGHT, DOWNRIGHT, DOWN, DOWNLEFT, LEFT, UPLEFT
// }
#define FORDIR(d) REP (d, n_dir)
/*}}}*/
int n, hx, hy, dx, dy;
VVD dist;
vector<P> cristals;
VD limits;
bool get_cristal(int status, int position, double time)
{
if (status == (1 << n) - 1) {
return true;
}
// Stop searching if more than one cristal is not to be reached
REP (c, n) {
if ((status & (1 << c)) == 0) {
if (time + dist[position][c] > limits[c] - EPS) {
return false;
}
}
}
bool clear = false;
REP (c, n) {
if ((status & (1 << c)) == 0) {
// Get c-th cristal
if (get_cristal(status | (1 << c), c, time + dist[position][c])) {
clear = true;
}
}
}
return clear;
}
int main()
{
std::ios_base::sync_with_stdio(false);
while (cin >> n >> hx >> hy >> dx >> dy, n | hx | hy | dx | dy) {
cristals.clear();
REP (i, n) {
int x, y; cin >> x >> y;
cristals.PB(P(x, y));
}
cristals.PB(P(hx, hy));
dist = VVD(cristals.size(), VD(cristals.size(), INF));
REP (i, cristals.size()) {
REP (j, cristals.size()) {
dist[i][j] = sqrt(norm(cristals[i] - cristals[j]));
}
}
limits = VD(n);
REP (i, n) {
limits[i] = sqrt(norm(cristals[i] - P(dx, dy)));
}
limits.PB(INF);
if (get_cristal(0, cristals.size() - 1, 0)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
// vim: foldmethod=marker
|
You are a programmer working for your local city hall. The town you live in has a thriving tourism industry, especially the beaches on the shores of remote islands. The area around this island is composed of sandy beaches, but in recent years the area of the sandy beaches has decreased due to coastal erosion. The Tourism Division, which took the situation seriously, asked you to simulate the shape change of the beach.
In the simulation, the shape of the beach after a certain period of time is obtained based on the current shape of the beach. For simplicity, the shape of the island's coastline is considered polygonal (not necessarily convex). During the period, it is assumed that the beach is eroded by R at a distance from the current coastline in Manhattan and sinks into the sea. Here, the Manhattan distance is the sum of the difference between the x-coordinates and the difference between the y-coordinates. That is, the Manhattan distance between (x1, y1) and (x2, y2) is given by | x1 --x2 | + | y1 --y2 |.
Your job is to write a program to find the length of the shoreline obtained as a result of the simulation from the shoreline of the sandy beach given as input. If an island is divided into two or more due to coastal erosion, find the length of the coastline for each divided island and output the sum of them.
It should be noted that the two line segments included in the coastline are parallel and the Manhattan distance is not exactly 2R.
Input
The input consists of multiple datasets. Each dataset is given in the following format.
> N R
> x1 y1
> x2 y2
> ...
> xN yN
The first line gives two non-negative integers N (3 ≤ N ≤ 100) and R (0 <R ≤ 100). These integers represent the number of vertices on the coastline and the distance eroded, respectively. In the following N lines, vertex information is given to each line, one for each line. Vertex information is given by two integers xi, yi (-10000 ≤ xi, yi ≤ 10000). The coordinates (xi, yi) represent the coordinates of the i-th vertex of the coastline, respectively. The coordinates of the vertices of the island are always given counterclockwise.
The end of the input is indicated by a single line containing two zeros separated by blanks.
Output
Output the length of the eroded coastline for each dataset. If the island is completely eroded and disappears, the length of the coastline should be treated as 0.0. The output value may contain an error of 0.01 or less. In addition, the value may be displayed in any number of digits after the decimal point.
Sample Input
3 1
0 0
10 0
5 10
3 1
0 0
10 0
0 10
4 1
0 0
10 0
10 10
0 10
0 0
Output for the Sample Input
22.6524758425
23.8994949366
32.0000000000
Example
Input
3 1
0 0
10 0
5 10
3 1
0 0
10 0
0 10
4 1
0 0
10 0
10 10
0 10
0 0
Output
22.6524758425
23.8994949366
32.0000000000
|
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class Main{
Scanner sc=new Scanner(System.in);
int INF=1<<28;
double EPS=1e-6;
int n;
double r;
P[] ps;
void run(){
for(;;){
n=sc.nextInt();
if(n==0){
break;
}
r=sc.nextInt();
ps=new P[n];
for(int i=0; i<n; i++){
ps[i]=new P(sc.nextInt(), sc.nextInt());
}
solve();
}
}
void solve(){
P[][] qs=new P[n][];
for(int i=0; i<n; i++){
qs[i]=new P[]{ps[i].add(new P(0, r)), ps[i].add(new P(r, 0)),
ps[i].add(new P(0, -r)), ps[i].add(new P(-r, 0))};
}
ArrayList<Seg> list1=new ArrayList<Seg>();
for(int i=0; i<n; i++){
int j=(i+1)%n;
for(int k=0; k<4; k++){
list1.add(new Seg(qs[i][k], qs[i][(k+1)%4]));
list1.add(new Seg(qs[i][k], qs[j][k]));
}
}
ArrayList<P> clist=new ArrayList<P>();
for(Seg segP : list1){
P p1=segP.p1, p2=segP.p2;
for(Seg segQ : list1){
P q1=segQ.p1, q2=segQ.p2;
if(crsSS(p1, p2, q1, q2)){
P c=isLL(p1, p2, q1, q2);
if(c!=null){
clist.add(c);
}
}
}
clist.add(p1);
clist.add(p2);
}
// arrangement
ArrayList<Seg> list2=new ArrayList<Seg>();
for(Seg segP : list1){
P p1=segP.p1, p2=segP.p2;
ArrayList<P> list=new ArrayList<P>();
for(P q : clist){
if(disSP(p1, p2, q)<EPS){
list.add(q);
}
}
P[] cs=list.toArray(new P[0]);
int m=cs.length;
for(int i=0; i<m; i++){
for(int j=i+1; j<m; j++){
double d1=cs[i].sub(p1).abs();
double d2=cs[j].sub(p1).abs();
if(d1>d2){
P t=cs[i];
cs[i]=cs[j];
cs[j]=t;
}
}
}
// debug(p1, p2, cs);
for(int i=0; i<m-1; i++){
if(cs[i].sub(cs[i+1]).abs()>EPS){
list2.add(new Seg(cs[i], cs[i+1]));
}
}
}
Seg[] segs=list2.toArray(new Seg[0]);
for(Seg seg : segs){
// debug("seg", seg.p1, seg.p2);
}
int m=segs.length;
boolean[] use=new boolean[m];
fill(use, true);
double sum=0;
for(int i=0; i<m; i++){
if(!use[i]){
continue;
}
P p1=segs[i].p1, p2=segs[i].p2;
for(int j=i+1; j<m; j++){
P q1=segs[j].p1, q2=segs[j].p2;
if(p1.sub(q1).abs()<EPS&&p2.sub(q2).abs()<EPS
||p1.sub(q2).abs()<EPS&&p2.sub(q1).abs()<EPS){
use[j]=false;
}
}
// debug("use", p1, p2);
P mid=p1.add(p2).div(2);
double d=Double.MAX_VALUE;
P x1=new P(-1e6, mid.y), x2=new P(+1e6, mid.y);
P y1=new P(mid.x, -1e6), y2=new P(mid.x, +1e6);
for(int k=0; k<n; k++){
P q1=ps[k], q2=ps[(k+1)%n];
d=min(d, abs(q1.x-mid.x)+abs(q1.y-mid.y));
if(crsSS(x1, x2, q1, q2)){
P c=isLL(x1, x2, q1, q2);
if(c!=null){
d=min(d, c.sub(mid).abs());
}
}
if(crsSS(y1, y2, q1, q2)){
P c=isLL(y1, y2, q1, q2);
if(c!=null){
d=min(d, c.sub(mid).abs());
}
}
}
// debug(p1, p2, d);
if(d+EPS>r){
if(contains(ps, p1)==1){
// debug(p1, p2, d);
sum+=p1.sub(p2).abs();
}
}
}
// debug(sum);
println(String.format("%.12f", sum));
}
double map(double x, double x1, double x2, double y1, double y2){
return 0;
}
double disSP(P p1, P p2, P q){
if(p2.sub(p1).dot(q.sub(p1))<EPS)
return q.sub(p1).abs();
if(p1.sub(p2).dot(q.sub(p2))<EPS)
return q.sub(p2).abs();
return disLP(p1, p2, q);
}
double disLP(P p1, P p2, P q){
return abs(p2.sub(p1).det(q.sub(p1)))/p2.sub(p1).abs();
}
boolean crsSS(P p1, P p2, P q1, P q2){
if(max(p1.x, p2.x)+EPS<min(q1.x, q2.x))
return false;
if(max(q1.x, q2.x)+EPS<min(p1.x, p2.x))
return false;
if(max(p1.y, p2.y)+EPS<min(q1.y, q2.y))
return false;
if(max(q1.y, q2.y)+EPS<min(p1.y, p2.y))
return false;
return signum(p2.sub(p1).det(q1.sub(p1)))
*signum(p2.sub(p1).det(q2.sub(p1)))<EPS
&&signum(q2.sub(q1).det(p1.sub(q1)))
*signum(q2.sub(q1).det(p2.sub(q1)))<EPS;
}
P isLL(P p1, P p2, P q1, P q2){
double d=q2.sub(q1).det(p2.sub(p1));
if(abs(d)<EPS)
return null;
return p1.add(p2.sub(p1).mul(q2.sub(q1).det(q1.sub(p1))/d));
}
int contains(P[] ps, P q){
int n=ps.length;
int res=-1;
for(int i=0; i<n; i++){
P a=ps[i].sub(q), b=ps[(i+1)%n].sub(q);
if(a.y>b.y){
P t=a;
a=b;
b=t;
}
if(a.y<EPS&&b.y>EPS&&a.det(b)>EPS){
res=-res;
}
if(abs(a.det(b))<EPS&&a.dot(b)<EPS)
return 0;
}
return res;
}
class Seg{
P p1, p2;
Seg(P p1, P p2){
this.p1=p1;
this.p2=p2;
}
}
class P implements Comparable<P>{
double x, y;
P(double x, double y){
this.x=x;
this.y=y;
}
P add(P p){
return new P(x+p.x, y+p.y);
}
P sub(P p){
return new P(x-p.x, y-p.y);
}
P mul(double m){
return new P(x*m, y*m);
}
P div(double d){
return new P(x/d, y/d);
}
double abs(){
return sqrt(abs2());
}
double abs2(){
return x*x+y*y;
}
double arg(){
return atan2(y, x);
}
double dot(P p){
return x*p.x+y*p.y;
}
double det(P p){
return x*p.y-y*p.x;
}
double ang(P p){
return atan2(det(p), dot(p));
}
P rot90(){
return new P(y, -x);
}
P rot(double d){
return new P(cos(d)*x-sin(d)*y, sin(d)*x+cos(d)*y);
}
public int compareTo(P p){
return Double.compare(x, p.x)*2+Double.compare(y, p.y);
}
public String toString(){
return String.format("(%.3f, %.3f)", x, y);
}
}
void debug(Object... os){
System.err.println(Arrays.deepToString(os));
}
void print(String s){
System.out.print(s);
}
void println(String s){
System.out.println(s);
}
public static void main(String[] args){
new Main().run();
}
}
|
A robot in a two-dimensional maze again. The maze has an entrance and an exit this time, though.
Just as in the previous problem, the maze is made up of H × W grid cells, its upper side faces north, and each cell is either empty or wall. Unlike the previous, on the other hand, one of the empty cells is connected to the entrance and another to the exit.
The robot is rather complex - there is some control, but not full. It is associated with a controller that has two buttons, namely forward and turn. The forward button moves the robot forward to the next cell, if possible. The robot can not move into a wall nor outside the maze. The turn button turns the robot as programmed. Here the program is a finite sequence of N commands, each of which is either 'L' (indicating a left turn) or 'R' (a right turn). The first turn follows the first command; the second turn follows the second command; similar for the following turns. The turn button stops working once the commands are exhausted; the forward button still works in such a case though. The robot always turns by 90 degrees at once.
The robot is initially put on the entrance cell, directed to the north. Your mission is to determine whether it can reach the exit cell if controlled properly.
Input
The input is a sequence of datasets. Each dataset is formatted as follows.
H W N
s1 ... sN
c1,1c1,2...c1,W
...
cH,1cH,2...cH,W
The first line of a dataset contains three integers H, W and N (1 ≤ H, W ≤ 1,000, 1 ≤ N ≤ 1,000,000).
The second line contains a program of N commands.
Each of the following H lines contains exactly W characters. Each of these characters represents a cell of the maze. "." indicates empty, "#" indicates a wall, "S" indicates an entrance, and "G" indicates an exit. There is exactly one entrance cell and one exit cell.
The end of input is indicated by a line with three zeros.
Output
For each dataset, output whether the robot can reach the exit in a line: "Yes" if it can or "No" otherwise (without quotes).
Examples
Input
2 2 1
L
G.
#S
2 2 2
RR
G.
.S
3 3 6
LLLLLL
G#.
...
.#S
0 0 0
Output
Yes
No
Yes
Input
2 2 1
L
G.
S
2 2 2
RR
G.
.S
3 3 6
LLLLLL
G#.
...
.#S
0 0 0
Output
Yes
No
Yes
|
#include<queue>
#include<cstdio>
#include<cstring>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
const int INF=1<<29;
const int dx[]={1,0,-1,0},dy[]={0,-1,0,1};
struct Stat{
int x,y,d; // d : ̽ßÔ
bool operator<(const Stat &S)const{ return d>S.d; }
};
int main(){
for(int h,w,n;scanf("%d%d%d",&h,&w,&n),h;){
char cmd[1000001]; scanf("%s",cmd);
int sx,sy,gx,gy;
static char B[1000][1001];
rep(i,h){
scanf("%s",B[i]);
rep(j,w){
if(B[i][j]=='S') sx=j, sy=i;
if(B[i][j]=='G') gx=j, gy=i;
}
}
// precalc
int len=strlen(cmd);
// dir[i] := ÉÀs·é½ßª i Å éÆ«Éü¢Ä¢éûü
static int dir[1000001];
dir[0]=1;
rep(i,len) dir[i+1]=(dir[i]+(cmd[i]=='L'?1:3))%4;
// next[i][k] := ÉÀs·é½ßª i Å éÆ«AÉßÄûü k ðüæ¤È½ßÔ(+1)
static int next[1000001][4];
rep(k,4) next[len][k]=(k==dir[len]?len:INF);
for(int i=len;i>0;i--) rep(k,4) {
if(k==dir[i-1]) next[i-1][k]=i-1;
else next[i-1][k]=next[i][k];
}
// Dijkstra
static int d[1000][1000][4];
rep(i,h) rep(j,w) rep(k,4) d[i][j][k]=INF;
d[sy][sx][1]=0;
bool ok=false;
priority_queue<Stat> pq; pq.push((Stat){sx,sy,0});
while(!pq.empty()){
Stat S=pq.top(); pq.pop();
if(d[S.y][S.x][dir[S.d]]<S.d) continue;
if(S.x==gx && S.y==gy){ ok=true; break; }
rep(k,4){
int xx=S.x+dx[k],yy=S.y+dy[k];
if(0<=yy && yy<h && 0<=xx && xx<w && B[yy][xx]!='#'){
if(next[S.d][k]<d[yy][xx][k]){
d[yy][xx][k]=next[S.d][k];
pq.push((Stat){xx,yy,next[S.d][k]});
}
}
}
}
puts(ok?"Yes":"No");
}
return 0;
}
|
Problem A: Approximate Circle
Consider a set of n points (x1, y1), ..., (xn,yn) on a Cartesian space. Your task is to write a program for regression to a circle x2 + y2 + ax + by + c = 0. In other words, your program should find a circle that minimizes the error. Here the error is measured by the sum over square distances between each point and the circle, which is given by:
<image>
Input
The input begins with a line containing one integer n (3 <= n <= 40,000). Then n lines follow. The i-th line contains two integers xi and yi (0 <= xi, yi <= 1,000), which denote the coordinates of the i-th point.
You can assume there are no cases in which all the points lie on a straight line.
Output
Print three integers a, b and c, separated by space, to show the regressed function. The output values should be in a decimal fraction and should not contain an error greater than 0.001.
Examples
Input
4
0 0
100 0
100 100
0 100
Output
-100.000 -100.000 0.000
Input
3
0 0
10 0
5 100
Output
-10.000 -99.750 0.000
|
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
// Approximate Circle
public class Main{
Scanner sc=new Scanner(System.in);
int INF=1<<28;
double EPS=1e-12;
int n;
double[] xs, ys;
void run(){
n=sc.nextInt();
xs=new double[n];
ys=new double[n];
for(int i=0; i<n; i++){
xs[i]=sc.nextInt();
ys[i]=sc.nextInt();
}
solve();
}
void solve(){
double[][] A=new double[3][3];
double[] b=new double[3];
for(int i=0; i<n; i++){
A[0][0]+=sq(xs[i]);
A[0][1]+=xs[i]*ys[i];
A[0][2]+=xs[i];
A[1][0]+=xs[i]*ys[i];
A[1][1]+=sq(ys[i]);
A[1][2]+=ys[i];
A[2][0]+=xs[i];
A[2][1]+=ys[i];
A[2][2]+=1;
b[0]-=xs[i]*(sq(xs[i])+sq(ys[i]));
b[1]-=ys[i]*(sq(xs[i])+sq(ys[i]));
b[2]-=sq(xs[i])+sq(ys[i]);
}
double[] x=gaussianElimination(A, b);
println(String.format("%.9f %.9f %.9f", x[0], x[1], x[2]));
}
double[] gaussianElimination(double[][] A_, double[] b){
int n=A_.length;
double[][] A=new double[n][n+1];
for(int i=0; i<n; i++){
System.arraycopy(A_[i], 0, A[i], 0, n);
A[i][n]=b[i];
}
for(int j=0; j<n; j++){
int pivot=j;
for(int i=j+1; i<n; i++)
if(abs(A[i][j])>abs(A[pivot][j]))
pivot=i;
double[] t=A[j];
A[j]=A[pivot];
A[pivot]=t;
if(abs(A[j][j])<EPS)
return null;
for(int k=j+1; k<n; k++){
double r=A[k][j]/A[j][j];
for(int i=j; i<=n; i++)
A[k][i]-=A[j][i]*r;
}
}
double[] x=new double[n];
for(int j=n-1; j>=0; j--){
x[j]=A[j][n];
for(int i=j+1; i<n; i++)
x[j]-=x[i]*A[j][i];
x[j]/=A[j][j];
}
return x;
}
double sq(double x){
return x*x;
}
void debug(Object... os){
System.err.println(Arrays.deepToString(os));
}
void print(String s){
System.out.print(s);
}
void println(String s){
System.out.println(s);
}
public static void main(String[] args){
new Main().run();
}
}
|
There are n cities and n − 1 roads, which are trees. Cities are numbered from 1 to n. When city 1 is taken as the root, the parent of city i is pi, and the distance between i and pi is di. Sunuke wants to solve the following problem for each k of 1 or more and n or less.
Minimum value of the sum of the distances from a city to cities 1, .. .., k \ begin {eqnarray} min_ {1 \ leq v \ leq n} \\ {\ sum ^ k_ {i = 1} dist (i) , v) \\} \; \; \; \; \; \; \; \; \; \; \; \; \; \; (2) \ end {eqnarray}
Find. However, dist (u, v) represents the distance between u and v.
Constraints
* 1 ≤ n ≤ 200000
* 1 ≤ pi ≤ n
* 1 ≤ di ≤ 200000
* The graph represented by pi is a tree
* All inputs are integers
Input
n
p2 d2
.. ..
pn dn
Output
Output n lines. On line i, output the answer when k = i.
Examples
Input
10
4 1
1 1
3 1
3 1
5 1
6 1
6 1
8 1
4 1
Output
0
3
3
4
5
7
10
13
16
19
Input
15
1 3
12 5
5 2
12 1
7 5
5 1
6 1
12 1
11 1
12 4
1 1
5 5
10 4
1 2
Output
0
3
9
13
14
21
22
29
31
37
41
41
47
56
59
|
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
#include "numeric"
#include "cassert"
#include "ctime"
using namespace std;
constexpr long long int MOD = 1000000007;
//constexpr int MOD = 1000000007;
//constexpr int MOD = 998244353;
//constexpr long long int MOD = 998244353;
constexpr double EPS = 1e-9;
//int N, M, K, H, W, L, R;
long long int N, M, K, H, W, L, R;
class Lowest_Common_Ancestor {
vector<int>depth;
vector<vector<int>>edge;
int height = 0;
int node;
public:
vector<vector<int>>parent;
Lowest_Common_Ancestor(int num) {
num++;
node = num;
while (num) {
height++;
num /= 2;
}
parent.resize(height);
edge.resize(node);
depth.resize(node);
for (int i = 0; i < height; i++)parent[i].resize(node);
}
void Add_Edge(int a, int b) {
edge[a].push_back(b);
edge[b].push_back(a);
return;
}
void Update(int rtnode) {
queue<int>QQ;
for (int i = 0; i < node; i++) depth[i] = INT_MAX;
depth[rtnode] = 0;
QQ.push(rtnode);
while (!QQ.empty()) {
int c = QQ.front();
for (auto i : edge[c]) {
if (depth[i] > depth[c] + 1) {
depth[i] = depth[c] + 1;
QQ.push(i);
}
}
QQ.pop();
}
parent[0][rtnode] = -1;
for (int i = 0; i < node; i++) {
for (auto j : edge[i]) {
if (depth[i] - 1 == depth[j]) {
parent[0][i] = j;
break;
}
}
}
for (int i = 0; i < height - 1; i++) {
for (int j = 0; j < node; j++) {
if (parent[i][j] < 0)parent[i + 1][j] = -1;
else parent[i + 1][j] = parent[i][parent[i][j]];
}
}
return;
}
int LCA(int u, int v) {
if (depth[u] > depth[v])swap(u, v);
for (int i = 0; i < height; i++) {
if ((depth[v] - depth[u]) >> i & 1) {
v = parent[i][v];
}
}
if (u == v)return u;
for (int i = height - 1; i >= 0; i--) {
if (parent[i][v] != parent[i][u]) {
u = parent[i][u];
v = parent[i][v];
}
}
return parent[0][u];
}
int Dist(int u, int v) {
return depth[u] + depth[v] - depth[LCA(u, v)] * 2;
}
};
class Add_Segment_Tree {
vector<long long int>v;
long long int ret;
int num;
long long int Update(int place) {
if (place >= v.size() / 2) {
return v[place];
}
v[place] = Update(place * 2) + Update(place * 2 + 1);
return v[place];
}
public:
Add_Segment_Tree(int n) {
n++;
num = 1;
while (num < n * 2)num *= 2;
v.resize(num, 0);
}
void Add(int place, long long int num, bool update) {
place += v.size() / 2;
v[place] += num;
if (!update)return;
place /= 2;
while (place) {
v[place] = v[place * 2] + v[place * 2 + 1];
place /= 2;
}
}
void TopDown() {
Update(1);
}
long long int Sum(int a, int b) {
ret = 0;
b++;
for (a += num / 2, b += num / 2; a < b; a >>= 1, b >>= 1) {
if (a & 1)ret += v[a++];
if (b & 1)ret += v[--b];
}
return ret;
}
};
class EulerTour { // 0-indexed
public:
vector<int>tour;
vector<int>depth;
vector<int>l;
vector<int>r;
private:
int node;
vector<vector<int>>edge;
int root = 0;
void DFS(int n) {
tour.push_back(n);
for (auto i : edge[n]) {
if (depth[n] < depth[i]) {
DFS(i);
}
}
tour.push_back(n);
return;
}
void BFS() {
for (auto &i : depth)i = MOD;
depth[root] = 0;
queue<int>Q;
Q.push(root);
while (!Q.empty()) {
int cn = Q.front();
int c = depth[cn];
Q.pop();
for (auto i : edge[cn]) {
if (depth[i] > c + 1) {
depth[i] = c + 1;
Q.push(i);
}
}
}
return;
}
public:
EulerTour(int n, int ro) {
node = n;
node++;
root = ro;
edge.resize(node);
depth.resize(node, MOD);
l.resize(node, MOD);
r.resize(node, 0);
return;
}
void Add_Edge(int a, int b) {
edge[a].push_back(b);
edge[b].push_back(a);
return;
}
void Retour() {
if (!tour.empty())tour.clear();
BFS();
DFS(root);
for (int i = 0; i < tour.size(); i++) {
l[tour[i]] = min(l[tour[i]], i);
r[tour[i]] = max(r[tour[i]], i);
}
return;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
vector<vector<pair<int, int>>>edge(N);
Lowest_Common_Ancestor lca(N);
EulerTour et(N, 0);
for (int i = 1; i < N; i++) {
cin >> L >> R;
L--;
edge[L].push_back({ i,R });
edge[i].push_back({ L,R });
lca.Add_Edge(i, L);
et.Add_Edge(i, L);
}
lca.Update(0);
et.Retour();
Add_Segment_Tree asg(et.tour.size());
vector<long long int>depth(N, MOD*MOD);
vector<int>step(N, MOD);
step[0] = 0;
depth[0] = 0;
queue<int>Q;
Q.push(0);
while (!Q.empty()) {
int cn = Q.front();
Q.pop();
for (auto i : edge[cn]) {
if (depth[i.first] > depth[cn] + i.second) {
depth[i.first] = depth[cn] + i.second;
step[i.first] = step[cn] + 1;
Q.push(i.first);
}
}
}
long long int ans = 0;
long long int p = 0;
cout << ans << endl;
asg.Add(et.l[0], 1, true);
for (int i = 1; i < N; i++) {
asg.Add(et.l[i], 1, true);
int l = lca.LCA(p, i);
ans -= depth[l] * 2;
ans += depth[p];
ans += depth[i];
//cout << ans << endl;
auto sump = asg.Sum(et.l[p], et.r[p]);
if (i == p) {
}
else if (l == p) {//今いる場所の下に追加
int nx = i;
int dis = step[i] - step[p] - 1;
for (int j = lca.parent.size() - 1; j >= 0; j--) {
if (dis >= (1 << j) && asg.Sum(et.l[lca.parent[j][nx]], et.r[lca.parent[j][nx]]) * 2 <= i) {
nx = lca.parent[j][nx];
dis -= 1 << j;
}
}
if (asg.Sum(et.l[nx], et.r[nx]) * 2 <= i)nx = lca.parent[0][nx];
ans -= (depth[p] - depth[nx])*(i + 1 - asg.Sum(et.l[nx], et.r[nx]) * 2);
p = nx;
}
else {//それ以外
int nx = p;
int dis = step[p] - step[l] - 1;
for (int j = lca.parent.size() - 1; j >= 0; j--) {
// cout << dis << endl;
if (dis >= (1 << j) && asg.Sum(et.l[lca.parent[j][nx]], et.r[lca.parent[j][nx]]) * 2 <= i) {
nx = lca.parent[j][nx];
dis -= 1 << j;
}
}
//cout << "fst " << nx << " " << asg.Sum(et.l[nx], et.r[nx]) << endl;
if (asg.Sum(et.l[nx], et.r[nx]) * 2 <= i)nx = lca.parent[0][nx];
//cout <<"snd "<< nx <<" "<< asg.Sum(et.l[nx], et.r[nx]) << endl;
if (nx != l) {//lcaを跨がない
ans += (depth[nx] - depth[p])*(i + 1 - sump * 2);
p = nx;
}
else {//lcaを跨ぐ
int dis = step[i] - step[l] - 1;
if (dis > 0) {
// cout << "dis " << dis << endl;
nx = i;
// cout << "nx " << nx << endl;
for (int j = lca.parent.size() - 1; j >= 0; j--) {
if (dis >= (1 << j) && asg.Sum(et.l[lca.parent[j][nx]], et.r[lca.parent[j][nx]]) * 2 <= i) {
nx = lca.parent[j][nx];
dis -= 1 << j;
}
}
// cout << "nxsnd " << nx << endl;
}
if (asg.Sum(et.l[nx], et.r[nx]) * 2 <= i)nx = lca.parent[0][nx];
ans += (depth[l] * 2 - depth[nx] - depth[p])*(i + 1 - sump * 2);
p = nx;
}
}
//cout << ans << " " << p << endl;
cout << ans << endl;
}
}
|
Example
Input
1 10 2
1 1 1
Output
2.0
|
#include <bits/stdc++.h>
#define ll long long
#define INF (1LL << 60)
#define MOD 1000000007
#define EPS 1e-10
#define rep(i,n) for(int i=0;i<(int)(n);++i)
#define rrep(i,n) for(int i=(int)(n)-1;i>=0;--i)
#define srep(i,s,t) for(int i=(int)(s);i<(int)(t);++i)
#define each(a,b) for(auto& (a): (b))
#define all(v) (v).begin(),(v).end()
#define len(v) (int)(v).size()
#define zip(v) sort(all(v)),v.erase(unique(all(v)),v.end())
#define cmx(x,y) x=max(x,y)
#define cmn(x,y) x=min(x,y)
#define fi first
#define se second
#define pb push_back
#define show(x) cout<<#x<<" = "<<(x)<<endl
#define spair(p) cout<<#p<<": "<<p.fi<<" "<<p.se<<endl
#define sar(a,n) cout<<#a<<":";rep(pachico,n)cout<<" "<<a[pachico];cout<<endl
#define svec(v) cout<<#v<<":";rep(pachico,v.size())cout<<" "<<v[pachico];cout<<endl
#define svecp(v) cout<<#v<<":";each(pachico,v)cout<<" {"<<pachico.first<<":"<<pachico.second<<"}";cout<<endl
#define sset(s) cout<<#s<<":";each(pachico,s)cout<<" "<<pachico;cout<<endl
#define smap(m) cout<<#m<<":";each(pachico,m)cout<<" {"<<pachico.first<<":"<<pachico.second<<"}";cout<<endl
using namespace std;
typedef pair<int,int> P;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<P> vp;
typedef vector<string> vs;
const int MAX_N = 100005;
ll f[1001];
ll dp1[1001],dp2[1001];
int mn[1001];
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int a,b,K;
cin >> a >> b >> K;
vl t(K+1);
rep(i,K+1){
cin >> t[i];
}
rep(i,b-a+1){
f[i] = INF;
}
f[1] = 0;
srep(i,2,b-a+1){
rep(j,i+1){
mn[j] = 0, dp1[j] = INF;
}
dp1[0] = 0;
rep(j,K+1){
rep(k,i+1){
dp2[k] = INF;
}
srep(k,j+1,i+1){
srep(l,max(mn[k],j),k){
if(dp2[k] > dp1[l]+(k-l)*t[j]+f[k-l]){
dp2[k] = dp1[l]+(k-l)*t[j]+f[k-l];
mn[k] = l;
}
}
}
if(j) cmn(f[i],dp2[i]);
swap(dp1,dp2);
}
}
printf("%.12lf\n",(double)f[b-a]/(b-a));
return 0;
}
|
K: Relief (Angel Relief)
Tenma, an angel, decides to save a city.
The city has a rectangular shape divided into north-south $ H $ parcels x east-west $ W $ parcels, with houses in each parcel.
The $ X $ th section from the north and the $ Y $ th section from the west are represented by $ (X, Y) $.
The house in parcel $ (i, j) $ is inhabited by $ A_ {i, j} $ people.
Tenshin chooses a rectangular area whose sides are parallel or vertical to north-south or east-west, and rescues all the people living in it one by one.
Tenshin does this for every possible rectangle.
Find the total number of times Tenma-san rescues people.
input
The integers $ H, W $ are given on the first line, separated by blanks.
Of the following $ H $ lines, the integers $ A_ {i, 1}, A_ {i, 2}, A_ {i, 3}, \ dots, A_ {i, W} $ are blank on the $ i $ line. Given as a delimiter.
output
Output the total number of times Tenma-san rescues people.
Constraint
* $ H, W $ are integers between $ 1 $ and $ 500 $
* $ A_ {i, j} $ are all integers greater than or equal to $ 1 $ and less than or equal to $ 9 $.
Input example 1
twenty two
1 2
4 8
Output example 1
60
For example, if you choose a rectangular area with $ (1, 1) $ in the upper left and $ (2, 2) $ in the lower right, you will rescue $ 15 $ people there one by one, so a total of $ 15 $ times. Relief.
$ 1, 2, 3, 4, 5, 8, 10, 12, 15 $ relief for each of the $ 9 $ rectangular areas, for a total of $ 60 $.
Input example 2
twenty three
one two Three
4 5 6
Output example 2
140
Example
Input
2 2
1 2
4 8
Output
60
|
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
#include <string>
#include <queue>
#include <functional>
#include <map>
using namespace std;
long long H, W, A[509][509], sum;
int main() {
cin >> H >> W;
for (int i = 1; i <= H; i++) {
for (int j = 1; j <= W; j++) {
cin >> A[i][j];
long long S1 = 1LL * i * (H + 1 - i);
long long S2 = 1LL * j * (W + 1 - j);
sum += A[i][j] * S1 * S2;
}
}
cout << sum << endl;
return 0;
}
|
Problem
There are $ N $ bus stops clockwise, numbered from $ 1 $ to $ N $ in a circle. Adjacent bus stops are connected by a road. For each $ i \ (1 \ le i \ le N) $, the length of the direct connection between the bus stop $ i $ and the bus stop $ i + 1 $ is $ d_i $ meters. However, bus stop $ N + 1 $ means bus stop $ 1 $.
There are $ M $ buses. The $ j \ (1 \ le j \ le M) $ th bus runs clockwise when $ c_j ='R'$ and counterclockwise when $ c_j ='L' $. It also takes $ t_j $ seconds to depart bus stop $ b_j $ at time $ 0 $ and travel $ 1 $ meters.
In this matter
* The bus keeps running forever
* It doesn't take long to get on and off the bus
* At a bus stop, you can get on and off the bus the moment it passes the bus stop.
* You cannot get on and off the bus except at the bus stop
* You can take as many buses as you like
And.
Process the following query a total of $ Q $ times.
* Find the minimum time required to depart bus stop $ x_k $ at time $ 0 $ and travel to bus stop $ y_k $ using only the bus.
Constraints
The input satisfies the following conditions.
* $ 3 \ leq N \ leq 10 ^ 5 $
* $ 1 \ leq M \ leq 10 ^ 5 $
* $ 1 \ leq Q \ leq 10 ^ 5 $
* $ 1 \ leq d_i \ leq 10 ^ 2 \ (1 \ leq i \ leq N) $
* $ c_j ='R' \ or \'L' \ (1 \ leq j \ leq M) $
* $ 1 \ leq b_j \ leq N \ (1 \ leq j \ leq M) $
* $ 1 \ leq t_j \ leq 10 ^ 5 \ (1 \ leq j \ leq M) $
* $ 1 \ leq x_k, y_k \ leq N \ (1 \ leq k \ leq Q) $
* $ x_k \ neq y_k \ (1 \ leq k \ leq Q) $
* All numbers given in the input are integers
Input
The input is given in the following format.
$ N $ $ M $ $ Q $
$ d_1 $ $ \ ldots $ $ d_N $
$ c_1 $ $ b_1 $ $ t_1 $
$ \ vdots $
$ c_M $ $ b_M $ $ t_M $
$ x_1 $ $ y_1 $
$ \ vdots $
$ x_Q $ $ y_Q $
The number of bus stops $ N $, the number of buses $ M $, and the number of queries $ Q $ are given on the first line, separated by blanks.
Information on the road connecting the adjacent bus stops is given on the second line, separated by blanks.
Bus information is given on the $ M $ line starting from the third line, separated by blanks.
Query information is given in the following $ Q $ line, separated by blanks.
Output
The output consists of $ Q $ lines.
Output the minimum required time for each query.
Print the answer to the $ k $ th query on the $ k $ line.
Examples
Input
3 1 6
1 2 3
R 1 1
1 2
1 3
2 1
2 3
3 1
3 2
Output
1
3
6
3
6
7
Input
4 6 7
45 72 81 47
R 1 47202
L 1 2156
L 2 95728
R 1 30739
L 3 39679
L 4 86568
3 2
3 4
1 2
2 4
4 3
1 4
2 1
Output
431200
629552
431200
629552
275968
101332
528220
|
#include <iostream>
#include <vector>
#include <algorithm>
#define llint long long
#define inf 1e18
using namespace std;
typedef pair<llint, llint> P;
struct LiChaoTree{
int size;
vector<P> seg;
vector<llint> x;
LiChaoTree(){}
LiChaoTree(int size){
this->size = size;
seg.resize(1<<(size+1));
x.resize(1<<size);
}
void init()
{
for(int i = 0; i < (1<<(size+1)); i++) seg[i] = make_pair(0, inf);
for(int i = 0; i < (1<<size); i++) x[i] = i;
}
llint calc(P f, llint x)
{
return f.first * x + f.second;
}
llint query(int i) //x[i]における最小値を取得
{
llint X = x[i], ret = inf;
i += (1 << size);
while(i >= 1){
ret = min(ret, calc(seg[i], X));
i /= 2;
}
return ret;
}
void add(int k, int l, int r, P f)
{
int m = (l+r)/2;
if(calc(f, x[m]) < calc(seg[k], x[m])) swap(seg[k], f);
bool L = (calc(f, x[l]) < calc(seg[k], x[l])), R = (calc(f, x[r]) < calc(seg[k], x[r]));
if(L == R) return;
if(L) add(k*2, l, m, f);
if(R) add(k*2+1, m+1, r, f);
}
void addSegment(int a, int b, int k, int l, int r, P f)
{
if(b < l || r < a) return;
if(a <= l && r <= b){
add(k, l, r, f);
return;
}
addSegment(a, b, k*2, l, (l+r)/2, f);
addSegment(a, b, k*2+1, (l+r)/2+1, r, f);
}
void addSegment(int a, int b, llint p, llint q) //区間[x[a], x[b]]に線分px+qを追加
{
addSegment(a, b, 1, 0, (1<<size)-1, make_pair(p, q));
}
void addLine(llint p, llint q) //直線px+qを追加
{
return addSegment(0, (1<<size)-1, p, q);
}
};
llint n, m, Q, L;
llint p[100005], np[100005];
char c[100005];
llint b[100005], t[100005];
llint x[100005], y[100005];
llint ans[100005];
vector<llint> qvec[100005], bvec[100005];
vector<llint> comp;
LiChaoTree lct(17);
llint dist(llint s, llint t)
{
if(t >= s) return t-s;
else return t-s+L;
}
void solve()
{
for(int i = 0; i < n; i++) qvec[i].clear();
for(int i = 1; i <= Q; i++) qvec[x[i]].push_back(i);
for(int i = 0; i < n; i++) bvec[i].clear();
for(int i = 1; i <= m; i++){
if(c[i] == 'R') bvec[b[i]].push_back(i);
}
comp.clear();
for(int i = 1; i <= Q; i++) comp.push_back(p[x[i]]+dist(p[x[i]], p[y[i]]));
sort(comp.begin(), comp.end());
comp.erase(unique(comp.begin(), comp.end()), comp.end());
int N = comp.size();
lct.init();
for(int i = 0; i < (1<<17); i++){
if(i < N) lct.x[i] = comp[i];
else lct.x[i] = 1e9;
}
for(int i = 1; i <= m; i++){
if(c[i] == 'R') lct.addLine(t[i], -(p[b[i]]-L)*t[i]);
}
for(int i = 0; i < n; i++){
for(int j = 0; j < bvec[i].size(); j++){
int bid = bvec[i][j];
lct.addLine(t[bid], -(p[b[bid]])*t[bid]);
}
for(int j = 0; j < qvec[i].size(); j++){
int qid = qvec[i][j];
llint id = lower_bound(comp.begin(), comp.end(), p[x[qid]] + dist(p[x[qid]], p[y[qid]])) - comp.begin();
ans[qid] = min(ans[qid], lct.query(id));
}
}
}
int main(void)
{
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> Q;
llint d;
for(int i = 0; i < n; i++){
cin >> d;
p[i] = L;
L += d;
}
for(int i = 1; i <= m; i++) cin >> c[i] >> b[i] >> t[i], b[i]--;
for(int i = 1; i <= Q; i++) cin >> x[i] >> y[i], x[i]--, y[i]--;
for(int i = 1; i <= Q; i++) ans[i] = inf;
solve();
for(int i = 1; i < n; i++) np[i] = L-p[n-i];
for(int i = 0; i < n; i++) p[i] = np[i];
for(int i = 1; i <= m; i++){
if(c[i] == 'L') c[i] = 'R';
else c[i] = 'L';
if(b[i] > 0) b[i] = n-b[i];
}
for(int i = 1; i <= Q; i++){
if(x[i] > 0) x[i] = n-x[i];
if(y[i] > 0) y[i] = n-y[i];
}
solve();
for(int i = 1; i <= Q; i++) cout << ans[i] << "\n";
flush(cout);
return 0;
}
|
For given a circle $c$ and a line $l$, print the coordinates of the cross points of them.
Constraints
* $p1$ and $p2$ are different
* The circle and line have at least one cross point
* $1 \leq q \leq 1,000$
* $-10,000 \leq cx, cy, x1, y1, x2, y2 \leq 10,000$
* $1 \leq r \leq 10,000$
Input
The input is given in the following format.
$cx\; cy\; r$
$q$
$Line_1$
$Line_2$
:
$Line_q$
In the first line, the center coordinate of the circle and its radius are given by $cx$, $cy$ and $r$. In the second line, the number of queries $q$ is given.
In the following $q$ lines, as queries, $Line_i$ are given ($1 \leq i \leq q$) in the following format.
$x_1\; y_1\; x_2\; y_2$
Each line is represented by two points $p1$ and $p2$ which the line crosses. The coordinate of $p1$ and $p2$ are given by ($x1$, $y1$) and ($x2$, $y2$) respectively. All input values are given in integers.
Output
For each query, print the coordinates of the cross points in the following rules.
* If there is one cross point, print two coordinates with the same values.
* Print the coordinate with smaller $x$ first. In case of a tie, print the coordinate with smaller $y$ first.
The output values should be in a decimal fraction with an error less than 0.000001.
Example
Input
2 1 1
2
0 1 4 1
3 0 3 3
Output
1.00000000 1.00000000 3.00000000 1.00000000
3.00000000 1.00000000 3.00000000 1.00000000
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <cmath>
#include <cstring>
#include <utility>
#include <numeric>
#include <complex>
#include <iomanip>
using namespace std;
// common
#define X real()
#define Y imag()
using Vector2 = complex<double>;
using Line = pair<Vector2, Vector2>;
using Segment = pair<Vector2, Vector2>;
const double EPS = 1e-10;
const double PI = 3.14159265359;
bool equals(double a, double b){
if(abs(a - b) < EPS){
return true;
}
else{
return false;
}
}
// struct
struct Circle{
Vector2 c;
double r;
Circle(Vector2 c, double r){
this->c = c;
this->r = r;
}
};
// Vector2
double abs(Vector2 v){
return sqrt(norm(v));
}
double dot(Vector2 a, Vector2 b){
return (a.X * b.X + a.Y * b.Y);
}
double cross(Vector2 a, Vector2 b){
return (a.X * b.Y - a.Y * b.X);
}
Vector2 project(Line l, Vector2 p){
Vector2 base = l.second - l.first;
double r = dot(p - l.first, base) / norm(base);
return l.first + base * r;
}
pair<Vector2, Vector2> crossPoints(Circle c, Line l){
Vector2 pr = project(l, c.c);
Vector2 e = (l.second - l.first) / abs(l.second - l.first);
double base = sqrt(c.r * c.r - norm(pr - c.c));
return make_pair(pr + e * base, pr - e * base);
}
int main(){
int cx, cy, r;
cin >> cx >> cy >> r;
Circle c(Vector2(cx, cy), r);
int q;
cin >> q;
for(int i = 0; i < q; i++){
int x0, y0, x1, y1;
cin >> x0 >> y0 >> x1 >> y1;
Line l(Vector2(x0, y0), Vector2(x1, y1));
auto ans = crossPoints(c, l);
Vector2 ansMin, ansMax;
if(equals(ans.first.X, ans.second.X)){
if(ans.first.Y < ans.second.Y){
ansMin = ans.first;
ansMax = ans.second;
}
else{
ansMin = ans.second;
ansMax = ans.first;
}
}
else{
if(ans.first.X < ans.second.X){
ansMin = ans.first;
ansMax = ans.second;
}
else{
ansMin = ans.second;
ansMax = ans.first;
}
}
cout << fixed << setprecision(8) << ansMin.X << " " << ansMin.Y << " " << ansMax.X << " " << ansMax.Y << endl;
}
return 0;
}
|
For a set $S$ of integers, perform a sequence of the following operations. Note that each value in $S$ must be unique.
* insert($x$): Insert $x$ to $S$ and report the number of elements in $S$ after the operation.
* find($x$): Report the number of $x$ in $S$ (0 or 1).
* delete($x$): Delete $x$ from $S$.
Constraints
* $1 \leq q \leq 200,000$
* $0 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $x$
or
1 $x$
or
2 $x$
where the first digits 0, 1 and 2 represent insert, find and delete operations respectively.
Output
For each insert operation, print the number of elements in $S$.
For each find operation, print the number of specified elements in $S$.
Example
Input
8
0 1
0 2
0 3
2 2
1 1
1 2
1 3
0 2
Output
1
2
3
1
0
1
3
|
#include <cstdio>
#include <utility>
#include <unordered_set>
using namespace std;
#define gcu getchar_unlocked
#define pcu putchar_unlocked
#define _T template <typename T>
#define _HT template <typename H, typename... T>
#define _il inline
#define _in _il int in
#define _sc _il bool scan
_T T in(int c){T n=0;bool m=false;if(c=='-')m=true,c=gcu();
do{n=10*n+(c-'0'),c=gcu();}while(c>='0');return m?-n:n;} //&&c<='9'
_in() {return in<int>(gcu());}
_T T scan(T &n){int c=gcu();return c==EOF?false:(n=in<T>(c),true);}
_sc(char &c){c=gcu();gcu();return c!=EOF;}
//_sc(string &s){int c;s="";
// for(;;){c=gcu();if(c=='\n'||c==' ')return true;else if(c==EOF)return false;s+=c;}}
_HT _sc(H &h, T&&... t){return scan(h)&&scan(t...);}
#define _vo _il void out
#define _vl _il void outl
_vo(const char *s){while(*s)pcu(*s++);}
_vo(char c){pcu(c);}
//_vo(string &s){for(char c:s)pcu(c);}
//_vo(string s){for(char c:s)pcu(c);}
_T _vo(T n){static char buf[20];char *p=buf;
if(n<0)pcu('-'),n*=-1;if(!n)*p++='0';else while(n)*p++=n%10+'0',n/=10;
while (p!=buf)pcu(*--p);}
_vl(){out('\n');}
//_T _vo(vector<T> &v){for(T &x:v)out(&x == &v[0]?"":" "),out(x);outl();}
_HT _vo(H&& h, T&&... t){out(h);out(move(t)...);}
template <typename... T> _vl(T&&... t){out(move(t)...);outl();}
int main() {
unordered_set<int> A;
for (int i = in(); i; i--)
switch(in()) {
case 0:
A.insert(in());
outl(A.size());
break;
case 1:
outl(A.count(in()));
break;
default:
A.erase(in());
}
}
|
Zombies zombies everywhere!!
In a parallel world of zombies, there are N zombies. There are infinite number of unused cars, each of same model only differentiated by the their colors. The cars are of K colors.
A zombie parent can give birth to any number of zombie-children (possibly zero), i.e. each zombie will have its parent except the head zombie which was born in the winters by combination of ice and fire.
Now, zombies are having great difficulties to commute to their offices without cars, so they decided to use the cars available. Every zombie will need only one car. Head zombie called a meeting regarding this, in which he will allow each zombie to select a car for him.
Out of all the cars, the head zombie chose one of cars for him. Now, he called his children to choose the cars for them. After that they called their children and so on till each of the zombie had a car. Head zombie knew that it won't be a good idea to allow children to have cars of same color as that of parent, as they might mistakenly use that. So, he enforced this rule during the selection of cars.
Professor James Moriarty is a criminal mastermind and has trapped Watson again in the zombie world. Sherlock somehow manages to go there and met the head zombie. Head zombie told Sherlock that they will let Watson free if and only if Sherlock manages to tell him the maximum number of ways in which the cars can be selected by N Zombies among all possible hierarchies. A hierarchy represents parent-child relationships among the N zombies. Since the answer may be large, output the answer modulo 10^9 + 7. Sherlock can not compute big numbers, so he confides you to solve this for him.
Input
The first line consists of a single integer T, the number of test-cases.
Each test case consists of two space-separated integers N and K, denoting number of zombies and the possible number of colors of the cars respectively.
Output
For each test-case, output a single line denoting the answer of the problem.
Constraints
1 ≤ T ≤ 100
1 ≤ N ≤ 10^9
1 ≤ K ≤ 10^9
Example
Input
2
2 2
3 3
Output:
2
12
Explanation
In the first sample test case, there are 2 zombies. Let us name them Z1 and Z2. Let one hierarchy be one in which Z1 is parent of Z2. There are 2 colors, suppose red and blue. If Z1 takes red, then Z2 should take a blue. If Z1 takes blue, then Z2 should take red.
Note that one other possible hierarchy could be one in which Z2 is a parent of Z1. In that hierarchy also, number of possible ways of assigning cars is 2.
So there maximum number of possible ways is 2.
In the second example, we have 3 Zombies say Z1, Z2, Z3 and cars of 3 colors, suppose red, blue and green.
A hierarchy to maximize the number of possibilities is Z1 is the parent of Z2, Z2 is the parent of Z3.
Zombie Z1 can choose one of red, blue or green cars. Z2 can choose one of the remaining two colors (as its car's color can not be same as its parent car.). Z3 can also choose his car in two colors, (one of them could be color same as Z1, and other being the color which is not same as cars of both Z1 and Z2.). This way, there can be 12 different ways of selecting the cars.
|
mod = 10 ** 9 + 7
def powmod(n, p):
if p == 0:
return 1
if p == 1:
return n % mod
if p % 2 == 1:
return n * powmod(n, p - 1) % mod
x = powmod(n, p / 2) % mod
return x * x % mod
t = int(raw_input())
for i in xrange(t):
n, k = map(int, raw_input().split())
print k * powmod(k - 1, n - 1) % mod
|
Jagjit Singh (Jaggi) is among the few fastest athletes of Thapar. Just before the Thapar Olympics he thought of a new way to practice. He decided he will run in intervals. In each interval , he will run at a particular speed. You have to calculate the total distance traveled by him, given the speed M and time S for each interval.
Input
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
Each test case will contain a single number N, the number of intervals. Then N lines follow.
Each of the next N lines will contain the length of the interval in seconds (S) and speed (M) in that interval in(m/sec).
Output
For each test case output the total distance covered by him in meters(m) separated by new line.
Constraints
0 < T < 100
0 < N <= 10000
0 <= S <= 10^5
0 <= M <= 10^5
Don't get shocked after looking at constraints, sometimes he becomes super fast. ;)
Example
Input:
2
3
2 5
1 6
3 10
5
1 1
2 2
3 3
4 10
5 1
Output:
46
59
|
import sys
t=sys.stdin.readline()
t=int(t)
for k in range(0,t):
n=sys.stdin.readline()
n=int(n)
d=0
for i in range(0,n):
string=sys.stdin.readline()
t,s=string.split(" ")
t=int(t)
s=int(s)
d=d+t*s
print d
|
Alice's school is planning to take some students from her class on a field trip. Alice is really excited about it. There are a total of S students in her class. But due to budget constraints, the school is planning to take only N students for the trip. These students will be picked randomly. And each student has equal chance of being picked.
Alice's friend circle has M students including her. Though she is excited about the field trip, she will enjoy it only if there are atleast K of her friends with her on the trip. She is wondering what are the chances of that happening. She needs your help. Tell her the probability that she will enjoy given that she goes on the trip.
Input:
First line of input contains a single integer T, the number of test cases.
Each test starts with a single line having 4 space separated integers, S, N, M and K.
Output:
For each test case, output a line containing the required probability. The answer will be accepted if the relative error is not more than 10^-6.
Constraints:
1 ≤ T ≤ 100
1 ≤ S ≤ 1000
1 ≤ N ≤ S
1 ≤ M ≤ S
0 ≤ K < M
Example:
Input:
3
10 10 5 3
10 4 6 4
3 2 2 1
Output:
1.000000
0.000000
0.500000
Explanation:
Case #1:
Every student will be taken to the trip. So all her 4 friends will accompany her to the trip no matter what.
Case #2:
Alice wants 4 out of her 5 friends to come along with her which isn't possible because the school is willing to pick only 4 students for the trip.
|
nCr = [[0 for x in xrange(1001)] for x in xrange(1001)]
for i in range (0,1001):
nCr[i][0]=1
nCr[i][i]=1
for i in range (1,1001):
for j in range (1,1001):
if i!=j:
nCr[i][j] = nCr[i-1][j] + nCr[i-1][j-1]
t=input()
for _ in range(0,t):
s,n,m,k=map(int,raw_input().split(' '))
y=0
if s==n:
print("1.000000")
continue
if (k>m or k>n):
print ("0.000000")
continue
total = float(nCr[s-1][n-1])
if m>n:z=m
else:z=n
for i in range(k,z):
y+=((nCr[m-1][i])*(nCr[s-m][n-i-1]))
print"%.6f" % (float(y/total))
|
Chef loves lucky numbers. Everybody knows that lucky numbers are positive integers whose decimal representation contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Let Fd(x) equals to the number of digits d in decimal representation of the positive integer x. Chef interests only in functions F4(x) and F7(x). For the given positive integer N he wants to know the total number of different pairs (L; R) such that F4(L) + F4(L + 1) + ... + F4(R) equals to F7(L) + F7(L + 1) + ... + F7(R) and 1 ≤ L ≤ R ≤ N.
Input
The first line contains a single positive integer T, the number of test cases. T test cases follow. The only line of each test case contains a positive integer N .
Output
For each test case, output a single line containing the answer for the corresponding test case.
Constraints
1 ≤ T ≤ 100000
1 ≤ N ≤ 100000
Example
Input:
3
3
10
100
Output:
6
31
1266
|
#codechef feb long quest
M=[0]*100001
A=[0]*100001
M[0]=1
s4=0
s7=0
ret=0
for el in range(1,100001):
n=el
while n>0:
k=n%10
if(k==4):s4+=1
if(k==7):s7+=1
n=n/10
ret+=M[s4-s7]
A[el]=ret
M[s4-s7]+=1
t=int(raw_input())
for i in range(t):
n=int(raw_input())
print(A[n])
|
Damian Wayne and Carrie Kelly are classmates and best friends. Since class 5, they have been in the same section. They usually sat on the last bench so that they could chat all they want during the class. One day, during the ancient martial arts period, Master Kirigi caught them and asked Damian to sit in the first bench.
Damian, however, was one who did not give up easily. He decided that he can send messages to Carrie by writing each message on a small piece of paper and passing it to the students sitting in the front who finally pass it on to Carrie. Being the intelligent boy he was, he quickly encrypted his messages by an unknown encryption method, to ensure that no one else read it, and passed it backwards to Carrie. Carrie, however, was not as good in cracking encryptions.
In her time of need, Carrie asks for your help in cracking the encryption and encrypting any message that she wants to pass to Damian.
Input
The first line of the input will consist of an integer t (1<=t<=100)
t lines follow.
Each line consists of a string S (1<=|S|<=1000), which will consists of only lower case letter, numbers and special symbols.
Output
Output will consist of t lines. Each line will consist of a string E corresponding to the encrypted message.
Example
Input:
2
die another day.
i'm batman.
Output:
v0w s56bzw9 vsg.
0'4 tsb4s5.
|
a=input()
for i in range(a):
b=raw_input()
string=""
for j in b:
k=ord(j)
if(48<=k<=57):
string+=chr(k+57)
elif(97<=k<=104):
string+=chr(k+18)
elif(105<=k<=114):
string+=chr(k-57)
elif(115<=k<=122):
string+=chr(k-18)
else:
string+=j
print string
|
ABC School is organising a sporting event. But they don’t know which game they should take up, so that every person can be divided in equally-sized teams with no one left over. Now, the school consists of various classes. You are given an array ‘A’ consisting of strength of these classes. Assuming a game of every possible team size exists and the school want to reduce the number of teams to minimum possible, you need to tell us just the team size.
Input
The first line consists of T: the number of test cases
Each test case starts with a number N: denoting the number of classes in the school.
The next line consists of N space separated natural numbers giving the strength of the ith class.
Output
For each test case, output only one integer, the team-size.
Answer for each test case should be printed in a new line.
Constraints
1 ≤ T ≤ 10000
1 ≤ N ≤ 1000
1 ≤ A[i] ≤ 100000
Example
Input:
3
3
1 2 3
3
4 12 6
2
8 12
Output:
1
2
4
|
for b in range(input()):
c = input()
d = map(int,raw_input().split())
d.sort()
for k in range(d[0],0,-1):
for l in d:
if l % k == 0:
flag = 1
else:
flag = 0
break
if flag == 1:
print k
break
|
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;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long mod = (int)1e9 + 7;
const int N = 1e6 + 100;
int n;
int op[N];
int ok[N];
int val[N];
int ans[2];
char s[10];
vector<int> son[N];
void dfs(int u) {
if (op[u] == 4) return;
for (int i = 0; i < son[u].size(); i++) dfs(son[u][i]);
int x = son[u][0];
if (op[u] == 3) {
val[u] = 1 ^ val[x];
ok[x] = 1;
}
int y = son[u][1];
if (op[u] == 1) {
val[u] = val[x] & val[y];
if (val[y] == 1) ok[x] = 1;
if (val[x] == 1) ok[y] = 1;
} else if (op[u] == 2) {
val[u] = val[x] ^ val[y];
ok[x] = ok[y] = 1;
} else if (op[u] == 5) {
val[u] = val[x] | val[y];
if (val[x] == 1 && val[y] == 0) ok[x] = 1;
if (val[x] == 0 && val[y] == 1) ok[y] = 1;
if (val[x] == 0 && val[y] == 0) ok[x] = ok[y] = 1;
}
}
void dfs2(int u, int flag) {
ok[u] &= flag;
for (int i = 0; i < son[u].size(); i++) dfs2(son[u][i], ok[u]);
}
int main() {
scanf("%d", &n);
int u, v;
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
if (s[1] == 'I')
op[i] = 4, scanf("%d", &val[i]);
else if (s[1] == 'N') {
scanf("%d", &u);
son[i].push_back(u);
op[i] = 3;
} else {
scanf("%d%d", &u, &v);
son[i].push_back(u);
son[i].push_back(v);
if (s[1] == 'A') op[i] = 1;
if (s[1] == 'X') op[i] = 2;
if (s[1] == 'O') op[i] = 5;
}
}
dfs(1);
ok[1] = 1;
dfs2(1, 1);
ans[0] = val[1];
ans[1] = val[1] ^ 1;
for (int i = 1; i <= n; i++)
if (op[i] == 4) printf("%d", ans[ok[i]]);
return 0;
}
|
You are given an acyclic directed graph, consisting of n vertices and m edges. The graph contains no multiple edges and no self-loops.
The vertex is called a source if it has no incoming edges. The vertex is called a sink if it has no outgoing edges. These definitions imply that some vertices can be both source and sink.
The number of sources in the given graph is equal to the number of sinks in it, and each of these numbers doesn't exceed 20.
The following algorithm is applied to the graph:
1. if the graph has no sources and sinks then quit;
2. choose arbitrary source s, arbitrary sink t, add an edge from t to s to the graph and go to step 1 (that operation pops s out of sources and t out of sinks). Note that s and t may be the same vertex, then a self-loop is added.
At the end you check if the graph becomes strongly connected (that is, any vertex is reachable from any other vertex).
Your task is to check that the graph becomes strongly connected no matter the choice of sources and sinks on the second step of the algorithm.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^6) — the number of vertices and the number of edges in the graph, respectively.
Each of the next m lines contains two integers v_i, u_i (1 ≤ v_i, u_i ≤ n, v_i ≠ u_i) — the description of the i-th edge of the original graph.
It is guaranteed that the number of sources and the number of sinks in the graph are the same and they don't exceed 20. It is guaranteed that the given graph contains no multiple edges. It is guaranteed that the graph contains no cycles.
Output
Print "YES" if the graph becomes strongly connected no matter the choice of sources and sinks on the second step of the algorithm. Otherwise print "NO".
Examples
Input
3 1
1 2
Output
NO
Input
3 3
1 2
1 3
2 3
Output
YES
Input
4 4
1 2
1 3
4 2
4 3
Output
YES
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000, M = 20;
int n, m;
struct side {
int y, next;
} e[N * 2 + 9];
int lin[N + 9], cs;
void Ins(int x, int y) {
e[++cs].y = y;
e[cs].next = lin[x];
lin[x] = cs;
}
int in[N + 9], out[N + 9];
void into() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
Ins(x, y);
++in[y];
++out[x];
}
}
int dp[N + 9], vis[N + 9], c;
int Dfs_dp(int k) {
if (vis[k]) return dp[k];
vis[k] = 1;
if (!out[k]) dp[k] |= 1 << c++;
for (int i = lin[k]; i; i = e[i].next) dp[k] |= Dfs_dp(e[i].y);
return dp[k];
}
void Get_dp() {
for (int i = 1; i <= n; ++i)
if (!vis[i]) Dfs_dp(i);
}
int to[(1 << M) + 9], cnt[(1 << M) + 9], ans;
void Get_to() {
c = 0;
for (int i = 1; i <= n; ++i)
if (!in[i]) to[1 << c++] = dp[i];
ans = 1;
for (int s = 0; s < 1 << c; ++s) cnt[s] = cnt[s >> 1] + (s & 1);
for (int s = 1; s < 1 << c; ++s) {
to[s] = to[s & -s] | to[s ^ s & -s];
cnt[s] = cnt[s >> 1] + (s & 1);
if (cnt[to[s]] < cnt[s]) ans = 0;
if (s ^ (1 << c) - 1 && cnt[to[s]] == cnt[s]) ans = 0;
}
}
void work() {
Get_dp();
Get_to();
}
void outo() { puts(ans ? "YES" : "NO"); }
int main() {
int T = 1;
for (; T--;) {
into();
work();
outo();
}
return 0;
}
|
In Disgaea as in most role-playing games, characters have skills that determine the character's ability to use certain weapons or spells. If the character does not have the necessary skill, he cannot use it. The skill level is represented as an integer that increases when you use this skill. Different character classes are characterized by different skills.
Unfortunately, the skills that are uncommon for the given character's class are quite difficult to obtain. To avoid this limitation, there is the so-called transmigration.
Transmigration is reincarnation of the character in a new creature. His soul shifts to a new body and retains part of his experience from the previous life.
As a result of transmigration the new character gets all the skills of the old character and the skill levels are reduced according to the k coefficient (if the skill level was equal to x, then after transmigration it becomes equal to [kx], where [y] is the integral part of y). If some skill's levels are strictly less than 100, these skills are forgotten (the character does not have them any more). After that the new character also gains the skills that are specific for his class, but are new to him. The levels of those additional skills are set to 0.
Thus, one can create a character with skills specific for completely different character classes via transmigrations. For example, creating a mage archer or a thief warrior is possible.
You are suggested to solve the following problem: what skills will the character have after transmigration and what will the levels of those skills be?
Input
The first line contains three numbers n, m and k — the number of skills the current character has, the number of skills specific for the class into which the character is going to transmigrate and the reducing coefficient respectively; n and m are integers, and k is a real number with exactly two digits after decimal point (1 ≤ n, m ≤ 20, 0.01 ≤ k ≤ 0.99).
Then follow n lines, each of which describes a character's skill in the form "name exp" — the skill's name and the character's skill level: name is a string and exp is an integer in range from 0 to 9999, inclusive.
Then follow m lines each of which contains names of skills specific for the class, into which the character transmigrates.
All names consist of lowercase Latin letters and their lengths can range from 1 to 20 characters, inclusive. All character's skills have distinct names. Besides the skills specific for the class into which the player transmigrates also have distinct names.
Output
Print on the first line number z — the number of skills the character will have after the transmigration. Then print z lines, on each of which print a skill's name and level, separated by a single space. The skills should be given in the lexicographical order.
Examples
Input
5 4 0.75
axe 350
impaler 300
ionize 80
megafire 120
magicboost 220
heal
megafire
shield
magicboost
Output
6
axe 262
heal 0
impaler 225
magicboost 165
megafire 0
shield 0
|
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
ArrayList<Property> list = new ArrayList<Property>();
Set<String> set = new TreeSet<String>();
int n = input.nextInt();
int m = input.nextInt();
int k = (int) Math.round(input.nextDouble() * 100);
for (int i = 0; i < n; i++) {
String name = input.next();
int number = input.nextInt() * k / 100;
if (number >= 100) {
list.add(new Property(name, number));
set.add(name);
}
}
for (int i = 0; i < m; i++) {
String name01 = input.next();
if (!(set.contains(name01))) {
list.add(new Property(name01, 0));
}
}
Collections.sort(list, new Comp());
System.out.println(list.size());
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i).name + " " + list.get(i).number);
}
}
}
class Property {
String name;
int number;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public Property(String name, int number) {
this.name = name;
this.number = number;
}
@Override
public String toString() {
return name + " " + number;
}
}
class Comp implements Comparator<Property> {
@Override
public int compare(Property o1, Property o2) {
// TODO Auto-generated method stub
return o1.getName().compareTo(o2.getName());
}
}
|
Chouti and his classmates are going to the university soon. To say goodbye to each other, the class has planned a big farewell party in which classmates, teachers and parents sang and danced.
Chouti remembered that n persons took part in that party. To make the party funnier, each person wore one hat among n kinds of weird hats numbered 1, 2, … n. It is possible that several persons wore hats of the same kind. Some kinds of hats can remain unclaimed by anyone.
After the party, the i-th person said that there were a_i persons wearing a hat differing from his own.
It has been some days, so Chouti forgot all about others' hats, but he is curious about that. Let b_i be the number of hat type the i-th person was wearing, Chouti wants you to find any possible b_1, b_2, …, b_n that doesn't contradict with any person's statement. Because some persons might have a poor memory, there could be no solution at all.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5), the number of persons in the party.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ n-1), the statements of people.
Output
If there is no solution, print a single line "Impossible".
Otherwise, print "Possible" and then n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ n).
If there are multiple answers, print any of them.
Examples
Input
3
0 0 0
Output
Possible
1 1 1
Input
5
3 3 2 2 2
Output
Possible
1 1 2 2 2
Input
4
0 1 2 3
Output
Impossible
Note
In the answer to the first example, all hats are the same, so every person will say that there were no persons wearing a hat different from kind 1.
In the answer to the second example, the first and the second person wore the hat with type 1 and all other wore a hat of type 2.
So the first two persons will say there were three persons with hats differing from their own. Similarly, three last persons will say there were two persons wearing a hat different from their own.
In the third example, it can be shown that no solution exists.
In the first and the second example, other possible configurations are possible.
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5, MOD = 998244353;
pair<long long, long long> c[N];
long long a[N], b[N];
unordered_map<long long, long long> m;
signed main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
c[i] = {a[i], i};
}
sort(c + 1, c + n + 1, greater<pair<long long, long long> >());
long long ptr = 1, cnt = 1;
for (long long i = 1; i <= n; i++) {
long long num = c[i].first, idx = c[i].second;
long long rem = n - num;
for (long long j = i; j <= (i + rem - 1); j++) {
if (j > n) break;
b[c[j].second] = cnt;
m[cnt]++;
}
cnt++;
i = i + rem - 1;
}
for (long long i = 1; i <= n; i++) {
long long idx = c[i].second;
long long num = c[i].first;
if (num != (n - m[b[idx]])) {
cout << "Impossible\n";
return 0;
}
}
cout << "Possible\n";
for (long long i = 1; i <= n; i++) cout << b[i] << " ";
return 0;
}
|
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, …, a_m (1 ≤ a_i ≤ n) — the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem.
|
import java.io.*;
import java.util.*;
public class Main{
static class Re
{
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Re()
{
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Re(String file_name) throws IOException
{
din = new DataInputStream(new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException
{
byte[] buf = new byte[1000000]; // line length
int cnt = 0, c;
while ((c = read()) != -1)
{
if (c == '\n')
break;
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
public int nextInt() throws IOException
{
int ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do
{
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public long nextLong() throws IOException
{
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public double nextDouble() throws IOException
{
double ret = 0, div = 1;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (c == '.')
{
while ((c = read()) >= '0' && c <= '9')
{
ret += (c - '0') / (div *= 10);
}
}
if (neg)
return -ret;
return ret;
}
private void fillBuffer() throws IOException
{
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}
private byte read() throws IOException
{
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}
public void close() throws IOException
{
if (din == null)
return;
din.close();
}
}
public static void main(String[] args) throws IOException{
Re r=new Re();
int n=r.nextInt();
int m=r.nextInt();
int[] c=new int[n+1];
HashSet<Integer> hs=new HashSet<>();
for(int i=0;i<m;i++){
int u=r.nextInt();
c[u]++;
hs.add(u);
if(hs.size()==n){
System.out.print(1);
for(int j=0;j<=n;j++){
c[j]--;
if(c[j]==0) hs.remove(j);
}
}
else{
System.out.print(0);
}
}
}
}
|
Suppose you are given a string s of length n consisting of lowercase English letters. You need to compress it using the smallest possible number of coins.
To compress the string, you have to represent s as a concatenation of several non-empty strings: s = t_{1} t_{2} … t_{k}. The i-th of these strings should be encoded with one of the two ways:
* if |t_{i}| = 1, meaning that the current string consists of a single character, you can encode it paying a coins;
* if t_{i} is a substring of t_{1} t_{2} … t_{i - 1}, then you can encode it paying b coins.
A string x is a substring of a string y if x can be obtained from y by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end.
So your task is to calculate the minimum possible number of coins you need to spend in order to compress the given string s.
Input
The first line contains three positive integers, separated by spaces: n, a and b (1 ≤ n, a, b ≤ 5000) — the length of the string, the cost to compress a one-character string and the cost to compress a string that appeared before.
The second line contains a single string s, consisting of n lowercase English letters.
Output
Output a single integer — the smallest possible number of coins you need to spend to compress s.
Examples
Input
3 3 1
aba
Output
7
Input
4 1 1
abcd
Output
4
Input
4 10 1
aaaa
Output
12
Note
In the first sample case, you can set t_{1} = 'a', t_{2} = 'b', t_{3} = 'a' and pay 3 + 3 + 1 = 7 coins, since t_{3} is a substring of t_{1}t_{2}.
In the second sample, you just need to compress every character by itself.
In the third sample, you set t_{1} = t_{2} = 'a', t_{3} = 'aa' and pay 10 + 1 + 1 = 12 coins, since t_{2} is a substring of t_{1} and t_{3} is a substring of t_{1} t_{2}.
|
import java.io.*;
import java.util.*;
public class Main {
private void solve() throws Exception {
n = nextInt();
a = nextLong();
b = nextLong();
s = nextToken();
memo = new Long[n];
out.println(doit(0));
}
Long[] memo;
long a;
long b;
int n;
String s;
long doit(int i){
if(i == n) return 0L;
else if(memo[i] == null){
long res = a + doit(i+1);
if(s.substring(0,i).contains(s.substring(i,i+1))) {
int l = i;
int r = n;
while(l < r-1){
int mid = (l+r)/2;
if(s.substring(0,i).contains(s.substring(i,mid+1))) l = mid;
else r = mid;
}
for(int j = i; j <= l; j++) res = Math.min(res, b + doit(j+1));
}
memo[i] = res;
}
return memo[i];
}
public static void main(String[] args) {
new Main().run();
}
private BufferedReader in;
private PrintWriter out;
private StringTokenizer tokenizer;
public void run() {
try {
in = new BufferedReader(new InputStreamReader(System.in));
tokenizer = null;
out = new PrintWriter(System.out);
solve();
in.close();
out.close();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
private int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
private long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
private float nextFloat() throws IOException {
return Float.parseFloat(nextToken());
}
private String nextLine() throws IOException {
return new String(in.readLine());
}
private String nextToken() throws IOException {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(in.readLine());
}
return tokenizer.nextToken();
}
}
|
You are given an array which is initially empty. You need to perform n operations of the given format:
* "a l r k": append a to the end of the array. After that count the number of integer pairs x, y such that l ≤ x ≤ y ≤ r and \operatorname{mex}(a_{x}, a_{x+1}, …, a_{y}) = k.
The elements of the array are numerated from 1 in the order they are added to the array.
To make this problem more tricky we don't say your real parameters of the queries. Instead your are given a', l', r', k'. To get a, l, r, k on the i-th operation you need to perform the following:
* a := (a' + lans) mod(n + 1),
* l := (l' + lans) mod{i} + 1,
* r := (r' + lans) mod{i} + 1,
* if l > r swap l and r,
* k := (k' + lans) mod(n + 1),
where lans is the answer to the previous operation, initially lans is equal to zero. i is the id of the operation, operations are numbered from 1.
The \operatorname{mex}(S), where S is a multiset of non-negative integers, is the smallest non-negative integer which does not appear in the set. For example, \operatorname{mex}(\{2, 2, 3\}) = 0 and \operatorname{mex} (\{0, 1, 4, 1, 6\}) = 2.
Input
The first line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array.
The next n lines contain the description of queries.
Each of them n lines contains four non-negative integers a', l', r', k' (0, ≤ a', l', r', k' ≤ 10^9), describing one operation.
Output
For each query print a single integer — the answer to this query.
Examples
Input
5
0 0 0 1
0 1 0 5
5 2 1 0
5 2 1 0
2 4 3 3
Output
1
1
2
6
3
Input
5
2 0 0 2
2 0 1 1
0 0 2 0
3 2 2 0
0 2 3 0
Output
0
0
3
0
0
Note
For the first example the decoded values of a, l, r, k are the following:
a_1=0,l_1=1,r_1=1,k_1=1
a_2=1,l_2=1,r_2=2,k_2=0
a_3=0,l_3=1,r_3=3,k_3=1
a_4=1,l_4=1,r_4=4,k_4=2
a_5=2,l_5=1,r_5=5,k_5=3
For the second example the decoded values of a, l, r, k are the following:
a_1=2,l_1=1,r_1=1,k_1=2
a_2=2,l_2=1,r_2=2,k_2=1
a_3=0,l_3=1,r_3=3,k_3=0
a_4=0,l_4=2,r_4=2,k_4=3
a_5=0,l_5=3,r_5=4,k_5=0
|
#include <bits/stdc++.h>
using ll = long long;
const int MN = 2e5 + 100;
int N;
struct node {
public:
node *l, *r;
ll v, z;
node() : l(nullptr), r(nullptr), v(0LL), z(0LL){};
};
const int pool_sz = 50000;
node *pool;
int pool_ctr;
node *nn(node *p = nullptr) {
if (!pool_ctr) pool = new node[pool_ctr = pool_sz];
if (p) pool[pool_ctr - 1] = *p;
return pool + --pool_ctr;
}
void upd(node *&n, int l, int r, int ql, int qr, ll q) {
n = nn(n);
n->v += (qr - ql) * q;
if (ql == l && r == qr)
n->z += q;
else {
int m = l + (r - l) / 2;
if (ql < m) upd(n->l, l, m, ql, std::min(qr, m), q);
if (m < qr) upd(n->r, m, r, std::max(m, ql), qr, q);
}
}
ll qry(node *n, int l, int r, int ql, int qr) {
if (!n) return 0LL;
ll f = 0LL;
if (ql == l && r == qr)
return n->v;
else {
f = n->z * (qr - ql);
int m = l + (r - l) / 2;
if (ql < m) f += qry(n->l, l, m, ql, std::min(qr, m));
if (m < qr) f += qry(n->r, m, r, std::max(m, ql), qr);
return f;
}
}
struct S {
public:
node *n;
int t;
};
std::vector<S> m[MN];
int lb(int k, int v) {
int l = 0, r = m[k].size();
for (; r - l > 1;) {
int x = l + (r - l) / 2;
if (m[k][x].t < v)
l = x;
else
r = x;
}
return r;
}
struct R {
public:
int m;
mutable int t;
R(int m = -1, int t = 0) : m(m), t(t) {}
bool operator<(R o) const { return m < o.m; }
};
std::set<R> r;
void fix(std::set<R>::iterator it, int i, bool over = 0) {
int v = it->m;
S x = m[v].back();
if (over && x.t == i) return;
if (!over) assert(x.t != i);
node *n = x.n;
upd(n, 0, N, std::next(it)->t, it->t, i - x.t);
m[v].push_back(S{n, i});
}
void fix(int v, int i, bool over = 0) {
if (over && m[v].back().t == i) return;
if (!over) assert(m[v].back().t < i);
m[v].push_back(S{m[v].back().n, i});
}
int p[MN];
ll getper(int k, int i, int l, int r) {
if (i == m[k].size()) {
std::set<R>::iterator it = ::r.lower_bound({k, 0});
return it->m == k
? std::max(0LL,
static_cast<ll>(std::min(r, it->t) -
std::max(l - 1, std::next(it)->t)))
: 0LL;
}
return (qry(m[k][i].n, 0, N, l - 1, r) - qry(m[k][i - 1].n, 0, N, l - 1, r)) /
(m[k][i].t - m[k][i - 1].t);
}
ll P;
void convert(int i, int *a, int *l, int *r, int *k) {
*a = (*a + P) % (N + 1);
*l = (*l + P) % i + 1;
*r = (*r + P) % i + 1;
if (*r < *l) *l ^= *r ^= *l ^= *r;
*k = (*k + P) % (N + 1);
}
void ans_q(int i) {
int a, l, r, k;
scanf("%d%d%d%d", &a, &l, &r, &k);
convert(i, &a, &l, &r, &k);
p[a] = i;
std::set<R>::iterator it;
it = ::r.lower_bound({a});
if (it->m == a) fix(it, i);
for (int j = a, k = i; it->m == j; ++j) {
k = std::min(k, p[j]);
if (k >= it->t)
k = it->t, it = ::r.erase(it);
else
++it;
if (k <= it->t) break;
if (it->m == j + 1)
fix(it, i), it->t = k;
else
fix(j + 1, i), it = ::r.insert(R{j + 1, k}).first;
}
if (a)
if ((it = ::r.begin())->m)
fix(0, i), ::r.insert(R{0, i});
else
fix(it, i), ++it->t;
else if ((it = ::r.begin())->m == 1)
fix(it, i, 1), ++it->t;
else if (it->m > 1)
fix(1, i, 1), ::r.insert(R{1, i});
P = 0LL;
int u, v;
u = lb(k, l);
v = lb(k, r + 1) - 1;
assert(v + 1 >= u);
if (u > v) return printf("%lld\n", P = getper(k, u, l, r) * (u - v)), void();
if (u < v)
P = qry(m[k][v].n, 0, N, l - 1, r) - qry(m[k][u].n, 0, N, l - 1, r);
if (l < m[k][u].t) P += getper(k, u, l, r) * (m[k][u].t - l);
P += getper(k, v + 1, l, r) * (r - m[k][v].t + 1);
printf("%lld\n", P);
}
int main(void) {
scanf("%d", &N);
for (int i = 0; i <= N; i++) m[i].assign(1, S{nullptr, 0});
r.clear();
r.insert(R{MN, 0});
for (int i = 1; i <= N; i++) ans_q(i);
return 0;
}
|
Little John aspires to become a plumber! Today he has drawn a grid consisting of n rows and m columns, consisting of n × m square cells.
In each cell he will draw a pipe segment. He can only draw four types of segments numbered from 1 to 4, illustrated as follows:
<image>
Each pipe segment has two ends, illustrated by the arrows in the picture above. For example, segment 1 has ends at top and left side of it.
Little John considers the piping system to be leaking if there is at least one pipe segment inside the grid whose end is not connected to another pipe's end or to the border of the grid. The image below shows an example of leaking and non-leaking systems of size 1 × 2.
<image>
Now, you will be given the grid that has been partially filled by Little John. Each cell will either contain one of the four segments above, or be empty. Find the number of possible different non-leaking final systems after Little John finishes filling all of the empty cells with pipe segments. Print this number modulo 1000003 (106 + 3).
Note that rotations or flipping of the grid are not allowed and so two configurations that are identical only when one of them has been rotated or flipped either horizontally or vertically are considered two different configurations.
Input
The first line will contain two single-space separated integers n and m (1 ≤ n, m, n·m ≤ 5·105) — the number of rows and columns respectively. Then n lines follow, each contains exactly m characters — the description of the grid. Each character describes a cell and is either one of these:
* "1" - "4" — a pipe segment of one of four types as described above
* "." — an empty cell
Output
Print a single integer denoting the number of possible final non-leaking pipe systems modulo 1000003 (106 + 3). If there are no such configurations, print 0.
Examples
Input
2 2
13
..
Output
2
Input
3 1
1
4
.
Output
0
Input
2 2
3.
.1
Output
1
Note
For the first example, the initial configuration of the grid is as follows.
<image>
The only two possible final non-leaking pipe configurations are as follows:
<image> <image>
For the second example, the initial grid is already leaking, so there will be no final grid that is non-leaking.
For the final example, there's only one possible non-leaking final grid as follows.
<image>
|
import java.math.BigInteger;
import java.util.Scanner;
public class Plumber
{
static final int MOD = 1000003;
static final int EMPTY = 0;
static final int UP = 1;
static final int DOWN = 2;
static final int LEFT = 4;
static final int RIGHT = 8;
static final int UL = UP|LEFT;
static final int DL = DOWN|LEFT;
static final int DR = DOWN|RIGHT;
static final int UR = UP|RIGHT;
static final int[] seg = {UL, DL, DR, UR};
int fill(int[][] grid, int n, int m, boolean[] bool)
{
int k = 0;
int[] r = new int[m];
for (int i = 0; i < n; ++i)
{
int br = 0;
for (int j = 0; j < m; ++j)
{
int t = grid[i][j];
if ((i == 0 || j == 0) && t == EMPTY)
{
int s = 2;
if (bool[i])
s--;
if (bool[n+j])
s--;
k += s;
bool[i] = true;
bool[n+j] = true;
}
if (t == EMPTY)
{
if (br != 0)
br = br == RIGHT ? LEFT : RIGHT;
if (r[j] != 0)
r[j] = r[j] == DOWN ? UP : DOWN;
continue;
}
if (r[j] == 0)
r[j] = ((t & DOWN) != 0) ? DOWN : UP;
else
{
r[j] = r[j] == DOWN ? UP : DOWN;
if ((t & DOWN) != 0 ? r[j] == UP : r[j] == DOWN)
return -1;
}
if (br == 0)
br = ((t & RIGHT) != 0) ? RIGHT : LEFT;
else
{
br = br == RIGHT ? LEFT : RIGHT;
if (((t & RIGHT) != 0) ? br == LEFT : br == RIGHT)
return -1;
}
}
}
return k;
}
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
sc.nextLine();
int[][] grid = new int[n][m];
boolean[] bool = new boolean[n+m];
for (int i = 0; i < n; ++i)
{
String str = sc.nextLine();
for (int j = 0; j < m; ++j)
{
char ch = str.charAt(j);
if (ch == '.')
{
grid[i][j] = EMPTY;
}
else
{
grid[i][j] = seg[ch-'1'];
bool[i] = true;
bool[n+j] = true;
}
}
}
int k = new Plumber().fill(grid, n, m, bool);
if (k == -1)
{
System.out.println(0);
}
else
{
BigInteger bi = BigInteger.ONE.shiftLeft(k).mod(BigInteger.valueOf(MOD));
System.out.println(bi.toString());
}
}
}
|
You are given n numbers a_1, a_2, ..., a_n. In one operation we can add to any one of those numbers a nonnegative integer power of 2.
What is the smallest number of operations we need to perform to make all n numbers equal? It can be proved that under given constraints it doesn't exceed 10^{18}.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5).
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^{17}).
Output
Output exactly one integer — the smallest number of operations we need to perform to make all n numbers equal.
Examples
Input
4
228 228 228 228
Output
0
Input
3
2 2 8
Output
3
Note
In the first example, all numbers are already equal. So the needed number of operation is 0.
In the second example, we can apply the operation 3 times: add 8 to first 2, add 8 to second 2, add 2 to 8, making all numbers equal to 10. It can be proved that we can't make all numbers equal in less than 3 operations.
|
#include <bits/stdc++.h>
using namespace std;
long long a[100010], M;
int f[70][100010], n, p1[100010], p[100010], as = 1e9 + 1, m;
bool Cmp(int x, int y) { return (a[x] % M > a[y] % M); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
memset(f, 31, sizeof(f));
int nm = 0;
for (int i = 1; i <= n; i++)
if (!(a[i] & 1)) nm++;
f[0][0] = nm, f[0][n - nm] = n - nm;
for (int i = 1; i <= 60; i++) {
for (int j = 1; j <= n; j++) p[j] = j;
M = 1ll << i;
sort(p + 1, p + 1 + n, Cmp);
for (int j = 1; j <= n; j++) p1[j] = p[j];
int nm1 = 0, nm0 = 0, ck = 1;
for (int j = 1; j <= n; j++) {
if ((a[j] >> i) & 1) nm1++;
if (a[j] >= (1ll << i + 1)) ck = 0;
}
nm0 = n - nm1;
for (int w1 = 0, w0 = nm1, j = 0; j <= n; j++) {
if (j) {
int jj = p1[j];
if ((a[jj] >> i) & 1)
w1++, nm1--, nm0++;
else
nm0--, w0++, nm1++;
}
if (f[i][w1] > f[i - 1][j] + nm0) {
f[i][w1] = f[i - 1][j] + nm0;
}
if (f[i][w0] > f[i - 1][j] + nm1) {
f[i][w0] = f[i - 1][j] + nm1;
}
}
if (ck && as > f[i][0]) as = f[i][0];
}
printf("%d\n", as);
}
|
You are given an array a consisting of 500000 integers (numbered from 1 to 500000). Initially all elements of a are zero.
You have to process two types of queries to this array:
* 1 x y — increase a_x by y;
* 2 x y — compute ∑_{i ∈ R(x, y)} a_i, where R(x, y) is the set of all integers from 1 to 500000 which have remainder y modulo x.
Can you process all the queries?
Input
The first line contains one integer q (1 ≤ q ≤ 500000) — the number of queries.
Then q lines follow, each describing a query. The i-th line contains three integers t_i, x_i and y_i (1 ≤ t_i ≤ 2). If t_i = 1, then it is a query of the first type, 1 ≤ x_i ≤ 500000, and -1000 ≤ y_i ≤ 1000. If t_i = 2, then it it a query of the second type, 1 ≤ x_i ≤ 500000, and 0 ≤ y_i < x_i.
It is guaranteed that there will be at least one query of type 2.
Output
For each query of type 2 print one integer — the answer to it.
Example
Input
5
1 3 4
2 3 0
2 4 3
1 4 -4
2 1 0
Output
4
4
0
|
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
public class P1207F {
public static void main(String[] args) {
FastScanner in = new FastScanner(System.in);
PrintWriter out = new PrintWriter(System.out);
int n = 500000;
int sqrt = (int) Math.sqrt(n);
int[][] sum = new int[sqrt + 1][sqrt + 1];
int[] arr = new int[500000 + 1];
int q = in.nextInt();
while (q-->0) {
int t = in.nextInt();
int x = in.nextInt();
int y = in.nextInt();
if (t == 1) {
for (int i = 1; i <= sqrt; i++)
sum[i][x % i] += y;
arr[x] += y;
}
else {
if (x <= sqrt)
out.println(sum[x][y]);
else {
int ans = 0;
for (int k = y; k <= n; k += x)
ans += arr[k];
out.println(ans);
}
}
}
out.close();
}
/**
* Source: Matt Fontaine
*/
public static class FastScanner {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
public FastScanner(InputStream stream) {
this.stream = stream;
}
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;
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public 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();
}
public 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();
}
}
}
|
Bytelandian Tree Factory produces trees for all kinds of industrial applications. You have been tasked with optimizing the production of a certain type of tree for an especially large and important order.
The tree in question is a rooted tree with n vertices labelled with distinct integers from 0 to n - 1. The vertex labelled 0 is the root of the tree, and for any non-root vertex v the label of its parent p(v) is less than the label of v.
All trees at the factory are made from bamboo blanks. A bamboo is a rooted tree such that each vertex has exactly one child, except for a single leaf vertex with no children. The vertices of a bamboo blank can be labelled arbitrarily before its processing is started.
To process a bamboo into another tree a single type of operation can be made: choose an arbitrary non-root vertex v such that its parent p(v) is not a root either. The operation consists of changing the parent of v to its parent's parent p(p(v)). Note that parents of all other vertices remain unchanged, in particular, the subtree of v does not change.
Efficiency is crucial, hence you have to minimize the number of operations to make the desired tree from a bamboo blank. Construct any optimal sequence of operations to produce the desired tree.
Note that the labelling of the resulting tree has to coincide with the labelling of the desired tree. Formally, the labels of the roots have to be equal, and for non-root vertices with the same label the labels of their parents should be the same.
It is guaranteed that for any test present in this problem an answer exists, and further, an optimal sequence contains at most 10^6 operations. Note that any hack that does not meet these conditions will be invalid.
Input
The first line contains a single integer n — the number of vertices in the tree (2 ≤ n ≤ 10^5).
The second line contains n - 1 integers p(1), …, p(n - 1) — indices of parent vertices of 1, …, n - 1 respectively (0 ≤ p(i) < i).
Output
In the first line, print n distinct integers id_1, …, id_n — the initial labelling of the bamboo blank starting from the root vertex (0 ≤ id_i < n).
In the second line, print a single integer k — the number of operations in your sequence (0 ≤ k ≤ 10^6).
In the third line print k integers v_1, …, v_k describing operations in order. The i-th operation consists of changing p(v_i) to p(p(v_i)). Each operation should be valid, i.e. neither v_i nor p(v_i) can be the root of the tree at the moment.
Examples
Input
5
0 0 1 1
Output
0 2 1 4 3
2
1 3
Input
4
0 1 2
Output
0 1 2 3
0
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 50;
int fa[MAXN], p[MAXN], high[MAXN], a[MAXN], n, cnt = 0;
vector<int> e[MAXN], ans;
inline int read() {
int res = 0;
char ch;
ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) {
res = (res << 3) + (res << 1) + ch - 48;
ch = getchar();
}
return res;
}
inline bool cmp(int i, int j) { return high[i] < high[j]; }
void dfs1(int u) {
if (!e[u].size()) {
high[u] = 1;
return;
}
for (int i = 0; i < e[u].size(); i++) dfs1(e[u][i]);
int maxx = 0;
for (int i = 0; i < e[u].size(); i++) maxx = max(maxx, high[e[u][i]]);
high[u] = maxx + 1;
return;
}
void dfs2(int u) {
a[++cnt] = u;
sort(e[u].begin(), e[u].end(), cmp);
for (int i = 0; i < e[u].size(); i++) dfs2(e[u][i]);
return;
}
int main() {
n = read();
for (int i = 1; i < n; i++) {
int t;
t = read();
e[t].push_back(i);
fa[i] = t;
}
dfs1(0);
dfs2(0);
for (int i = 1; i <= n; i++) printf("%d%c", a[i], i == n ? '\n' : ' ');
for (int i = 2; i <= n; i++) p[a[i]] = a[i - 1];
for (int i = 2; i <= n; i++) {
int u = a[i];
while (p[u] != fa[u]) {
ans.push_back(u);
p[u] = p[p[u]];
}
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
|
You are given n k-digit integers. You have to rearrange the digits in the integers so that the difference between the largest and the smallest number was minimum. Digits should be rearranged by the same rule in all integers.
Input
The first line contains integers n and k — the number and digit capacity of numbers correspondingly (1 ≤ n, k ≤ 8). Next n lines contain k-digit positive integers. Leading zeroes are allowed both in the initial integers and the integers resulting from the rearranging of digits.
Output
Print a single number: the minimally possible difference between the largest and the smallest number after the digits are rearranged in all integers by the same rule.
Examples
Input
6 4
5237
2753
7523
5723
5327
2537
Output
2700
Input
3 3
010
909
012
Output
3
Input
7 5
50808
36603
37198
44911
29994
42543
50156
Output
20522
Note
In the first sample, if we rearrange the digits in numbers as (3,1,4,2), then the 2-nd and the 4-th numbers will equal 5237 and 2537 correspondingly (they will be maximum and minimum for such order of digits).
In the second sample, if we swap the second digits and the first ones, we get integers 100, 99 and 102.
|
#include <bits/stdc++.h>
using namespace std;
char arr[10][10];
char my[10][10];
int n, k;
int ans = 1000000000;
int getLen() {
int mi = 1000000000, ma = 0;
for (int i = 0; i < n; i++) {
int num = 0;
int st = 1;
for (int j = k - 1; j >= 0; --j) {
num += st * arr[i][j];
st *= 10;
}
if (num < mi) mi = num;
if (num > ma) ma = num;
}
return (ma - mi);
}
int per[10];
void go(int idx = 0) {
if (idx == k) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
arr[i][j] = my[i][per[j]];
}
}
int le = getLen();
if (le < ans) ans = le;
}
for (int i = 0; i < k; i++) {
bool fo = 0;
for (int j = 0; j < idx; j++) {
if (per[j] == i) {
fo = 1;
break;
}
}
if (!fo) {
per[idx] = i;
go(idx + 1);
}
}
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
for (int j = 0; j < k; j++) {
arr[i][j] -= '0';
my[i][j] = arr[i][j];
}
}
go(0);
cout << ans << endl;
return 0;
}
|
You are given a cactus graph, in this graph each edge lies on at most one simple cycle.
It is given as m edges a_i, b_i, weight of i-th edge is i.
Let's call a path in cactus increasing if the weights of edges on this path are increasing.
Let's call a pair of vertices (u,v) happy if there exists an increasing path that starts in u and ends in v.
For each vertex u find the number of other vertices v, such that pair (u,v) is happy.
Input
The first line of input contains two integers n,m (1 ≤ n, m ≤ 500 000): the number of vertices and edges in the given cactus.
The next m lines contain a description of cactus edges, i-th of them contain two integers a_i, b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i).
It is guaranteed that there are no multiple edges and the graph is connected.
Output
Print n integers, required values for vertices 1,2,…,n.
Examples
Input
3 3
1 2
2 3
3 1
Output
2 2 2
Input
5 4
1 2
2 3
3 4
4 5
Output
4 4 3 2 1
|
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
char ch = getchar();
x = 0;
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - 48, ch = getchar();
}
const int N = 5e5 + 5, M = N << 1;
int n, m, num, dfn[N], fa[N], up[N], dp[N], f[N];
int cnt, c, mx[N], mn[N], q[M], in[N], k[N];
struct edge {
int x, y;
} e[N];
vector<edge> g[N];
void yxlove() {
int x = 0, y = 0;
mx[++cnt] = 0, mn[cnt] = 1e9;
for (int i = 1, o; i <= c; ++i) {
in[o = q[i]] = cnt;
if (o > mx[cnt]) mx[cnt] = o, y = i;
if (o < mn[cnt]) mn[cnt] = o, x = i;
}
for (int i = 1; i <= c; ++i) q[c + i] = q[i];
int tx = x, ty = y;
if (tx > ty) ty += c;
k[cnt] = 1;
for (int i = tx; i < ty; ++i)
if (q[i] > q[i + 1]) k[cnt] = 0;
tx = x, ty = y;
if (tx < ty) tx += c;
for (int i = tx; i > ty; --i)
if (q[i] > q[i - 1]) k[cnt] = 0;
}
void dfs(int u) {
dfn[u] = ++num;
dp[u] = 1;
for (edge i : g[u])
if (i.x != fa[u]) {
int v = i.x, w = i.y;
if (!dfn[v])
fa[v] = u, up[v] = w, dfs(v);
else if (dfn[v] < 0) {
c = 0;
for (int t = v; t != u; t = fa[t]) q[++c] = up[t];
q[++c] = w;
yxlove();
}
}
dfn[u] = -1;
}
signed main() {
read(n), read(m);
for (int i = 1, u, v; i <= m; ++i) {
read(u), read(v);
e[i] = {u, v};
g[u].push_back({v, i}), g[v].push_back({u, i});
}
dfs(1);
for (int i = m, x, y; i >= 1; --i) {
f[i] = dp[x = e[i].x] + dp[y = e[i].y];
if (k[in[i]] && i == mn[in[i]]) f[i] -= f[mx[in[i]]];
dp[x] = dp[y] = f[i];
}
for (int i = 1; i <= n; ++i) printf("%d ", dp[i] - 1);
return 0;
}
|
You are given n pairwise non-collinear two-dimensional vectors. You can make shapes in the two-dimensional plane with these vectors in the following fashion:
1. Start at the origin (0, 0).
2. Choose a vector and add the segment of the vector to the current point. For example, if your current point is at (x, y) and you choose the vector (u, v), draw a segment from your current point to the point at (x + u, y + v) and set your current point to (x + u, y + v).
3. Repeat step 2 until you reach the origin again.
You can reuse a vector as many times as you want.
Count the number of different, non-degenerate (with an area greater than 0) and convex shapes made from applying the steps, such that the shape can be contained within a m × m square, and the vectors building the shape are in counter-clockwise fashion. Since this number can be too large, you should calculate it by modulo 998244353.
Two shapes are considered the same if there exists some parallel translation of the first shape to another.
A shape can be contained within a m × m square if there exists some parallel translation of this shape so that every point (u, v) inside or on the border of the shape satisfies 0 ≤ u, v ≤ m.
Input
The first line contains two integers n and m — the number of vectors and the size of the square (1 ≤ n ≤ 5, 1 ≤ m ≤ 10^9).
Each of the next n lines contains two integers x_i and y_i — the x-coordinate and y-coordinate of the i-th vector (|x_i|, |y_i| ≤ 4, (x_i, y_i) ≠ (0, 0)).
It is guaranteed, that no two vectors are parallel, so for any two indices i and j such that 1 ≤ i < j ≤ n, there is no real value k such that x_i ⋅ k = x_j and y_i ⋅ k = y_j.
Output
Output a single integer — the number of satisfiable shapes by modulo 998244353.
Examples
Input
3 3
-1 0
1 1
0 -1
Output
3
Input
3 3
-1 0
2 2
0 -1
Output
1
Input
3 1776966
-1 0
3 3
0 -2
Output
296161
Input
4 15
-4 -4
-1 1
-1 -4
4 3
Output
1
Input
5 10
3 -4
4 -3
1 -3
2 -3
-3 -4
Output
0
Input
5 1000000000
-2 4
2 -3
0 -4
2 4
-1 -3
Output
9248783
Note
The shapes for the first sample are:
<image>
The only shape for the second sample is:
<image>
The only shape for the fourth sample is:
<image>
|
#include <bits/stdc++.h>
using namespace std;
constexpr int mod = 998244353;
int x[5], y[5];
int px[32], nx[32], py[32], ny[32];
int dp[32][20][20][20][20][2][2];
void add(int& x, const int& y) {
x += y;
if (x >= mod) x -= mod;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i += 1) cin >> x[i] >> y[i];
for (int mask = 0; mask < (1 << n); mask += 1)
for (int i = 0; i < n; i += 1)
if ((mask >> i) & 1) {
(x[i] > 0 ? px : nx)[mask] += abs(x[i]);
(y[i] > 0 ? py : ny)[mask] += abs(y[i]);
}
dp[0][0][0][0][0][0][0] = 1;
for (int i = 0; i < (30); i += 1)
for (int cpx = 0; cpx < (20); cpx += 1)
for (int cnx = 0; cnx < (20); cnx += 1)
for (int cpy = 0; cpy < (20); cpy += 1)
for (int cny = 0; cny < (20); cny += 1)
for (int bx = 0; bx < (2); bx += 1)
for (int by = 0; by < (2); by += 1)
for (int mask = 0; mask < (1 << n); mask += 1)
if (dp[i][cpx][cnx][cpy][cny][bx][by]) {
if (0)
cout << i << " " << cpx << " " << cny << " " << cpy << " "
<< cny << " " << bx << " " << by << " "
<< dp[i][cpx][cnx][cpy][cny][bx][by] << endl;
int npx = cpx + px[mask], nnx = cnx + nx[mask],
npy = cpy + py[mask], nny = cny + ny[mask];
if ((npx ^ nnx) & 1) continue;
if ((npy ^ nny) & 1) continue;
int cx = npx & 1, mx = (m >> i) & 1;
int cy = npy & 1, my = (m >> i) & 1;
add(dp[i + 1][npx >> 1][nnx >> 1][npy >> 1][nny >> 1]
[cx != mx ? (cx > mx) : bx]
[cy != my ? (cy > my) : by],
dp[i][cpx][cnx][cpy][cny][bx][by]);
}
cout << (dp[30][0][0][0][0][0][0] + mod - 1) % mod;
return 0;
}
|
You are given two positive integers a and b.
In one move, you can change a in the following way:
* Choose any positive odd integer x (x > 0) and replace a with a+x;
* choose any positive even integer y (y > 0) and replace a with a-y.
You can perform as many such operations as you want. You can choose the same numbers x and y in different moves.
Your task is to find the minimum number of moves required to obtain b from a. It is guaranteed that you can always obtain b from a.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t test cases follow. Each test case is given as two space-separated integers a and b (1 ≤ a, b ≤ 10^9).
Output
For each test case, print the answer — the minimum number of moves required to obtain b from a if you can perform any number of moves described in the problem statement. It is guaranteed that you can always obtain b from a.
Example
Input
5
2 3
10 10
2 4
7 4
9 3
Output
1
0
2
2
1
Note
In the first test case, you can just add 1.
In the second test case, you don't need to do anything.
In the third test case, you can add 1 two times.
In the fourth test case, you can subtract 4 and add 1.
In the fifth test case, you can just subtract 6.
|
for i in range(int(input())):
a,b=map(int,input().split())
if a==b:
print(0)
elif a<b:
if (b-a)%2==0:
print(2)
else:
print(1)
elif a>b:
if (a-b)%2==0:
print(1)
else:
print(2)
|
Egor wants to achieve a rating of 1600 points on the well-known chess portal ChessForces and he needs your help!
Before you start solving the problem, Egor wants to remind you how the chess pieces move. Chess rook moves along straight lines up and down, left and right, as many squares as it wants. And when it wants, it can stop. The queen walks in all directions vertically and diagonally at any distance. You can see the examples below.
<image>
To reach the goal, Egor should research the next topic:
There is an N × N board. Each cell of the board has a number from 1 to N ^ 2 in it and numbers in all cells are distinct.
In the beginning, some chess figure stands in the cell with the number 1. Note that this cell is already considered as visited. After that every move is determined by the following rules:
1. Among all not visited yet cells to which the figure can get in one move, it goes to the cell that has minimal number.
2. If all accessible cells were already visited and some cells are not yet visited, then the figure is teleported to the not visited cell that has minimal number. If this step happens, the piece pays a fee of 1 vun.
3. If all cells are already visited, the process is stopped.
Egor should find an N × N board on which the rook pays strictly less vuns than the queen during the round with this numbering. Help him to find such N × N numbered board, or tell that it doesn't exist.
Input
The only line contains one integer N — the size of the board, 1≤ N ≤ 500.
Output
The output should contain N lines.
In i-th line output N numbers — numbers on the i-th row of the board. All numbers from 1 to N × N must be used exactly once.
On your board rook must pay strictly less vuns than the queen.
If there are no solutions, print -1.
If there are several solutions, you can output any of them.
Examples
Input
1
Output
-1
Input
4
Output
4 3 6 12
7 5 9 15
14 1 11 10
13 8 16 2
Note
In case we have 1 × 1 board, both rook and queen do not have a chance to pay fees.
In second sample rook goes through cells 1 → 3 → 4 → 6 → 9 → 5 → 7 → 13 → 2 → 8 → 16 → 11 → 10 → 12 → 15 → (1 vun) → 14.
Queen goes through 1 → 3 → 4 → 2 → 5 → 6 → 9 → 7 → 13 → 8 → 11 → 10 → 12 → 15 → (1 vun) → 14 → (1 vun) → 16.
As a result rook pays 1 vun and queen pays 2 vuns.
|
#include <bits/stdc++.h>
using namespace std;
int a[512][512];
void solve() {
int n;
cin >> n;
if (n < 3) {
cout << -1;
return;
}
int x = 1;
for (int j = n - 1; j >= 2; j--) {
a[2][j] = x++;
}
for (int i = 3; i <= n; i++) {
a[i][2] = x++;
}
for (int j = 1; j <= n; j++)
if (j != 2) {
for (int i = 3; i <= n; i++) {
a[i][j] = x++;
}
}
a[2][n] = x++;
for (int j = n - 1; j >= 1; j--) {
a[1][j] = x++;
}
a[2][1] = x++;
a[1][n] = x++;
assert(x - 1 == n * n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cout << a[i][j] << ' ';
}
cout << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
|
You are given a string s such that each its character is either 1, 2, or 3. You have to choose the shortest contiguous substring of s such that it contains each of these three characters at least once.
A contiguous substring of string s is a string that can be obtained from s by removing some (possibly zero) characters from the beginning of s and some (possibly zero) characters from the end of s.
Input
The first line contains one integer t (1 ≤ t ≤ 20000) — the number of test cases.
Each test case consists of one line containing the string s (1 ≤ |s| ≤ 200000). It is guaranteed that each character of s is either 1, 2, or 3.
The sum of lengths of all strings in all test cases does not exceed 200000.
Output
For each test case, print one integer — the length of the shortest contiguous substring of s containing all three types of characters at least once. If there is no such substring, print 0 instead.
Example
Input
7
123
12222133333332
112233
332211
12121212
333333
31121
Output
3
3
4
4
0
0
4
Note
Consider the example test:
In the first test case, the substring 123 can be used.
In the second test case, the substring 213 can be used.
In the third test case, the substring 1223 can be used.
In the fourth test case, the substring 3221 can be used.
In the fifth test case, there is no character 3 in s.
In the sixth test case, there is no character 1 in s.
In the seventh test case, the substring 3112 can be used.
|
import math
from sys import stdin,stdout
def L():
return list(map(int,stdin.readline().split())) #For array input
def Si():
return sorted(list(map(int,stdin.readline().split()))) #For sorted array
def In():
return map(int,stdin.readline().split()) #For multiple input
def I():
return stdin.readline() #For single input
def main():
for i in range(int(I())):
s=str(I())
n1=-1
n2=-1
n3=-1
m=len(s)
for i in range(m):
if(s[i]=="1"):
n1=i
elif(s[i]=="2"):
n2=i
elif(s[i]=="3"):
n3=i
if(n1!=-1 and n2!=-1 and n3!=-1 ):
m=min( m, ( max(n1,n2,n3)-min(n1,n2,n3)+1) )
print(m if (n1!=-1 and n2!=-1 and n3!=-1) else 0)
if __name__ == "__main__" :
main()
|
You are given a chessboard consisting of n rows and n columns. Rows are numbered from bottom to top from 1 to n. Columns are numbered from left to right from 1 to n. The cell at the intersection of the x-th column and the y-th row is denoted as (x, y). Furthermore, the k-th column is a special column.
Initially, the board is empty. There are m changes to the board. During the i-th change one pawn is added or removed from the board. The current board is good if we can move all pawns to the special column by the followings rules:
* Pawn in the cell (x, y) can be moved to the cell (x, y + 1), (x - 1, y + 1) or (x + 1, y + 1);
* You can make as many such moves as you like;
* Pawns can not be moved outside the chessboard;
* Each cell can not contain more than one pawn.
The current board may not always be good. To fix it, you can add new rows to the board. New rows are added at the top, i. e. they will have numbers n+1, n+2, n+3, ....
After each of m changes, print one integer — the minimum number of rows which you have to add to make the board good.
Input
The first line contains three integers n, k and m (1 ≤ n, m ≤ 2 ⋅ 10^5; 1 ≤ k ≤ n) — the size of the board, the index of the special column and the number of changes respectively.
Then m lines follow. The i-th line contains two integers x and y (1 ≤ x, y ≤ n) — the index of the column and the index of the row respectively. If there is no pawn in the cell (x, y), then you add a pawn to this cell, otherwise — you remove the pawn from this cell.
Output
After each change print one integer — the minimum number of rows which you have to add to make the board good.
Example
Input
5 3 5
4 4
3 5
2 4
3 4
3 5
Output
0
1
2
2
1
|
#include <bits/stdc++.h>
using namespace std;
int read() {
char c = getchar();
while (!isdigit(c)) c = getchar();
int num = 0;
while (isdigit(c)) num = num * 10 + c - '0', c = getchar();
return num;
}
struct node {
int tag, maxn, cnt = 0;
} nd[1600001];
void pushdown(int p) {
nd[p * 2].tag += nd[p].tag, nd[p * 2 + 1].tag += nd[p].tag;
nd[p * 2].maxn += nd[p].tag, nd[p * 2 + 1].maxn += nd[p].tag;
nd[p].tag = 0;
}
void add(int p, int l, int r, int l0, int r0, int x) {
if (l >= l0 && r <= r0) {
nd[p].tag += x, nd[p].maxn += x;
return;
}
pushdown(p);
int mid = (l + r) / 2;
if (l0 <= mid) add(p * 2, l, mid, l0, r0, x);
if (r0 > mid) add(p * 2 + 1, mid + 1, r, l0, r0, x);
nd[p].maxn = max(nd[p * 2].maxn, nd[p * 2 + 1].maxn);
}
void modify(int p, int l, int r, int x, int num) {
if (l == r) {
nd[p].maxn = num + l;
return;
}
pushdown(p);
int mid = (l + r) / 2;
if (x <= mid)
modify(p * 2, l, mid, x, num);
else
modify(p * 2 + 1, mid + 1, r, x, num);
nd[p].maxn = max(nd[p * 2].maxn, nd[p * 2 + 1].maxn);
nd[p].cnt = nd[p * 2].cnt + nd[p * 2 + 1].cnt;
}
void addcnt(int p, int l, int r, int x, int num) {
if (l == r) {
nd[p].cnt += num;
return;
}
pushdown(p);
int mid = (l + r) / 2;
if (x <= mid)
addcnt(p * 2, l, mid, x, num);
else
addcnt(p * 2 + 1, mid + 1, r, x, num);
nd[p].cnt = nd[p * 2].cnt + nd[p * 2 + 1].cnt;
}
int query(int p, int l, int r, int l0, int r0) {
if (l >= l0 && r <= r0) return nd[p].cnt;
int mid = (l + r) / 2, ans = 0;
if (l0 <= mid) ans += query(p * 2, l, mid, l0, r0);
if (r0 > mid) ans += query(p * 2 + 1, mid + 1, r, l0, r0);
return ans;
}
set<pair<int, int> > vis;
int v[400001];
int main() {
int n, k, m;
n = read(), k = read(), m = read();
add(1, 1, n * 2, 1, n * 2, -0x3f3f3f3f);
for (int i = 1; i <= m; i++) {
int x, y;
x = read(), y = read();
int p = y + abs(k - x);
if (vis.find(make_pair(x, y)) != vis.end()) {
vis.erase(make_pair(x, y));
add(1, 1, n * 2, 1, p, -1);
--v[p];
addcnt(1, 1, n * 2, p, -1);
if (!v[p]) modify(1, 1, n * 2, p, -0x3f3f3f3f);
} else {
vis.insert(make_pair(x, y));
++v[p];
if (v[p] == 1) modify(1, 1, n * 2, p, query(1, 1, n * 2, p, n * 2) - 1);
addcnt(1, 1, n * 2, p, 1);
add(1, 1, n * 2, 1, p, 1);
}
cout << max(0, nd[1].maxn - n) << endl;
}
}
|
You are given n strings s_1, s_2, …, s_n consisting of lowercase Latin letters.
In one operation you can remove a character from a string s_i and insert it to an arbitrary position in a string s_j (j may be equal to i). You may perform this operation any number of times. Is it possible to make all n strings equal?
Input
The first line contains t (1 ≤ t ≤ 10): the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 1000): the number of strings.
n lines follow, the i-th line contains s_i (1 ≤ \lvert s_i \rvert ≤ 1000).
The sum of lengths of all strings in all test cases does not exceed 1000.
Output
If it is possible to make the strings equal, print "YES" (without quotes).
Otherwise, print "NO" (without quotes).
You can output each character in either lowercase or uppercase.
Example
Input
4
2
caa
cbb
3
cba
cba
cbb
4
ccab
cbac
bca
acbcc
4
acb
caf
c
cbafc
Output
YES
NO
YES
NO
Note
In the first test case, you can do the following:
* Remove the third character of the first string and insert it after the second character of the second string, making the two strings "ca" and "cbab" respectively.
* Remove the second character of the second string and insert it after the second character of the first string, making both strings equal to "cab".
In the second test case, it is impossible to make all n strings equal.
|
for _ in range(int(input())):
#n,k=map(int,input().split())
ll=[0]*26
n=int(input())
bool=True
for _ in range(n):
s=input()
pp=set(s)
for c in pp:
cc=s.count(c)
ll[ord(c)-97]+=cc
# print(ll)
for x in ll:
if x%n!=0 :
bool=False
if bool == True :
print('YES')
else:
print('NO')
|
This is the easy version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokémon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokémon! Pokémon trainer Andrew decided to help Pikachu to build a pokémon army to resist.
First, Andrew counted all the pokémon — there were exactly n pikachu. The strength of the i-th pokémon is equal to a_i, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array b from k indices such that 1 ≤ b_1 < b_2 < ... < b_k ≤ n, and his army will consist of pokémons with forces a_{b_1}, a_{b_2}, ..., a_{b_k}.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + ....
Andrew is experimenting with pokémon order. He performs q operations. In i-th operation Andrew swaps l_i-th and r_i-th pokémon.
Note: q=0 in this version of the task.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokémon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokémon, or team R will realize their tricky plan!
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10^3) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers n and q (1 ≤ n ≤ 3 ⋅ 10^5, q = 0) denoting the number of pokémon and number of operations respectively.
The second line contains n distinct positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) denoting the strengths of the pokémon.
i-th of the last q lines contains two positive integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) denoting the indices of pokémon that were swapped in the i-th operation.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, print q+1 integers: the maximal strength of army before the swaps and after each swap.
Example
Input
3
3 0
1 3 2
2 0
1 2
7 0
1 2 5 4 3 6 7
Output
3
2
9
Note
In third test case we can build an army in such way: [1 2 5 4 3 6 7], its strength will be 5−3+7=9.
|
import java.util.*;
import java.io.*;
public class EdB {
public static void main(String[] args) throws Exception{
int num = 998244353;
// TODO Auto-generated method stub
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
int t = Integer.parseInt(bf.readLine());
for(int i = 0;i<t;i++){
// String input1 = bf.readLine().trim();
// String input2 = bf.readLine().trim();
StringTokenizer st = new StringTokenizer(bf.readLine());
int n = Integer.parseInt(st.nextToken());
int m = Integer.parseInt(st.nextToken());
ArrayList<Long> array = new ArrayList<Long>();
StringTokenizer st2 = new StringTokenizer(bf.readLine());
for(int j=0;j<n;j++){
array.add(Long.parseLong(st2.nextToken()));
}
long sum = 0;
int j = 0;
while(j < n){
while(j < n-1 && array.get(j) <= array.get(j+1))
j++;
sum+=array.get(j);
while(j < n-1 && array.get(j) >= array.get(j+1))
j++;
if (j == n-1)
break;
sum-=array.get(j);
}
out.println(sum);
}
out.println();
out.close();
}
}
//StringJoiner sj = new StringJoiner(" ");
//sj.add(strings)
//sj.toString() gives string of those stuff w spaces or whatever that sequence is
|
This is the hard version of the problem. The difference between the versions is in the number of possible operations that can be made. You can make hacks if and only if you solved both versions of the problem.
You are given a binary table of size n × m. This table consists of symbols 0 and 1.
You can make such operation: select 3 different cells that belong to one 2 × 2 square and change the symbols in these cells (change 0 to 1 and 1 to 0).
Your task is to make all symbols in the table equal to 0. You are allowed to make at most nm operations. You don't need to minimize the number of operations.
It can be proved, that it is always possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 5000) — the number of test cases. The next lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, m (2 ≤ n, m ≤ 100).
Each of the next n lines contains a binary string of length m, describing the symbols of the next row of the table.
It is guaranteed, that the sum of nm for all test cases does not exceed 20000.
Output
For each test case print the integer k (0 ≤ k ≤ nm) — the number of operations.
In the each of the next k lines print 6 integers x_1, y_1, x_2, y_2, x_3, y_3 (1 ≤ x_1, x_2, x_3 ≤ n, 1 ≤ y_1, y_2, y_3 ≤ m) describing the next operation. This operation will be made with three cells (x_1, y_1), (x_2, y_2), (x_3, y_3). These three cells should be different. These three cells should belong to some 2 × 2 square.
Example
Input
5
2 2
10
11
3 3
011
101
110
4 4
1111
0110
0110
1111
5 5
01011
11001
00010
11011
10000
2 3
011
101
Output
1
1 1 2 1 2 2
2
2 1 3 1 3 2
1 2 1 3 2 3
4
1 1 1 2 2 2
1 3 1 4 2 3
3 2 4 1 4 2
3 3 4 3 4 4
4
1 2 2 1 2 2
1 4 1 5 2 5
4 1 4 2 5 1
4 4 4 5 3 4
2
1 3 2 2 2 3
1 2 2 1 2 2
Note
In the first test case, it is possible to make only one operation with cells (1, 1), (2, 1), (2, 2). After that, all symbols will be equal to 0.
In the second test case:
* operation with cells (2, 1), (3, 1), (3, 2). After it the table will be:
011
001
000
* operation with cells (1, 2), (1, 3), (2, 3). After it the table will be:
000
000
000
In the fifth test case:
* operation with cells (1, 3), (2, 2), (2, 3). After it the table will be:
010
110
* operation with cells (1, 2), (2, 1), (2, 2). After it the table will be:
000
000
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
int n, m, a[103][103];
char s[103][103];
vector<int> ans;
int main() {
int t;
cin >> t;
while (t--) {
ans.clear();
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < m; j++) {
a[i][j] = 0;
if (s[i][j] == '1') a[i][j] = 1;
}
}
for (int i = 0; i < n - 2; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == 1) {
if (j != m - 1) {
a[i][j] ^= 1, a[i + 1][j] ^= 1, a[i + 1][j + 1] ^= 1;
ans.push_back(i), ans.push_back(j);
ans.push_back(i + 1), ans.push_back(j);
ans.push_back(i + 1), ans.push_back(j + 1);
} else {
a[i][j] ^= 1, a[i + 1][j] ^= 1, a[i + 1][j - 1] ^= 1;
ans.push_back(i), ans.push_back(j);
ans.push_back(i + 1), ans.push_back(j);
ans.push_back(i + 1), ans.push_back(j - 1);
}
}
}
}
for (int i = 0; i < m - 2; i++) {
for (int j = n - 2; j < n; j++) {
if (a[j][i] == 1) {
if (j != n - 1) {
a[j][i] ^= 1, a[j][i + 1] ^= 1, a[j + 1][i + 1] ^= 1;
ans.push_back(j), ans.push_back(i);
ans.push_back(j), ans.push_back(i + 1);
ans.push_back(j + 1), ans.push_back(i + 1);
} else {
a[j][i] ^= 1, a[j][i + 1] ^= 1, a[j - 1][i + 1] ^= 1;
ans.push_back(j), ans.push_back(i);
ans.push_back(j), ans.push_back(i + 1);
ans.push_back(j - 1), ans.push_back(i + 1);
}
}
}
}
vector<pair<int, int> > on, ze;
for (int i = n - 1; i >= n - 2; i--) {
for (int j = m - 1; j >= m - 2; j--) {
if (a[i][j] == 1) on.push_back({i, j});
if (a[i][j] == 0) ze.push_back({i, j});
}
}
while (on.size()) {
if (on.size() == 1) {
for (int z = 0; z < 1; z++) {
ans.push_back(on[z].first);
ans.push_back(on[z].second);
ze.insert(ze.begin(), on[z]);
on.erase(on.begin());
}
for (int z = 3; z >= 2; z--) {
ans.push_back(ze[z].first);
ans.push_back(ze[z].second);
on.push_back(ze[z]);
ze.pop_back();
}
}
if (on.size() == 2) {
for (int z = 0; z < 1; z++) {
ans.push_back(on[z].first);
ans.push_back(on[z].second);
ze.insert(ze.begin(), on[z]);
on.erase(on.begin());
}
for (int z = 2; z >= 1; z--) {
ans.push_back(ze[z].first);
ans.push_back(ze[z].second);
on.push_back(ze[z]);
ze.pop_back();
}
}
if (on.size() == 3) {
for (int z = 0; z < on.size(); z++) {
ans.push_back(on[z].first);
ans.push_back(on[z].second);
}
ze.clear(), on.clear();
}
if (on.size() == 4) {
for (int z = 3; z >= 1; z--) {
ans.push_back(on[z].first);
ans.push_back(on[z].second);
ze.push_back(on[z]);
on.pop_back();
}
}
}
cout << ans.size() / 6 << endl;
for (int i = 0; i < ans.size(); i += 6) {
for (int j = i; j < i + 6; j++) cout << ans[j] + 1 << ' ';
cout << endl;
}
}
}
|
Argus was charged with guarding Io, which is not an ordinary cow. Io is quite an explorer, and she wanders off rather frequently, making Argus' life stressful. So the cowherd decided to construct an enclosed pasture for Io.
There are n trees growing along the river, where Argus tends Io. For this problem, the river can be viewed as the OX axis of the Cartesian coordinate system, and the n trees as points with the y-coordinate equal 0. There is also another tree growing in the point (0, 1).
Argus will tie a rope around three of the trees, creating a triangular pasture. Its exact shape doesn't matter to Io, but its area is crucial to her. There may be many ways for Argus to arrange the fence, but only the ones which result in different areas of the pasture are interesting for Io. Calculate the number of different areas that her pasture may have. Note that the pasture must have nonzero area.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow, each one is described in two lines.
In the first line of each test case there is a single integer n (1 ≤ n ≤ 50) denoting the number of trees growing along the river. Next line contains n distinct integers x_1 < x_2 < … < x_{n - 1} < x_n (1 ≤ x_i ≤ 50), the x-coordinates of trees growing along the river.
Output
In a single line output an integer, the number of different nonzero areas that triangles with trees as vertices may have.
Example
Input
8
4
1 2 4 5
3
1 3 5
3
2 6 8
2
1 2
1
50
5
3 4 5 6 8
3
1 25 26
6
1 2 4 8 16 32
Output
4
2
3
1
0
5
3
15
Note
In the first test case, we have 6 non-degenerate triangles with the following areas: 0.5, 0.5, 1, 1.5, 1.5 and 2. The pasture can have 4 different areas, and thus 4 is the answer.
In the second test case, we have 3 non-degenerate triangles with the following areas: 1, 1 and 2. The pasture can have 2 different areas, so 2 is the answer.
The following two drawings present the situation in the second test case. The blue triangles in the first drawing have area 1. The red triangle in the second drawing has area 2.
<image>
|
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class TaskGB2020A {
public static void main(String[] args) {
Scanner in = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
int t = in.nextInt(); // Scanner has functions to read ints, longs, strings, chars, etc.
long n, m, c;
int a[] = new int[51];
final Set<Integer> sa = new HashSet<>();
for (int i = 1; i <= t; ++i) {
n = in.nextLong();
for (int j = 0; j < n; j++) {
a[j] = in.nextInt();
}
for (int j = 0; j < n; j++) {
for (int k = j + 1; k < n; k++) {
sa.add(a[k] - a[j]);
}
}
System.out.println(sa.size());
sa.clear();
}
}
}
|
You are given a number n (divisible by 3) and an array a[1 ... n]. In one move, you can increase any of the array elements by one. Formally, you choose the index i (1 ≤ i ≤ n) and replace a_i with a_i + 1. You can choose the same index i multiple times for different moves.
Let's denote by c_0, c_1 and c_2 the number of numbers from the array a that have remainders 0, 1 and 2 when divided by the number 3, respectively. Let's say that the array a has balanced remainders if c_0, c_1 and c_2 are equal.
For example, if n = 6 and a = [0, 2, 5, 5, 4, 8], then the following sequence of moves is possible:
* initially c_0 = 1, c_1 = 1 and c_2 = 4, these values are not equal to each other. Let's increase a_3, now the array a = [0, 2, 6, 5, 4, 8];
* c_0 = 2, c_1 = 1 and c_2 = 3, these values are not equal. Let's increase a_6, now the array a = [0, 2, 6, 5, 4, 9];
* c_0 = 3, c_1 = 1 and c_2 = 2, these values are not equal. Let's increase a_1, now the array a = [1, 2, 6, 5, 4, 9];
* c_0 = 2, c_1 = 2 and c_2 = 2, these values are equal to each other, which means that the array a has balanced remainders.
Find the minimum number of moves needed to make the array a have balanced remainders.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (3 ≤ n ≤ 3 ⋅ 10^4) — the length of the array a. It is guaranteed that the number n is divisible by 3.
The next line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100).
It is guaranteed that the sum of n over all test cases does not exceed 150 000.
Output
For each test case, output one integer — the minimum number of moves that must be made for the a array to make it have balanced remainders.
Example
Input
4
6
0 2 5 5 4 8
6
2 0 2 1 0 0
9
7 1 3 4 2 10 3 9 6
6
0 1 2 3 4 5
Output
3
1
3
0
Note
The first test case is explained in the statements.
In the second test case, you need to make one move for i=2.
The third test case you need to make three moves:
* the first move: i=9;
* the second move: i=9;
* the third move: i=2.
In the fourth test case, the values c_0, c_1 and c_2 initially equal to each other, so the array a already has balanced remainders.
|
#include<bits/stdc++.h>
using namespace std;
void solve()
{
int n;
cin>>n;
int a[n],c0=0,c1=0,c2=0;
for(int i=0;i<n;i++)
{
cin>>a[i];
if(a[i]%3==0)
{
c0++;
}
else if(a[i]%3==1)
{
c1++;
}
else if(a[i]%3==2)
{
c2++;
}
}
int b= n/3;
int ans=0;
for(int i=0;i<2;i++)
{
if(c0>b)
{
ans+=c0-b;
c1+=c0-b;
c0=b;
}
if(c1>b)
{
ans+=c1-b;
c2+=c1-b;
c1=b;
}
if(c2>b)
{
ans+=c2-b;
c0+=c2-b;
c2=b;
}
}
cout<<ans<<endl;
}
int main()
{
int t;
cin>>t;
while(t--)
solve();
return 0;
}
|
A permutation is a sequence of n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.
Polycarp was given four integers n, l, r (1 ≤ l ≤ r ≤ n) and s (1 ≤ s ≤ (n (n+1))/(2)) and asked to find a permutation p of numbers from 1 to n that satisfies the following condition:
* s = p_l + p_{l+1} + … + p_r.
For example, for n=5, l=3, r=5, and s=8, the following permutations are suitable (not all options are listed):
* p = [3, 4, 5, 2, 1];
* p = [5, 2, 4, 3, 1];
* p = [5, 2, 1, 3, 4].
But, for example, there is no permutation suitable for the condition above for n=4, l=1, r=1, and s=5.
Help Polycarp, for the given n, l, r, and s, find a permutation of numbers from 1 to n that fits the condition above. If there are several suitable permutations, print any of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 500). Then t test cases follow.
Each test case consist of one line with four integers n (1 ≤ n ≤ 500), l (1 ≤ l ≤ n), r (l ≤ r ≤ n), s (1 ≤ s ≤ (n (n+1))/(2)).
It is guaranteed that the sum of n for all input data sets does not exceed 500.
Output
For each test case, output on a separate line:
* n integers — a permutation of length n that fits the condition above if such a permutation exists;
* -1, otherwise.
If there are several suitable permutations, print any of them.
Example
Input
5
5 2 3 5
5 3 4 1
3 1 2 4
2 2 2 2
2 1 1 3
Output
1 2 3 4 5
-1
1 3 2
1 2
-1
|
import java.util.ArrayList;
import java.util.HashSet;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Arrays;
import java.util.Random;
import java.io.FileWriter;
import java.io.PrintWriter;
/*
Solution Created: 02:13:10 25/04/2021
Custom Competitive programming helper.
*/
public class Main {
public static void solve() {
int n = in.nextInt(), l = in.nextInt(), r = in.nextInt(), s = in.nextInt();
int range = r-l+1;
int rangeLeft = n-range;
int mnSum = (range+1)*range/2;
int mxSum = n*(n+1)/2 - (rangeLeft+1)*rangeLeft/2;
if(s<mnSum || mxSum<s) {
out.println(-1);
return;
}
int[] ans = new int[range+1];
for(int i = 0; i<range; i++) ans[i] = i+1;
ans[range] = n+1;
int idx = range-1;
for(int i = 0; i<s-mnSum; i++) {
if(ans[idx] + 1 == ans[idx+1]) idx--;
ans[idx]++;
}
idx = 0;
l--;r--;
HashSet<Integer> fixed = new HashSet<>();
for(int i = 0; i<range; i++) fixed.add(ans[i]);
ArrayList<Integer> other = new ArrayList<>();
for(int i = 1; i<=n; i++) if(!fixed.contains(i)) other.add(i);
for(int i = 0; i<n; i++) {
if(i<l || r<i) {
out.print(other.get(idx++)+" ");
}else {
int v = -1;
for(int x : fixed) {
v = x;
break;
}
out.print(v+" ");
fixed.remove(v);
}
}
out.println();
}
public static void main(String[] args) {
in = new Reader();
out = new Writer();
int t = in.nextInt();
while(t-->0) solve();
out.exit();
}
static Reader in; static Writer out;
static class Reader {
static BufferedReader br;
static StringTokenizer st;
public Reader() {
this.br = new BufferedReader(new InputStreamReader(System.in));
}
public Reader(String f){
try {
this.br = new BufferedReader(new FileReader(f));
} catch (IOException e) {
e.printStackTrace();
}
}
public int[] na(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = nextInt();
return a;
}
public double[] nd(int n) {
double[] a = new double[n];
for (int i = 0; i < n; i++) a[i] = nextDouble();
return a;
}
public long[] nl(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) a[i] = nextLong();
return a;
}
public char[] nca() {
return next().toCharArray();
}
public String[] ns(int n) {
String[] a = new String[n];
for (int i = 0; i < n; i++) a[i] = next();
return a;
}
public int nextInt() {
ensureNext();
return Integer.parseInt(st.nextToken());
}
public double nextDouble() {
ensureNext();
return Double.parseDouble(st.nextToken());
}
public Long nextLong() {
ensureNext();
return Long.parseLong(st.nextToken());
}
public String next() {
ensureNext();
return st.nextToken();
}
public String nextLine() {
try {
return br.readLine();
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
private void ensureNext() {
if (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
static class Util{
private static Random random = new Random();
static long[] fact;
public static void initFactorial(int n, long mod) {
fact = new long[n+1];
fact[0] = 1;
for (int i = 1; i < n+1; i++) fact[i] = (fact[i - 1] * i) % mod;
}
public static long modInverse(long a, long MOD) {
long[] gcdE = gcdExtended(a, MOD);
if (gcdE[0] != 1) return -1; // Inverted doesn't exist
long x = gcdE[1];
return (x % MOD + MOD) % MOD;
}
public static long[] gcdExtended(long p, long q) {
if (q == 0) return new long[] { p, 1, 0 };
long[] vals = gcdExtended(q, p % q);
long tmp = vals[2];
vals[2] = vals[1] - (p / q) * vals[2];
vals[1] = tmp;
return vals;
}
public static long nCr(int n, int r, long MOD) {
if (r == 0) return 1;
return (fact[n] * modInverse(fact[r], MOD) % MOD * modInverse(fact[n - r], MOD) % MOD) % MOD;
}
public static long nCr(int n, int r) {
return (fact[n]/fact[r])/fact[n-r];
}
public static long nPr(int n, int r, long MOD) {
if (r == 0) return 1;
return (fact[n] * modInverse(fact[n - r], MOD) % MOD) % MOD;
}
public static long nPr(int n, int r) {
return fact[n]/fact[n-r];
}
public static boolean isPrime(int 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 = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
public static boolean[] getSieve(int n) {
boolean[] isPrime = new boolean[n+1];
for (int i = 2; i <= n; i++) isPrime[i] = true;
for (int i = 2; i*i <= n; i++) if (isPrime[i])
for (int j = i; i*j <= n; j++) isPrime[i*j] = false;
return isPrime;
}
public static int gcd(int a, int b) {
int tmp = 0;
while(b != 0) {
tmp = b;
b = a%b;
a = tmp;
}
return a;
}
public static long gcd(long a, long b) {
long tmp = 0;
while(b != 0) {
tmp = b;
b = a%b;
a = tmp;
}
return a;
}
public static int random(int min, int max) {
return random.nextInt(max-min+1)+min;
}
public static void dbg(Object... o) {
System.out.println(Arrays.deepToString(o));
}
public static void reverse(int[] s, int l , int r) {
for(int i = l; i<=(l+r)/2; i++) {
int tmp = s[i];
s[i] = s[r+l-i];
s[r+l-i] = tmp;
}
}
public static void reverse(int[] s) {
reverse(s, 0, s.length-1);
}
public static void reverse(long[] s, int l , int r) {
for(int i = l; i<=(l+r)/2; i++) {
long tmp = s[i];
s[i] = s[r+l-i];
s[r+l-i] = tmp;
}
}
public static void reverse(long[] s) {
reverse(s, 0, s.length-1);
}
public static void reverse(float[] s, int l , int r) {
for(int i = l; i<=(l+r)/2; i++) {
float tmp = s[i];
s[i] = s[r+l-i];
s[r+l-i] = tmp;
}
}
public static void reverse(float[] s) {
reverse(s, 0, s.length-1);
}
public static void reverse(double[] s, int l , int r) {
for(int i = l; i<=(l+r)/2; i++) {
double tmp = s[i];
s[i] = s[r+l-i];
s[r+l-i] = tmp;
}
}
public static void reverse(double[] s) {
reverse(s, 0, s.length-1);
}
public static void reverse(char[] s, int l , int r) {
for(int i = l; i<=(l+r)/2; i++) {
char tmp = s[i];
s[i] = s[r+l-i];
s[r+l-i] = tmp;
}
}
public static void reverse(char[] s) {
reverse(s, 0, s.length-1);
}
public static <T> void reverse(T[] s, int l , int r) {
for(int i = l; i<=(l+r)/2; i++) {
T tmp = s[i];
s[i] = s[r+l-i];
s[r+l-i] = tmp;
}
}
public static <T> void reverse(T[] s) {
reverse(s, 0, s.length-1);
}
public static void shuffle(int[] s) {
for (int i = 0; i < s.length; ++i) {
int j = random.nextInt(i + 1);
int t = s[i];
s[i] = s[j];
s[j] = t;
}
}
public static void shuffle(long[] s) {
for (int i = 0; i < s.length; ++i) {
int j = random.nextInt(i + 1);
long t = s[i];
s[i] = s[j];
s[j] = t;
}
}
public static void shuffle(float[] s) {
for (int i = 0; i < s.length; ++i) {
int j = random.nextInt(i + 1);
float t = s[i];
s[i] = s[j];
s[j] = t;
}
}
public static void shuffle(double[] s) {
for (int i = 0; i < s.length; ++i) {
int j = random.nextInt(i + 1);
double t = s[i];
s[i] = s[j];
s[j] = t;
}
}
public static void shuffle(char[] s) {
for (int i = 0; i < s.length; ++i) {
int j = random.nextInt(i + 1);
char t = s[i];
s[i] = s[j];
s[j] = t;
}
}
public static <T> void shuffle(T[] s) {
for (int i = 0; i < s.length; ++i) {
int j = random.nextInt(i + 1);
T t = s[i];
s[i] = s[j];
s[j] = t;
}
}
public static void sortArray(int[] a) {
shuffle(a);
Arrays.sort(a);
}
public static void sortArray(long[] a) {
shuffle(a);
Arrays.sort(a);
}
public static void sortArray(float[] a) {
shuffle(a);
Arrays.sort(a);
}
public static void sortArray(double[] a) {
shuffle(a);
Arrays.sort(a);
}
public static void sortArray(char[] a) {
shuffle(a);
Arrays.sort(a);
}
public static <T extends Comparable<T>> void sortArray(T[] a) {
Arrays.sort(a);
}
}
static class Writer {
private PrintWriter pw;
public Writer(){
pw = new PrintWriter(System.out);
}
public Writer(String f){
try {
pw = new PrintWriter(new FileWriter(f));
} catch (IOException e) {
e.printStackTrace();
}
}
public void printArray(int[] a) {
for(int i = 0; i<a.length; i++) print(a[i]+" ");
}
public void printlnArray(int[] a) {
for(int i = 0; i<a.length; i++) print(a[i]+" ");
pw.println();
}
public void printArray(long[] a) {
for(int i = 0; i<a.length; i++) print(a[i]+" ");
}
public void printlnArray(long[] a) {
for(int i = 0; i<a.length; i++) print(a[i]+" ");
pw.println();
}
public void print(Object o) {
pw.print(o.toString());
}
public void println(Object o) {
pw.println(o.toString());
}
public void println() {
pw.println();
}
public void flush() {
pw.flush();
}
public void exit() {
pw.close();
}
}
}
|
In some country live wizards. They love to ride trolleybuses.
A city in this country has a trolleybus depot with n trolleybuses. Every day the trolleybuses leave the depot, one by one and go to the final station. The final station is at a distance of d meters from the depot. We know for the i-th trolleybus that it leaves at the moment of time ti seconds, can go at a speed of no greater than vi meters per second, and accelerate with an acceleration no greater than a meters per second squared. A trolleybus can decelerate as quickly as you want (magic!). It can change its acceleration as fast as you want, as well. Note that the maximum acceleration is the same for all trolleys.
Despite the magic the trolleys are still powered by an electric circuit and cannot overtake each other (the wires are to blame, of course). If a trolleybus catches up with another one, they go together one right after the other until they arrive at the final station. Also, the drivers are driving so as to arrive at the final station as quickly as possible.
You, as head of the trolleybuses' fans' club, are to determine for each trolley the minimum time by which it can reach the final station. At the time of arrival at the destination station the trolleybus does not necessarily have zero speed. When a trolley is leaving the depot, its speed is considered equal to zero. From the point of view of physics, the trolleybuses can be considered as material points, and also we should ignore the impact on the speed of a trolley bus by everything, except for the acceleration and deceleration provided by the engine.
Input
The first input line contains three space-separated integers n, a, d (1 ≤ n ≤ 105, 1 ≤ a, d ≤ 106) — the number of trolleybuses, their maximum acceleration and the distance from the depot to the final station, correspondingly.
Next n lines contain pairs of integers ti vi (0 ≤ t1 < t2... < tn - 1 < tn ≤ 106, 1 ≤ vi ≤ 106) — the time when the i-th trolleybus leaves the depot and its maximum speed, correspondingly. The numbers in the lines are separated by spaces.
Output
For each trolleybus print a single line the time it arrives to the final station. Print the times for the trolleybuses in the order in which the trolleybuses are given in the input. The answer will be accepted if the absolute or relative error doesn't exceed 10 - 4.
Examples
Input
3 10 10000
0 10
5 11
1000 1
Output
1000.5000000000
1000.5000000000
11000.0500000000
Input
1 2 26
28 29
Output
33.0990195136
Note
In the first sample the second trolleybus will catch up with the first one, that will happen at distance 510.5 meters from the depot. The trolleybuses will go the remaining 9489.5 meters together at speed 10 meters per second. As a result, both trolleybuses will arrive to the final station by the moment of time 1000.5 seconds. The third trolleybus will not catch up with them. It will arrive to the final station by the moment of time 11000.05 seconds.
|
import java.io.*;
import java.util.StringTokenizer;
/**
* 167A
* θ(n) time
* θ(n) space
*
* @author artyom
*/
public class _167A implements Runnable {
private BufferedReader in;
private StringTokenizer tok;
private Object solve() throws IOException {
int n = nextInt();
double a = nextInt(), d = nextInt();
double[] r = new double[n];
for (int i = 0; i < n; i++) {
double t0 = nextInt(), v = nextInt(),
s = v * v / (2 * a),
t = s <= d ? v / a + (d - s) / v : Math.sqrt(2 * d / a);
r[i] = t0 + t;
}
for (int i = 1; i < n; i++) {
r[i] = Math.max(r[i], r[i - 1]);
}
return join(r);
}
//--------------------------------------------------------------
public static void main(String[] args) {
new _167A().run();
}
@Override
public void run() {
try {
in = new BufferedReader(new InputStreamReader(System.in));
tok = null;
System.out.print(solve());
in.close();
} catch (IOException e) {
System.exit(0);
}
}
private String nextToken() throws IOException {
while (tok == null || !tok.hasMoreTokens()) {
tok = new StringTokenizer(in.readLine());
}
return tok.nextToken();
}
private int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
private static String join(double[] entries) {
StringBuilder sb = new StringBuilder();
for (int i = 0, n = entries.length - 1; i <= n; i++) {
sb.append(entries[i]);
if (i < n) {
sb.append('\n');
}
}
return sb.toString();
}
}
|
Polycarpus got hold of a family relationship tree. The tree describes family relationships of n people, numbered 1 through n. Each person in the tree has no more than one parent.
Let's call person a a 1-ancestor of person b, if a is the parent of b.
Let's call person a a k-ancestor (k > 1) of person b, if person b has a 1-ancestor, and a is a (k - 1)-ancestor of b's 1-ancestor.
Family relationships don't form cycles in the found tree. In other words, there is no person who is his own ancestor, directly or indirectly (that is, who is an x-ancestor for himself, for some x, x > 0).
Let's call two people x and y (x ≠ y) p-th cousins (p > 0), if there is person z, who is a p-ancestor of x and a p-ancestor of y.
Polycarpus wonders how many counsins and what kinds of them everybody has. He took a piece of paper and wrote m pairs of integers vi, pi. Help him to calculate the number of pi-th cousins that person vi has, for each pair vi, pi.
Input
The first input line contains a single integer n (1 ≤ n ≤ 105) — the number of people in the tree. The next line contains n space-separated integers r1, r2, ..., rn, where ri (1 ≤ ri ≤ n) is the number of person i's parent or 0, if person i has no parent. It is guaranteed that family relationships don't form cycles.
The third line contains a single number m (1 ≤ m ≤ 105) — the number of family relationship queries Polycarus has. Next m lines contain pairs of space-separated integers. The i-th line contains numbers vi, pi (1 ≤ vi, pi ≤ n).
Output
Print m space-separated integers — the answers to Polycarpus' queries. Print the answers to the queries in the order, in which the queries occur in the input.
Examples
Input
6
0 1 1 0 4 4
7
1 1
1 2
2 1
2 2
4 1
5 1
6 1
Output
0 0 1 0 0 1 1
|
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.StringTokenizer;
public class TaskE {
public static void main(String[] args) {
InputStream inputStream;
String str = null;
if(str == null){
inputStream = System.in;
}else{
inputStream = new ByteArrayInputStream(str.getBytes());
}
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
Solver solver = new Solver();
solver.solve(1, in, out);
out.close();
}
static class Solver {
public void solve(int testNumber, InputReader in, PrintWriter out) {
int numPeople = in.nextInt();
Person[] people = new Person[numPeople+1];
HashMap<Integer, ArrayList<Integer>> levels = new HashMap<>();
LinkedList<Person> roots = new LinkedList<>();
for(int i=1;i<=numPeople;i++){
people[i] = new Person();
people[i].index = i;
}
for(int i=1;i<=numPeople;i++){
people[i].parent = people[in.nextInt()];
//if(people[i].parent != null)
//System.out.println("Node " + i + " has parent " + people[i].parent.index);
if(people[i].parent == null){
roots.add(people[i]);
}else{
people[i].parent.children.add(people[i]);
}
}
//preprocess
int counter = 1;
HashMap<Integer, Person> origIDtoNewID = new HashMap<>();
for(Person root : roots){
LinkedList<Person> toVisit = new LinkedList<>();
HashSet<Person> visited = new HashSet<>();
toVisit.add(root);
//System.out.println("Starting");
while(!toVisit.isEmpty()){
Person current = toVisit.getFirst();
if(visited.contains(current)){
if(current.children.isEmpty()){
toVisit.remove(current);
if(current.parent!=null){
current.parent.maxChild = Math.max(current.ID, current.maxChild);
//System.out.println(current.index+" " + current.parent.maxChild);
}
}else{
toVisit.addFirst(current.children.removeFirst());
}
}else{
current.ID = counter++;
current.maxChild = current.ID;
origIDtoNewID.put(current.ID, current);
//System.out.println("Mapping: " + current.index + " to "+ current.ID);
visited.add(current);
if(current.parent != null){
current.height = current.parent.height+1;
}
if(!levels.containsKey(current.height)){
levels.put(current.height, new ArrayList<>());
}
levels.get(current.height).add(current.ID);
}
}
}
int numQueries = in.nextInt();
StringBuilder answers = new StringBuilder();
for(int query=0;query<numQueries;query++){
Person target = people[in.nextInt()];
int level = in.nextInt();
//System.out.println(query+": looking at node " + target.index + " parent is " + (target.parent == null ? null : target.parent.index));
if(level > target.height){
answers.append(0+" ");
continue;
}
//System.out.println("Searching: " + target.ID);
int parentIndex = levels.get(target.height-level).get((Collections.binarySearch(levels.get(target.height-level), target.ID)+1)*-1-1);
//System.out.println(levels.get(target.height-level));
//System.out.println(parentIndex+" is parent");
Person parent = people[origIDtoNewID.get(parentIndex).index];
int left = parent.ID;
int right = parent.maxChild+1;
int l = Collections.binarySearch(levels.get(target.height), left);
int r = Collections.binarySearch(levels.get(target.height), right);
//System.out.println(left + " "+ right + " -> " + l + " " +r + " " + levels.get(target.height));
if(l < 0){
l = (l+1)*-1;
}
if(r < 0){
r = (r+1)*-1;
}
//System.out.println(left + " "+ right + " -> " + l + " " +r);
//System.out.println();
answers.append(r-l-1);
answers.append(" ");
}
System.out.println(answers);
}
}
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());
}
}
}
class Person{
Person parent;
LinkedList<Person> children = new LinkedList<>();
int ID;
int index;
int height = 0;
int maxChild = 0;
}
|
Scientists say a lot about the problems of global warming and cooling of the Earth. Indeed, such natural phenomena strongly influence all life on our planet.
Our hero Vasya is quite concerned about the problems. He decided to try a little experiment and observe how outside daily temperature changes. He hung out a thermometer on the balcony every morning and recorded the temperature. He had been measuring the temperature for the last n days. Thus, he got a sequence of numbers t1, t2, ..., tn, where the i-th number is the temperature on the i-th day.
Vasya analyzed the temperature statistics in other cities, and came to the conclusion that the city has no environmental problems, if first the temperature outside is negative for some non-zero number of days, and then the temperature is positive for some non-zero number of days. More formally, there must be a positive integer k (1 ≤ k ≤ n - 1) such that t1 < 0, t2 < 0, ..., tk < 0 and tk + 1 > 0, tk + 2 > 0, ..., tn > 0. In particular, the temperature should never be zero. If this condition is not met, Vasya decides that his city has environmental problems, and gets upset.
You do not want to upset Vasya. Therefore, you want to select multiple values of temperature and modify them to satisfy Vasya's condition. You need to know what the least number of temperature values needs to be changed for that.
Input
The first line contains a single integer n (2 ≤ n ≤ 105) — the number of days for which Vasya has been measuring the temperature.
The second line contains a sequence of n integers t1, t2, ..., tn (|ti| ≤ 109) — the sequence of temperature values. Numbers ti are separated by single spaces.
Output
Print a single integer — the answer to the given task.
Examples
Input
4
-1 1 -2 1
Output
1
Input
5
0 -1 1 2 -5
Output
2
Note
Note to the first sample: there are two ways to change exactly one number so that the sequence met Vasya's condition. You can either replace the first number 1 by any negative number or replace the number -2 by any positive number.
|
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Scanner;
public class C {
public static void main(String[] args) throws FileNotFoundException {
Scanner sc = new Scanner(new File("input.txt"));
PrintWriter pw = new PrintWriter(new File("output.txt"));
int n = sc.nextInt();
int a[] = new int[n];
int min = 100000;
int m[] = new int[n];
int p[] = new int[n];
for (int i = 0; i < n; i++) {
a[i] = sc.nextInt();
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] >= 0){
cnt ++;
}
m[i] = cnt;
}
cnt = 0;
for (int i = n-1; i >= 0 ; i--) {
if (a[i] <= 0){
cnt++;
}
p[i] = cnt;
}
for (int i = 0; i < n-1; i++) {
if (p[i+1]+m[i] < min){
min = p[i+1]+m[i];
}
}
pw.println(min);
pw.close();
}
}
|
Phone number in Berland is a sequence of n digits. Often, to make it easier to memorize the number, it is divided into groups of two or three digits. For example, the phone number 1198733 is easier to remember as 11-987-33. Your task is to find for a given phone number any of its divisions into groups of two or three digits.
Input
The first line contains integer n (2 ≤ n ≤ 100) — amount of digits in the phone number. The second line contains n digits — the phone number to divide into groups.
Output
Output any of divisions of the given phone number into groups of two or three digits. Separate groups by single character -. If the answer is not unique, output any.
Examples
Input
6
549871
Output
54-98-71
Input
7
1198733
Output
11-987-33
|
from sys import stdin
n = int(stdin.readline())
m = stdin.readline()[:-1]
rv = ''
while len(m) > 3:
rv += m[:2] + '-'
m = m[2:]
rv += m
print rv
|
Farmer John has just given the cows a program to play with! The program contains two integer variables, x and y, and performs the following operations on a sequence a1, a2, ..., an of positive integers:
1. Initially, x = 1 and y = 0. If, after any step, x ≤ 0 or x > n, the program immediately terminates.
2. The program increases both x and y by a value equal to ax simultaneously.
3. The program now increases y by ax while decreasing x by ax.
4. The program executes steps 2 and 3 (first step 2, then step 3) repeatedly until it terminates (it may never terminate). So, the sequence of executed steps may start with: step 2, step 3, step 2, step 3, step 2 and so on.
The cows are not very good at arithmetic though, and they want to see how the program works. Please help them!
You are given the sequence a2, a3, ..., an. Suppose for each i (1 ≤ i ≤ n - 1) we run the program on the sequence i, a2, a3, ..., an. For each such run output the final value of y if the program terminates or -1 if it does not terminate.
Input
The first line contains a single integer, n (2 ≤ n ≤ 2·105). The next line contains n - 1 space separated integers, a2, a3, ..., an (1 ≤ ai ≤ 109).
Output
Output n - 1 lines. On the i-th line, print the requested value when the program is run on the sequence i, a2, a3, ...an.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
4
2 4 1
Output
3
6
8
Input
3
1 2
Output
-1
-1
Note
In the first sample
1. For i = 1, x becomes <image> and y becomes 1 + 2 = 3.
2. For i = 2, x becomes <image> and y becomes 2 + 4 = 6.
3. For i = 3, x becomes <image> and y becomes 3 + 1 + 4 = 8.
|
import java.io.OutputStream;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.File;
/**
*
* @author MEGNAD
*
*/
public class CowProgram {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
JoltyScanner in = new JoltyScanner(inputStream);
PrintWriter out = new PrintWriter(outputStream);
ProblemBCowProgram solver = new ProblemBCowProgram();
solver.solve(1, in, out);
out.close();
}
static class ProblemBCowProgram {
int n;
long[] a;
boolean[] stack2;
boolean[] stack3;
long[] memo2;
long[] memo3;
long oo = 987654321987654321L;
long dfs2(int x) {
if (memo2[x] != oo) return memo2[x];
stack2[x] = true;
long newx = x + a[x];
long ans;
if (newx > n || newx <= 0) {
ans = 0;
} else if (stack3[(int) newx]) {
ans = -1;
} else {
ans = dfs3((int) newx);
}
stack2[x] = false;
return memo2[x] = ans == -1 ? ans : ans + a[x];
}
long dfs3(int x) {
if (memo3[x] != oo) return memo3[x];
stack3[x] = true;
long newx = x - a[x];
long ans;
if (newx > n || newx <= 0) {
ans = 0;
} else if (stack2[(int) newx]) {
ans = -1;
} else {
ans = dfs2((int) newx);
}
stack3[x] = false;
return memo3[x] = ans == -1 ? ans : ans + a[x];
}
public void solve(int testNumber, JoltyScanner in, PrintWriter out) {
n = in.nextInt();
a = new long[n + 1];
for (int i = 2; i <= n; ++i) a[i] = in.nextInt();
stack2 = new boolean[n + 1];
stack3 = new boolean[n + 1];
memo2 = new long[n + 1];
Arrays.fill(memo2, oo);
memo3 = new long[n + 1];
Arrays.fill(memo3, oo);
for (int a1 = 1; a1 <= n - 1; ++a1) {
int x = 1, y = 0;
stack2[x] = true;
long ans = x + a1 > n || x + a1 <= 0 ? y + a1 : dfs3(x + a1);
if (ans != -1) ans += a1;
out.println(ans);
}
}
}
static class JoltyScanner {
public int BS = 1 << 16;
public char NC = (char) 0;
public byte[] buf = new byte[BS];
public int bId = 0;
public int size = 0;
public char c = NC;
public double num = 1;
public BufferedInputStream in;
public JoltyScanner(InputStream is) {
in = new BufferedInputStream(is, BS);
}
public JoltyScanner(String s) throws FileNotFoundException {
in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
}
public char nextChar() {
while (bId == size) {
try {
size = in.read(buf);
} catch (Exception e) {
return NC;
}
if (size == -1) return NC;
bId = 0;
}
return (char) buf[bId++];
}
public int nextInt() {
return (int) nextLong();
}
public long nextLong() {
num = 1;
boolean neg = false;
if (c == NC) c = nextChar();
for (; (c < '0' || c > '9'); c = nextChar()) {
if (c == '-') neg = true;
}
long res = 0;
for (; c >= '0' && c <= '9'; c = nextChar()) {
res = (res << 3) + (res << 1) + c - '0';
num *= 10;
}
return neg ? -res : res;
}
}
}
|
Polycarpus has got n candies and m friends (n ≥ m). He wants to make a New Year present with candies to each friend. Polycarpus is planning to present all candies and he wants to do this in the fairest (that is, most equal) manner. He wants to choose such ai, where ai is the number of candies in the i-th friend's present, that the maximum ai differs from the least ai as little as possible.
For example, if n is divisible by m, then he is going to present the same number of candies to all his friends, that is, the maximum ai won't differ from the minimum one.
Input
The single line of the input contains a pair of space-separated positive integers n, m (1 ≤ n, m ≤ 100;n ≥ m) — the number of candies and the number of Polycarpus's friends.
Output
Print the required sequence a1, a2, ..., am, where ai is the number of candies in the i-th friend's present. All numbers ai must be positive integers, total up to n, the maximum one should differ from the minimum one by the smallest possible value.
Examples
Input
12 3
Output
4 4 4
Input
15 4
Output
3 4 4 4
Input
18 7
Output
2 2 2 3 3 3 3
Note
Print ai in any order, separate the numbers by spaces.
|
n,m=map(int,input().split())
print(*[n//m+1 if i<n%m else n//m for i in range(m)])
|
Yet another Armageddon is coming! This time the culprit is the Julya tribe calendar.
The beavers in this tribe knew math very well. Smart Beaver, an archaeologist, got a sacred plate with a magic integer on it. The translation from Old Beaverish is as follows:
"May the Great Beaver bless you! May your chacres open and may your third eye never turn blind from beholding the Truth! Take the magic number, subtract a digit from it (the digit must occur in the number) and get a new magic number. Repeat this operation until a magic number equals zero. The Earth will stand on Three Beavers for the time, equal to the number of subtractions you perform!"
Distinct subtraction sequences can obviously get you different number of operations. But the Smart Beaver is ready to face the worst and is asking you to count the minimum number of operations he needs to reduce the magic number to zero.
Input
The single line contains the magic integer n, 0 ≤ n.
* to get 20 points, you need to solve the problem with constraints: n ≤ 106 (subproblem C1);
* to get 40 points, you need to solve the problem with constraints: n ≤ 1012 (subproblems C1+C2);
* to get 100 points, you need to solve the problem with constraints: n ≤ 1018 (subproblems C1+C2+C3).
Output
Print a single integer — the minimum number of subtractions that turns the magic number to a zero.
Examples
Input
24
Output
5
Note
In the first test sample the minimum number of operations can be reached by the following sequence of subtractions:
24 → 20 → 18 → 10 → 9 → 0
|
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, long long>, pair<long long, long long> > mp;
pair<long long, long long> solve(long long N, long long mxd) {
if (N == 0 && mxd == 0) return {0LL, 0LL};
if (N < 10) {
if (mxd == 0) return {1LL, 0LL};
if (mxd > N) return {1LL, N - mxd};
return {2LL, -mxd};
}
long long initN = N;
if (mp.count({N, mxd})) return mp[{N, mxd}];
long long p10 = 1;
while (p10 <= N / 10LL) p10 *= 10LL;
long long cif = N / p10;
long long rem = N % p10;
pair<long long, long long> ans1 = solve(N % p10, max(cif, mxd));
cif--;
if (cif < 0) {
mp[{initN, mxd}] = ans1;
return ans1;
}
N -= (N % p10);
N += ans1.second;
pair<long long, long long> ans2 = solve(N, mxd);
pair<long long, long long> ans;
ans.first = ans1.first + ans2.first;
ans.second = ans2.second;
mp[{initN, mxd}] = ans;
return ans;
}
int main() {
long long N;
scanf("%I64d", &N);
auto ans = solve(N, 0);
printf("%I64d\n", ans.first);
return 0;
}
|
You have a directed acyclic graph G, consisting of n vertexes, numbered from 0 to n - 1. The graph contains n edges numbered from 0 to n - 1. An edge with number i connects vertexes i and (i + 1) mod n, and it can be directed in either direction (from i to (i + 1) mod n, or vise versa).
Operation x mod y means taking the remainder after dividing number x by number y.
Let's call two vertexes u and v in graph G comparable if the graph contains a path either from u to v or from v to u. We'll assume that an antichain is a set of vertexes of graph G, where any two distinct vertexes are not comparable. The size of an antichain is the number of vertexes in the corresponding set. An antichain is maximum if the graph doesn't have antichains of a larger size.
Your task is to find the size of the maximum antichain in graph G.
Input
The first line contains the sequence of characters s0s1... sn - 1 (2 ≤ n ≤ 106), consisting of numbers zero and one. The length of the line (number n) corresponds to the number of vertexes and edges in graph G. If character si (i ≥ 0) equals 0, then the edge between vertexes i and (i + 1) mod n is directed from the i-th vertex to the (i + 1) mod n-th one, otherwise — to the opposite point.
It is guaranteed that the given graph is acyclic.
Output
Print a single integer — the size of the maximum antichain of graph G.
Examples
Input
001
Output
1
Input
110010
Output
3
Note
Consider the first test sample. The graph's G edges are: 0 → 1, 1 → 2, 0 → 2. We can choose the set of vertexes [0] as the maximum antichain. We cannot choose an antichain of larger size.
|
//package round205;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
public class E3 {
InputStream is;
PrintWriter out;
String INPUT = "";
void solve()
{
char[] s = ns().toCharArray();
int n = s.length;
boolean[] f = new boolean[n];
int ct = 0;
for(int i = 1;i < n;i++){
if(s[i] != s[i-1]){
int t = i, tn = i;
for(int j = 0, jn = i;j <= n;j++){
if(j == n || s[tn] != s[jn]){
if(i+j-t > 1){
ct++;
for(int k = t, kn = tn;k <= i+j;k++){
f[kn] = true;
if(++kn == n)kn = 0;
}
}
t = (i+j);
tn = i+j;
if(tn >= n)tn -= n;
}
if(++jn == n)jn = 0;
}
if(ct == 0){
out.println(n/2);
return;
}
for(int j = 0;j < n;j++){
if(f[j]){
if(++j == n)j = 0;
int lct = 0;
for(int k = 0, kn = j;k < n;k++){
if(!f[kn]){
lct++;
}else{
ct += (lct+1)/2;
lct = 0;
}
if(++kn == n)kn = 0;
}
break;
}
}
break;
}
}
out.println(ct);
}
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 E3().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)); }
}
|
Two players are playing a game. First each of them writes an integer from 1 to 6, and then a dice is thrown. The player whose written number got closer to the number on the dice wins. If both payers have the same difference, it's a draw.
The first player wrote number a, the second player wrote number b. How many ways to throw a dice are there, at which the first player wins, or there is a draw, or the second player wins?
Input
The single line contains two integers a and b (1 ≤ a, b ≤ 6) — the numbers written on the paper by the first and second player, correspondingly.
Output
Print three integers: the number of ways to throw the dice at which the first player wins, the game ends with a draw or the second player wins, correspondingly.
Examples
Input
2 5
Output
3 0 3
Input
2 4
Output
2 1 3
Note
The dice is a standard cube-shaped six-sided object with each side containing a number from 1 to 6, and where all numbers on all sides are distinct.
You can assume that number a is closer to number x than number b, if |a - x| < |b - x|.
|
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner in = new Scanner(System.in);
int a=in.nextInt();
int b=in.nextInt();
int winA=0,winB=0,draw=0;
if(a==b){
draw=6;
winA=0;
winB=0;
}
if(a>b){
if((a+b)%2==1){
draw=0;
}
else{
draw=1;
}
winA=(6-(a+b)/2);
winB=6-winA-draw;
}
if(a<b){
if((a+b)%2==1){
winA=((a+b)/2-1+1);
draw=0;
}
else{
winA=(a+b)/2-1;
draw=1;
}
winB=6-winA-draw;
}
System.out.println(winA+" "+draw+" "+winB);
}
}
|
There are lots of theories concerning the origin of moon craters. Most scientists stick to the meteorite theory, which says that the craters were formed as a result of celestial bodies colliding with the Moon. The other version is that the craters were parts of volcanoes.
An extraterrestrial intelligence research specialist professor Okulov (the namesake of the Okulov, the author of famous textbooks on programming) put forward an alternate hypothesis. Guess what kind of a hypothesis it was –– sure, the one including extraterrestrial mind involvement. Now the professor is looking for proofs of his hypothesis.
Professor has data from the moon robot that moves linearly in one direction along the Moon surface. The moon craters are circular in form with integer-valued radii. The moon robot records only the craters whose centers lay on his path and sends to the Earth the information on the distance from the centers of the craters to the initial point of its path and on the radii of the craters.
According to the theory of professor Okulov two craters made by an extraterrestrial intelligence for the aims yet unknown either are fully enclosed one in the other or do not intersect at all. Internal or external tangency is acceptable. However the experimental data from the moon robot do not confirm this theory! Nevertheless, professor Okulov is hopeful. He perfectly understands that to create any logical theory one has to ignore some data that are wrong due to faulty measuring (or skillful disguise by the extraterrestrial intelligence that will be sooner or later found by professor Okulov!) That’s why Okulov wants to choose among the available crater descriptions the largest set that would satisfy his theory.
Input
The first line has an integer n (1 ≤ n ≤ 2000) — the number of discovered craters. The next n lines contain crater descriptions in the "ci ri" format, where ci is the coordinate of the center of the crater on the moon robot’s path, ri is the radius of the crater. All the numbers ci and ri are positive integers not exceeding 109. No two craters coincide.
Output
In the first line output the number of craters in the required largest set. In the next line output space-separated numbers of craters that this set consists of. The craters are numbered from 1 to n in the order in which they were given in the input data. The numbers may be output in any order. If the result is not unique, output any.
Examples
Input
4
1 1
2 2
4 1
5 1
Output
3
1 2 4
|
#include <bits/stdc++.h>
using namespace std;
int pct(int x) { return __builtin_popcount(x); }
int pct(long long x) { return __builtin_popcountll(x); }
int bt(int x) { return 31 - __builtin_clz(x); }
int bt(long long x) { return 63 - __builtin_clzll(x); }
int cdiv(int a, int b) { return a / b + !(a < 0 || a % b == 0); }
long long cdiv(long long a, long long b) {
return a / b + !(a < 0 || a % b == 0);
}
int nxt_C(int x) {
int c = x & -x, r = x + c;
return (((r ^ x) >> 2) / c) | r;
}
long long nxt_C(long long x) {
long long c = x & -x, r = x + c;
return (((r ^ x) >> 2) / c) | r;
}
vector<int> get_bits(int mask) {
vector<int> bb;
while (mask) {
int b = bt(mask);
bb.push_back(b);
mask ^= (1 << b);
}
reverse(bb.begin(), bb.end());
return bb;
}
int get_mask(vector<int> v) {
int mask = 0;
for (int x : v) {
mask ^= (1 << x);
}
return mask;
}
template <typename T>
void uniq(vector<T> &v) {
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
}
template <typename T>
void leftShift(vector<T> &v, long long k) {
k %= (int)v.size();
if (k < 0) k += (int)v.size();
rotate(v.begin(), v.begin() + k, v.end());
}
template <typename T>
void rightShift(vector<T> &v, long long k) {
leftShift(v, (int)v.size() - k);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long rand(long long l, long long r) {
uniform_int_distribution<long long> uid(l, r);
return uid(rng);
}
void sc() {}
template <typename Head, typename... Tail>
void sc(Head &H, Tail &...T) {
cin >> H;
sc(T...);
}
string to_string(__int128 x) {
string s = "";
bool neg = 0;
if (x < 0) {
s += "-";
neg = 1;
x = -x;
}
if (!x) s += '0';
while (x) {
int rem = x % 10;
s += to_string(rem);
x /= 10;
}
reverse(s.begin() + neg, s.end());
return s;
}
const int mod = 1e9 + 7;
int pwr(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = (ans * 1LL * a) % mod;
a = (a * 1LL * a) % mod;
b >>= 1;
}
return ans;
}
const int N = 4005;
int l[N], r[N];
vector<int> comp;
vector<pair<int, int> > lol[N];
int dp[N][N];
int go(int l, int r) {
if (l >= r) return 0;
if (dp[l][r] != -1) return dp[l][r];
bool z = 0;
for (pair<int, int> lr : lol[r]) {
if (lr.first == l) z = 1;
}
int ans = go(l, r - 1) + z;
for (pair<int, int> lr : lol[r]) {
if (lr.first <= l) continue;
int val = go(l, lr.first) + z + go(lr.first, r);
ans = max(ans, val);
}
return dp[l][r] = ans;
}
void get(int l, int r) {
if (l >= r) return;
int ans = go(l, r);
bool z = 0;
for (pair<int, int> lr : lol[r]) {
if (lr.first == l) {
z = 1;
cout << lr.second << " ";
}
}
if (ans == go(l, r - 1) + z) {
get(l, r - 1);
return;
}
for (pair<int, int> lr : lol[r]) {
if (lr.first <= l) continue;
int val = go(l, lr.first) + z + go(lr.first, r);
if (ans == val) {
get(l, lr.first);
get(lr.first, r);
return;
}
}
}
void solve() {
int n;
sc(n);
memset(dp, -1, sizeof dp);
for (int i = 1; i <= n; i++) {
int x, c;
sc(x, c);
l[i] = x - c, r[i] = x + c;
comp.push_back(l[i]);
comp.push_back(r[i]);
}
uniq(comp);
for (int i = 1; i <= n; i++) {
l[i] = upper_bound(comp.begin(), comp.end(), l[i]) - comp.begin();
r[i] = upper_bound(comp.begin(), comp.end(), r[i]) - comp.begin();
lol[r[i]].emplace_back(l[i], i);
}
int ans;
cout << (ans = go(1, (int)comp.size())) << '\n';
get(1, (int)comp.size());
}
signed main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int tt = 1; tt <= t; tt++) {
solve();
}
return 0;
}
|
Recently an official statement of the world Olympic Committee said that the Olympic Winter Games 2030 will be held in Tomsk. The city officials decided to prepare for the Olympics thoroughly and to build all the necessary Olympic facilities as early as possible. First, a biathlon track will be built.
To construct a biathlon track a plot of land was allocated, which is a rectangle divided into n × m identical squares. Each of the squares has two coordinates: the number of the row (from 1 to n), where it is located, the number of the column (from 1 to m), where it is located. Also each of the squares is characterized by its height. During the sports the biathletes will have to move from one square to another. If a biathlete moves from a higher square to a lower one, he makes a descent. If a biathlete moves from a lower square to a higher one, he makes an ascent. If a biathlete moves between two squares with the same height, then he moves on flat ground.
The biathlon track should be a border of some rectangular area of the allocated land on which biathletes will move in the clockwise direction. It is known that on one move on flat ground an average biathlete spends tp seconds, an ascent takes tu seconds, a descent takes td seconds. The Tomsk Administration wants to choose the route so that the average biathlete passes it in as close to t seconds as possible. In other words, the difference between time ts of passing the selected track and t should be minimum.
For a better understanding you can look at the first sample of the input data. In this sample n = 6, m = 7, and the administration wants the track covering time to be as close to t = 48 seconds as possible, also, tp = 3, tu = 6 and td = 2. If we consider the rectangle shown on the image by arrows, the average biathlete can move along the boundary in a clockwise direction in exactly 48 seconds. The upper left corner of this track is located in the square with the row number 4, column number 3 and the lower right corner is at square with row number 6, column number 7.
<image>
Among other things the administration wants all sides of the rectangle which boundaries will be the biathlon track to consist of no less than three squares and to be completely contained within the selected land.
You are given the description of the given plot of land and all necessary time values. You are to write the program to find the most suitable rectangle for a biathlon track. If there are several such rectangles, you are allowed to print any of them.
Input
The first line of the input contains three integers n, m and t (3 ≤ n, m ≤ 300, 1 ≤ t ≤ 109) — the sizes of the land plot and the desired distance covering time.
The second line also contains three integers tp, tu and td (1 ≤ tp, tu, td ≤ 100) — the time the average biathlete needs to cover a flat piece of the track, an ascent and a descent respectively.
Then n lines follow, each line contains m integers that set the heights of each square of the given plot of land. Each of the height values is a positive integer, not exceeding 106.
Output
In a single line of the output print four positive integers — the number of the row and the number of the column of the upper left corner and the number of the row and the number of the column of the lower right corner of the rectangle that is chosen for the track.
Examples
Input
6 7 48
3 6 2
5 4 8 3 3 7 9
4 1 6 8 7 1 1
1 6 4 6 4 8 6
7 2 6 1 6 9 4
1 9 8 6 3 9 2
4 5 6 8 4 3 7
Output
4 3 6 7
|
#include <bits/stdc++.h>
using namespace std;
int n, m, t, tu, tp, td, pi, pii, pj, pjj;
int U[305][305], D[305][305], L[305][305], R[305][305], a[305][305];
int cal(int x, int y) {
if (x == y) return tp;
return x < y ? tu : td;
}
int main() {
int ans = 0x7fffffff;
scanf("%d%d%d", &n, &m, &t);
scanf("%d%d%d", &tp, &tu, &td);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
if (i != 1) U[i][j] = U[i - 1][j] + cal(a[i - 1][j], a[i][j]);
if (i != 1) D[i][j] = D[i - 1][j] + cal(a[i][j], a[i - 1][j]);
if (j != 1) L[i][j] = L[i][j - 1] + cal(a[i][j - 1], a[i][j]);
if (j != 1) R[i][j] = R[i][j - 1] + cal(a[i][j], a[i][j - 1]);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
for (int ii = i + 2; ii <= n; ++ii)
for (int jj = j + 2; jj <= m; ++jj) {
int lr = L[i][jj] - L[i][j] + R[ii][jj] - R[ii][j],
ud = D[ii][j] - D[i][j] + U[ii][jj] - U[i][jj];
if (ans > abs(lr + ud - t)) {
pii = ii;
pi = i;
pjj = jj;
pj = j;
ans = abs(lr + ud - t);
}
}
printf("%d %d %d %d\n", pi, pj, pii, pjj);
return 0;
}
|
Jzzhu is the president of country A. There are n cities numbered from 1 to n in his country. City 1 is the capital of A. Also there are m roads connecting the cities. One can go from city ui to vi (and vise versa) using the i-th road, the length of this road is xi. Finally, there are k train routes in the country. One can use the i-th train route to go from capital of the country to city si (and vise versa), the length of this route is yi.
Jzzhu doesn't want to waste the money of the country, so he is going to close some of the train routes. Please tell Jzzhu the maximum number of the train routes which can be closed under the following condition: the length of the shortest path from every city to the capital mustn't change.
Input
The first line contains three integers n, m, k (2 ≤ n ≤ 105; 1 ≤ m ≤ 3·105; 1 ≤ k ≤ 105).
Each of the next m lines contains three integers ui, vi, xi (1 ≤ ui, vi ≤ n; ui ≠ vi; 1 ≤ xi ≤ 109).
Each of the next k lines contains two integers si and yi (2 ≤ si ≤ n; 1 ≤ yi ≤ 109).
It is guaranteed that there is at least one way from every city to the capital. Note, that there can be multiple roads between two cities. Also, there can be multiple routes going to the same city from the capital.
Output
Output a single integer representing the maximum number of the train routes which can be closed.
Examples
Input
5 5 3
1 2 1
2 3 2
1 3 3
3 4 4
1 5 5
3 5
4 5
5 5
Output
2
Input
2 2 3
1 2 2
2 1 3
2 1
2 2
2 3
Output
2
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100001;
const long long MAX = 123456897213124;
int n, m, k, ans;
vector<pair<int, long long> > a[N];
priority_queue<pair<long long, int> > q;
bool Visited[N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int u, v;
long long x;
cin >> u >> v >> x;
a[u].push_back(make_pair(v, x));
a[v].push_back(make_pair(u, x));
}
for (int i = 1; i <= k; i++) {
int u;
long long x;
cin >> u >> x;
q.push(make_pair(-x, u - N));
}
q.push(make_pair(0, 1));
while (!q.empty()) {
pair<long long, int> u = q.top();
q.pop();
if (u.second < 0) {
u.second += N;
if (Visited[u.second]) ans++;
}
if (Visited[u.second]) continue;
Visited[u.second] = 1;
for (int i = 0; i < (int)a[u.second].size(); i++)
q.push(make_pair(u.first - a[u.second][i].second, a[u.second][i].first));
}
cout << ans;
return 0;
}
|
Vasya decided to learn to play chess. Classic chess doesn't seem interesting to him, so he plays his own sort of chess.
The queen is the piece that captures all squares on its vertical, horizontal and diagonal lines. If the cell is located on the same vertical, horizontal or diagonal line with queen, and the cell contains a piece of the enemy color, the queen is able to move to this square. After that the enemy's piece is removed from the board. The queen cannot move to a cell containing an enemy piece if there is some other piece between it and the queen.
There is an n × n chessboard. We'll denote a cell on the intersection of the r-th row and c-th column as (r, c). The square (1, 1) contains the white queen and the square (1, n) contains the black queen. All other squares contain green pawns that don't belong to anyone.
The players move in turns. The player that moves first plays for the white queen, his opponent plays for the black queen.
On each move the player has to capture some piece with his queen (that is, move to a square that contains either a green pawn or the enemy queen). The player loses if either he cannot capture any piece during his move or the opponent took his queen during the previous move.
Help Vasya determine who wins if both players play with an optimal strategy on the board n × n.
Input
The input contains a single number n (2 ≤ n ≤ 109) — the size of the board.
Output
On the first line print the answer to problem — string "white" or string "black", depending on who wins if the both players play optimally.
If the answer is "white", then you should also print two integers r and c representing the cell (r, c), where the first player should make his first move to win. If there are multiple such cells, print the one with the minimum r. If there are still multiple squares, print the one with the minimum c.
Examples
Input
2
Output
white
1 2
Input
3
Output
black
Note
In the first sample test the white queen can capture the black queen at the first move, so the white player wins.
In the second test from the statement if the white queen captures the green pawn located on the central vertical line, then it will be captured by the black queen during the next move. So the only move for the white player is to capture the green pawn located at (2, 1).
Similarly, the black queen doesn't have any other options but to capture the green pawn located at (2, 3), otherwise if it goes to the middle vertical line, it will be captured by the white queen.
During the next move the same thing happens — neither the white, nor the black queen has other options rather than to capture green pawns situated above them. Thus, the white queen ends up on square (3, 1), and the black queen ends up on square (3, 3).
In this situation the white queen has to capture any of the green pawns located on the middle vertical line, after that it will be captured by the black queen. Thus, the player who plays for the black queen wins.
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.FilterInputStream;
import java.io.BufferedInputStream;
import java.io.InputStream;
/**
* @author khokharnikunj8
*/
public class Main {
public static void main(String[] args) {
new Thread(null, new Runnable() {
public void run() {
new Main().solve();
}
}, "1", 1 << 26).start();
}
void solve() {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
ScanReader in = new ScanReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
DVasyaAndChess solver = new DVasyaAndChess();
solver.solve(1, in, out);
out.close();
}
static class DVasyaAndChess {
public void solve(int testNumber, ScanReader in, PrintWriter out) {
int n = in.scanInt();
if ((n & 1) == 1) out.println("black");
else out.println("white\n1 2");
}
}
static class ScanReader {
private byte[] buf = new byte[4 * 1024];
private int index;
private BufferedInputStream in;
private int total;
public ScanReader(InputStream inputStream) {
in = new BufferedInputStream(inputStream);
}
private int scan() {
if (index >= total) {
index = 0;
try {
total = in.read(buf);
} catch (Exception e) {
e.printStackTrace();
}
if (total <= 0) return -1;
}
return buf[index++];
}
public int scanInt() {
int integer = 0;
int n = scan();
while (isWhiteSpace(n)) n = scan();
int neg = 1;
if (n == '-') {
neg = -1;
n = scan();
}
while (!isWhiteSpace(n)) {
if (n >= '0' && n <= '9') {
integer *= 10;
integer += n - '0';
n = scan();
}
}
return neg * integer;
}
private boolean isWhiteSpace(int n) {
if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1) return true;
else return false;
}
}
}
|
Anya has bought a new smartphone that uses Berdroid operating system. The smartphone menu has exactly n applications, each application has its own icon. The icons are located on different screens, one screen contains k icons. The icons from the first to the k-th one are located on the first screen, from the (k + 1)-th to the 2k-th ones are on the second screen and so on (the last screen may be partially empty).
Initially the smartphone menu is showing the screen number 1. To launch the application with the icon located on the screen t, Anya needs to make the following gestures: first she scrolls to the required screen number t, by making t - 1 gestures (if the icon is on the screen t), and then make another gesture — press the icon of the required application exactly once to launch it.
After the application is launched, the menu returns to the first screen. That is, to launch the next application you need to scroll through the menu again starting from the screen number 1.
All applications are numbered from 1 to n. We know a certain order in which the icons of the applications are located in the menu at the beginning, but it changes as long as you use the operating system. Berdroid is intelligent system, so it changes the order of the icons by moving the more frequently used icons to the beginning of the list. Formally, right after an application is launched, Berdroid swaps the application icon and the icon of a preceding application (that is, the icon of an application on the position that is smaller by one in the order of menu). The preceding icon may possibly be located on the adjacent screen. The only exception is when the icon of the launched application already occupies the first place, in this case the icon arrangement doesn't change.
Anya has planned the order in which she will launch applications. How many gestures should Anya make to launch the applications in the planned order?
Note that one application may be launched multiple times.
Input
The first line of the input contains three numbers n, m, k (1 ≤ n, m, k ≤ 105) — the number of applications that Anya has on her smartphone, the number of applications that will be launched and the number of icons that are located on the same screen.
The next line contains n integers, permutation a1, a2, ..., an — the initial order of icons from left to right in the menu (from the first to the last one), ai — is the id of the application, whose icon goes i-th in the menu. Each integer from 1 to n occurs exactly once among ai.
The third line contains m integers b1, b2, ..., bm(1 ≤ bi ≤ n) — the ids of the launched applications in the planned order. One application may be launched multiple times.
Output
Print a single number — the number of gestures that Anya needs to make to launch all the applications in the desired order.
Examples
Input
8 3 3
1 2 3 4 5 6 7 8
7 8 1
Output
7
Input
5 4 2
3 1 5 2 4
4 4 4 4
Output
8
Note
In the first test the initial configuration looks like (123)(456)(78), that is, the first screen contains icons of applications 1, 2, 3, the second screen contains icons 4, 5, 6, the third screen contains icons 7, 8.
After application 7 is launched, we get the new arrangement of the icons — (123)(457)(68). To launch it Anya makes 3 gestures.
After application 8 is launched, we get configuration (123)(457)(86). To launch it Anya makes 3 gestures.
After application 1 is launched, the arrangement of icons in the menu doesn't change. To launch it Anya makes 1 gesture.
In total, Anya makes 7 gestures.
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.StringTokenizer;
public class Solve6 {
public static void main(String[] args) throws IOException {
PrintWriter pw = new PrintWriter(System.out);
new Solve6().solve(pw);
pw.flush();
pw.close();
}
public void solve(PrintWriter pw) throws IOException {
FastReader sc = new FastReader();
HashMap<Integer, Integer> id = new HashMap();
HashMap<Integer, Integer> pos = new HashMap();
int n = sc.nextInt(), m = sc.nextInt(), k = sc.nextInt();
for (int i = 1; i <= n; i++) {
int x = sc.nextInt();
id.put(x, i);
pos.put(i, x);
}
long s = 0;
for (int i = 0; i < m; i++) {
int b = sc.nextInt();
int temp = id.get(b);
s += (temp - 1) / k + 1;
if (temp > 1) {
int y = pos.get(temp - 1);
id.put(b, temp - 1);
id.put(y, temp);
pos.put(temp - 1, b);
pos.put(temp, y);
}
}
pw.println(s);
}
static class FastReader {
StringTokenizer st;
BufferedReader br;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
public String next() throws IOException {
if (st == null || !st.hasMoreTokens()) {
st = new StringTokenizer(br.readLine());
}
return st.nextToken();
}
public boolean hasNext() throws IOException {
if (st != null && st.hasMoreTokens()) {
return true;
}
String s = br.readLine();
if (s == null || s.isEmpty()) {
return false;
}
st = new StringTokenizer(s);
return true;
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
}
}
|
Programmers working on a large project have just received a task to write exactly m lines of code. There are n programmers working on a project, the i-th of them makes exactly ai bugs in every line of code that he writes.
Let's call a sequence of non-negative integers v1, v2, ..., vn a plan, if v1 + v2 + ... + vn = m. The programmers follow the plan like that: in the beginning the first programmer writes the first v1 lines of the given task, then the second programmer writes v2 more lines of the given task, and so on. In the end, the last programmer writes the remaining lines of the code. Let's call a plan good, if all the written lines of the task contain at most b bugs in total.
Your task is to determine how many distinct good plans are there. As the number of plans can be large, print the remainder of this number modulo given positive integer mod.
Input
The first line contains four integers n, m, b, mod (1 ≤ n, m ≤ 500, 0 ≤ b ≤ 500; 1 ≤ mod ≤ 109 + 7) — the number of programmers, the number of lines of code in the task, the maximum total number of bugs respectively and the modulo you should use when printing the answer.
The next line contains n space-separated integers a1, a2, ..., an (0 ≤ ai ≤ 500) — the number of bugs per line for each programmer.
Output
Print a single integer — the answer to the problem modulo mod.
Examples
Input
3 3 3 100
1 1 1
Output
10
Input
3 6 5 1000000007
1 2 3
Output
0
Input
3 5 6 11
1 2 1
Output
0
|
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const long long MOD = 1e9 + 7, di = 998244353, N = 2e6 + 1;
bool IsQuery = false;
long long q = 1, a[N], n;
map<int, vector<int>> edge;
map<int, bool> occ;
bool odd, even;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
void solve() {
long long n, m, b, MOD, ans = 0;
cin >> n >> m >> b >> MOD;
for (int i = 0; i < n; i++) cin >> a[i];
long long dp[m + 1][b + 1];
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 0; i < n; i++) {
for (int k = 0; k < m; k++) {
for (int j = 0; j <= b; j++) {
if (dp[k][j] && j + a[i] <= b) {
dp[k + 1][j + a[i]] = (dp[k + 1][j + a[i]] + dp[k][j]) % MOD;
};
}
}
}
for (int i = 0; i <= b; i++) ans = (ans + dp[m][i]) % MOD;
cout << ans;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
if (IsQuery) cin >> q;
for (int i = 0; i < q; i++) {
solve();
cout << "\n";
}
return 0;
}
|
Peppa the Pig was walking and walked into the forest. What a strange coincidence! The forest has the shape of a rectangle, consisting of n rows and m columns. We enumerate the rows of the rectangle from top to bottom with numbers from 1 to n, and the columns — from left to right with numbers from 1 to m. Let's denote the cell at the intersection of the r-th row and the c-th column as (r, c).
Initially the pig stands in cell (1, 1), and in the end she wants to be in cell (n, m). Since the pig is in a hurry to get home, she can go from cell (r, c), only to either cell (r + 1, c) or (r, c + 1). She cannot leave the forest.
The forest, where the pig is, is very unusual. Some cells of the forest similar to each other, and some look very different. Peppa enjoys taking pictures and at every step she takes a picture of the cell where she is now. The path through the forest is considered to be beautiful if photographs taken on her way, can be viewed in both forward and in reverse order, showing the same sequence of photos. More formally, the line formed by the cells in order of visiting should be a palindrome (you can read a formal definition of a palindrome in the previous problem).
Count the number of beautiful paths from cell (1, 1) to cell (n, m). Since this number can be very large, determine the remainder after dividing it by 109 + 7.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the height and width of the field.
Each of the following n lines contains m lowercase English letters identifying the types of cells of the forest. Identical cells are represented by identical letters, different cells are represented by different letters.
Output
Print a single integer — the number of beautiful paths modulo 109 + 7.
Examples
Input
3 4
aaab
baaa
abba
Output
3
Note
Picture illustrating possibilities for the sample test.
<image>
<image>
<image>
|
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b, long long MOD) {
long long res = 1;
a %= MOD;
for (; b; b >>= 1) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
struct Point {
int x, y;
Point(int x, int y) {
this->x = x;
this->y = y;
}
void mov() { x--, y++; }
bool operator==(const Point &o) const { return x == o.x && y == o.y; }
};
int n, m;
const int N = 500 + 5;
char s[N][N];
int dp[2][N][N];
const int MOD = 1e9 + 7;
inline void addmod(int &a, int b) { a = (a + b) % MOD; }
void nxt1(Point &a) { a.x++; }
void nxt2(Point &a) { a.y--; }
bool eq(Point &a, Point &b) { return s[a.x][a.y] == s[b.x][b.y]; }
bool valid(Point &a) { return a.x >= 1 && a.x <= n && a.y >= 1 && a.y <= m; }
bool adj(Point &a, Point &b) {
return abs(a.x - b.x) <= 1 && abs(a.y - b.y) <= 1;
}
int main() {
scanf("%d%d", &n, &m);
getchar();
for (int i = 1; i <= n; i++) {
gets(s[i] + 1);
}
Point st1(1, 1), st2(n, m);
dp[0][1][1] = 1;
int cur = 1, pre = 0, ans = 0;
for (int l = 2, r = n + m; l <= r; l++, r--) {
Point a = st1, b = st2;
for (int i = 1; i < l; i++, a.mov()) {
if (!valid(a)) continue;
b = st2;
for (int j = 1; j < l; j++, b.mov()) {
if (!valid(b)) continue;
if (eq(a, b)) {
addmod(dp[cur][i][j], (0LL + dp[pre][i][j] + dp[pre][i - 1][j] +
dp[pre][i][j - 1] + dp[pre][i - 1][j - 1]) %
MOD);
if (l == r - 1 && adj(a, b)) {
addmod(ans, dp[cur][i][j]);
} else if (l == r && a == b) {
addmod(ans, dp[cur][i][j]);
}
}
}
}
nxt1(st1);
nxt2(st2);
memset(dp[pre], 0, sizeof dp[pre]);
swap(cur, pre);
}
printf("%d\n", ans);
return 0;
}
|
Vector Willman and Array Bolt are the two most famous athletes of Byteforces. They are going to compete in a race with a distance of L meters today.
<image>
Willman and Bolt have exactly the same speed, so when they compete the result is always a tie. That is a problem for the organizers because they want a winner.
While watching previous races the organizers have noticed that Willman can perform only steps of length equal to w meters, and Bolt can perform only steps of length equal to b meters. Organizers decided to slightly change the rules of the race. Now, at the end of the racetrack there will be an abyss, and the winner will be declared the athlete, who manages to run farther from the starting point of the the racetrack (which is not the subject to change by any of the athletes).
Note that none of the athletes can run infinitely far, as they both will at some moment of time face the point, such that only one step further will cause them to fall in the abyss. In other words, the athlete will not fall into the abyss if the total length of all his steps will be less or equal to the chosen distance L.
Since the organizers are very fair, the are going to set the length of the racetrack as an integer chosen randomly and uniformly in range from 1 to t (both are included). What is the probability that Willman and Bolt tie again today?
Input
The first line of the input contains three integers t, w and b (1 ≤ t, w, b ≤ 5·1018) — the maximum possible length of the racetrack, the length of Willman's steps and the length of Bolt's steps respectively.
Output
Print the answer to the problem as an irreducible fraction <image>. Follow the format of the samples output.
The fraction <image> (p and q are integers, and both p ≥ 0 and q > 0 holds) is called irreducible, if there is no such integer d > 1, that both p and q are divisible by d.
Examples
Input
10 3 2
Output
3/10
Input
7 1 2
Output
3/7
Note
In the first sample Willman and Bolt will tie in case 1, 6 or 7 are chosen as the length of the racetrack.
|
#include <bits/stdc++.h>
using namespace std;
long long t, a, b, k, mk, ans;
long long gcd(long long x, long long y) {
while (y) {
long long t = x;
x = y;
y = t % y;
}
return x;
}
int main() {
scanf("%I64d%I64d%I64d", &t, &a, &b);
k = gcd(a, b);
mk = 1000000000;
mk *= 5;
if (a / k / mk * (b / mk) > t / mk / mk + 10) {
ans = min(t, a - 1);
ans = min(ans, b - 1);
printf("%I64d/%I64d", ans / (gcd(ans, t)), t / (gcd(ans, t)));
} else {
ans = t / (a / k * b) * min(a, b) - 1;
ans += min(min(t % (a / k * b) + 1, a), b);
printf("%I64d/%I64d", ans / (gcd(ans, t)), t / (gcd(ans, t)));
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.