input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
You are given a rectangular matrix of size n × m consisting of integers from 1 to 2 ⋅ 10^5.
In one move, you can:
* choose any element of the matrix and change its value to any integer between 1 and n ⋅ m, inclusive;
* take any column and shift it one cell up cyclically (see the example of such cyclic shift below).
A cyclic shift is an operation such that you choose some j (1 ≤ j ≤ m) and set a_{1, j} := a_{2, j}, a_{2, j} := a_{3, j}, ..., a_{n, j} := a_{1, j} simultaneously.
<image> Example of cyclic shift of the first column
You want to perform the minimum number of moves to make this matrix look like this:
<image>
In other words, the goal is to obtain the matrix, where a_{1, 1} = 1, a_{1, 2} = 2, ..., a_{1, m} = m, a_{2, 1} = m + 1, a_{2, 2} = m + 2, ..., a_{n, m} = n ⋅ m (i.e. a_{i, j} = (i - 1) ⋅ m + j) with the minimum number of moves performed.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5, n ⋅ m ≤ 2 ⋅ 10^5) — the size of the matrix.
The next n lines contain m integers each. The number at the line i and position j is a_{i, j} (1 ≤ a_{i, j} ≤ 2 ⋅ 10^5).
Output
Print one integer — the minimum number of moves required to obtain the matrix, where a_{1, 1} = 1, a_{1, 2} = 2, ..., a_{1, m} = m, a_{2, 1} = m + 1, a_{2, 2} = m + 2, ..., a_{n, m} = n ⋅ m (a_{i, j} = (i - 1)m + j).
Examples
Input
3 3
3 2 1
1 2 3
4 5 6
Output
6
Input
4 3
1 2 3
4 5 6
7 8 9
10 11 12
Output
0
Input
3 4
1 6 3 4
5 10 7 8
9 2 11 12
Output
2
Note
In the first example, you can set a_{1, 1} := 7, a_{1, 2} := 8 and a_{1, 3} := 9 then shift the first, the second and the third columns cyclically, so the answer is 6. It can be shown that you cannot achieve a better answer.
In the second example, the matrix is already good so the answer is 0.
In the third example, it is enough to shift the second column cyclically twice to obtain a good matrix, so the answer is 2.
|
from collections import Counter
from sys import stdin
def input():
return(next(stdin))
def main():
n, m = map(int, input().split())
aaa = []
for _ in range(n):
aaa.append([int(a) for a in input().split()])
aaar = list(zip(*aaa))
t = m * n
cost = 0
for i,aa in enumerate(aaar, 1):
rot = Counter()
for j,a in enumerate(aa):
if a % m == i%m and aa[j] <= t:
rot[(j - (a-1)//m)%n] += 1
for j in range(n):
rot[j] -= j
best = rot.most_common(1)[0][1]
cost += n - max(best, 0)
print(cost)
if __name__ == "__main__":
main()
|
The biggest event of the year – Cota 2 world championship "The Innernational" is right around the corner. 2^n teams will compete in a double-elimination format (please, carefully read problem statement even if you know what is it) to identify the champion.
Teams are numbered from 1 to 2^n and will play games one-on-one. All teams start in the upper bracket.
All upper bracket matches will be held played between teams that haven't lost any games yet. Teams are split into games by team numbers. Game winner advances in the next round of upper bracket, losers drop into the lower bracket.
Lower bracket starts with 2^{n-1} teams that lost the first upper bracket game. Each lower bracket round consists of two games. In the first game of a round 2^k teams play a game with each other (teams are split into games by team numbers). 2^{k-1} loosing teams are eliminated from the championship, 2^{k-1} winning teams are playing 2^{k-1} teams that got eliminated in this round of upper bracket (again, teams are split into games by team numbers). As a result of each round both upper and lower bracket have 2^{k-1} teams remaining. See example notes for better understanding.
Single remaining team of upper bracket plays with single remaining team of lower bracket in grand-finals to identify championship winner.
You are a fan of teams with numbers a_1, a_2, ..., a_k. You want the championship to have as many games with your favourite teams as possible. Luckily, you can affect results of every championship game the way you want. What's maximal possible number of championship games that include teams you're fan of?
Input
First input line has two integers n, k — 2^n teams are competing in the championship. You are a fan of k teams (2 ≤ n ≤ 17; 0 ≤ k ≤ 2^n).
Second input line has k distinct integers a_1, …, a_k — numbers of teams you're a fan of (1 ≤ a_i ≤ 2^n).
Output
Output single integer — maximal possible number of championship games that include teams you're fan of.
Examples
Input
3 1
6
Output
6
Input
3 3
1 7 8
Output
11
Input
3 4
1 3 5 7
Output
14
Note
On the image, each game of the championship is denoted with an English letter (a to n). Winner of game i is denoted as Wi, loser is denoted as Li. Teams you're a fan of are highlighted with red background.
In the first example, team 6 will play in 6 games if it looses the first upper bracket game (game c) and wins all lower bracket games (games h, j, l, m).
<image>
In the second example, teams 7 and 8 have to play with each other in the first game of upper bracket (game d). Team 8 can win all remaining games in upper bracket, when teams 1 and 7 will compete in the lower bracket.
<image>
In the third example, your favourite teams can play in all games of the championship.
<image>
|
#include <bits/stdc++.h>
using namespace std;
int si();
long long sl();
string ss(int);
char sc();
float sf();
double sd();
long double sld();
template <typename T>
void print(T, char = '\n');
template <typename T, typename... Args>
void print(T, Args...);
void pi(const int&, char = '\n');
void pl(const long long&, char = '\n');
void pf(const float&, char = '\n');
void pc(const char&, char = '\n');
void pd(const double&, char = '\n');
void pld(const long double&, char = '\n');
void ps(const string&, char = '\n');
template <typename T>
void pv(const vector<T>& v, char = ' ', char = '\n');
template <typename It>
void out(It begin, It end, char = ' ', char = '\n');
long long russian(long long, long long, long long);
long long fastpow(long long, long long, long long);
long long slowpow(long long, long long, long long);
long long _gcd(long long, long long);
long long _lcm(long long, long long);
long long extgcd(long long, long long, long long&, long long&);
long long _inv(long long, long long);
const int INF = 1e9;
const long long LINF = 1e18;
const int N = (1 << 17) + 7;
bool A[N];
int DP[N][2][2];
int main() {
int n = (1 << si()), k = si();
while (k--) A[si() - 1] = true;
for (int i = 1; i < n; ++i)
for (int t1 = 0; t1 < 2; ++t1)
for (int t2 = 0; t2 < 2; ++t2) DP[i][t1][t2] = -INF;
for (int i = 0; i < n; i += 2) {
int t1 = A[i], t2 = A[i + 1];
int idx = (i + n) >> 1;
int val = t1 || t2 ? 1 : 0;
DP[idx][t1][t2] = DP[idx][t2][t1] = val;
}
for (int i = (n >> 1) - 1; i > 0; --i) {
int left = i << 1;
int right = left + 1;
for (int t1 = 0; t1 < 2; ++t1)
for (int t2 = 0; t2 < 2; ++t2) {
for (int l1 = 0; l1 < 2; ++l1)
for (int l2 = 0; l2 < 2; ++l2)
for (int r1 = 0; r1 < 2; ++r1)
for (int r2 = 0; r2 < 2; ++r2) {
if (t1 != l1 && t1 != r1) continue;
int valup = l1 || r1 ? 1 : 0;
int down = t1 == l1 ? r1 : l1;
if (t2 != down && t2 != l2 && t2 != r2) continue;
int valdown = r2 || l2 ? 1 : 0;
int valadd =
t2 == down ? (t2 || valdown ? 1 : 0) : (t2 || down ? 1 : 0);
DP[i][t1][t2] =
max(DP[i][t1][t2], DP[left][l1][l2] + DP[right][r1][r2] +
valup + valdown + valadd);
}
}
}
int res = 0;
for (int t1 = 0; t1 < 2; ++t1)
for (int t2 = 0; t2 < 2; ++t2)
res = max(res, DP[1][t1][t2] + (t1 || t2 ? 1 : 0));
pi(res);
return 0;
}
template <typename T>
T scanf_t(string&& token) {
T a;
scanf(token.c_str(), &a);
return a;
}
int si() { return scanf_t<int>("%d"); }
long long sl() { return scanf_t<long long>("%lld"); }
string ss(int n) {
char T[n + 7];
scanf("%s", T);
return string(T);
}
char sc() { return scanf_t<char>(" %c"); }
float sf() { return scanf_t<float>("%f"); }
double sd() { return scanf_t<double>("%lf"); }
long double sld() { return scanf_t<long double>("%Lf"); }
template <typename T>
void print(T a, char sep) {
string token;
if (is_same<T, int>::value)
token = "%d";
else if (is_same<T, long long>::value)
token = "%lld";
else if (is_same<T, string>::value)
token = "%s";
else if (is_same<T, char>::value)
token = "%c";
else if (is_same<T, float>::value)
token = "%.6f";
else if (is_same<T, double>::value)
token = "%.8lf";
else if (is_same<T, long double>::value)
token = "%.10Lf";
token.push_back(sep);
printf(token.c_str(), a);
}
template <typename T, typename... Args>
void print(T first, Args... rest) {
print(first, ' ');
print(rest...);
}
void pi(const int& a, char sep) { printf("%d%c", a, sep); }
void pl(const long long& a, char sep) { printf("%lld%c", a, sep); }
void pf(const float& a, char sep) { printf("%.6f%c", a, sep); }
void pc(const char& a, char sep) { printf("%c%c", a, sep); }
void pd(const double& a, char sep) { printf("%.8lf%c", a, sep); }
void pld(const long double& a, char sep) { printf("%.12Lf%c", a, sep); }
void ps(const string& a, char sep) { printf("%s%c", a.c_str(), sep); }
template <typename It>
void out(It begin, It end, char sep, char endl) {
if (begin == end) {
printf("%c", endl);
return;
}
while (begin + 1 != end) print(*begin, sep), ++begin;
if (begin != end) print(*begin, ' '), printf("%c", endl);
}
template <typename T>
void pv(const vector<T>& v, char sep, char endl) {
out(v.begin(), v.end(), sep, endl);
}
long long russian(long long a, long long k, long long m) {
long long res = 0;
while (k) {
if (k & 1LL) res = (res + a) % m;
a = (a + a) % m;
k >>= 1LL;
}
return res;
}
long long fastpow(long long a, long long k, long long m) {
long long res = 1;
while (k) {
if (k & 1LL) res = (res * a) % m;
a = (a * a) % m;
k >>= 1LL;
}
return res;
}
long long slowpow(long long a, long long k, long long m) {
long long res = 1;
while (k) {
if (k & 1LL) res = russian(res, a, m);
a = russian(a, a, m);
k >>= 1LL;
}
return res;
}
long long _gcd(long long a, long long b) {
while (b) swap(a %= b, b);
return a;
}
long long _lcm(long long a, long long b) { return a / _gcd(a, b) * b; }
long long extgcd(long long a, long long b, long long& k, long long& l) {
if (b == 0) {
k = 1;
l = 0;
return a;
}
long long res = extgcd(a, a % b, l, k);
l -= a / b * k;
return res;
}
long long _inv(long long a, long long p) { return fastpow(a, p - 2, p); }
|
Ichihime is the current priestess of the Mahjong Soul Temple. She claims to be human, despite her cat ears.
These days the temple is holding a math contest. Usually, Ichihime lacks interest in these things, but this time the prize for the winner is her favorite — cookies. Ichihime decides to attend the contest. Now she is solving the following problem.
<image>
You are given four positive integers a, b, c, d, such that a ≤ b ≤ c ≤ d.
Your task is to find three integers x, y, z, satisfying the following conditions:
* a ≤ x ≤ b.
* b ≤ y ≤ c.
* c ≤ z ≤ d.
* There exists a triangle with a positive non-zero area and the lengths of its three sides are x, y, and z.
Ichihime desires to get the cookie, but the problem seems too hard for her. Can you help her?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines describe test cases. Each test case is given as four space-separated integers a, b, c, d (1 ≤ a ≤ b ≤ c ≤ d ≤ 10^9).
Output
For each test case, print three integers x, y, z — the integers you found satisfying the conditions given in the statement.
It is guaranteed that the answer always exists. If there are multiple answers, print any.
Example
Input
4
1 3 5 7
1 5 5 7
100000 200000 300000 400000
1 1 977539810 977539810
Output
3 4 5
5 5 5
182690 214748 300999
1 977539810 977539810
Note
One of the possible solutions to the first test case:
<image>
One of the possible solutions to the second test case:
<image>
|
"""
Author : thekushalghosh
Team : CodeDiggers
"""
import sys,math,cmath,time
start_time = time.time()
################# ---- USER DEFINED INPUT FUNCTIONS ---- #################
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(s[:len(s) - 1])
def invr():
return(map(int,input().split()))
##########################################################################
################# ---- THE ACTUAL CODE STARTS BELOW ---- #################
def solve():
a,b,c,d = invr()
print(b,c,c)
################## ---- THE ACTUAL CODE ENDS ABOVE ---- ##################
##########################################################################
ONLINE_JUDGE = __debug__
if not ONLINE_JUDGE:
sys.stdin = open('input.txt','r')
sys.stdout = open('output.txt','w')
else:
input = sys.stdin.readline
t = 1
t = inp()
for tt in range(t):
solve()
if not ONLINE_JUDGE:
print("Time Elapsed:",time.time() - start_time,"seconds")
sys.stdout.close()
|
We define x mod y as the remainder of division of x by y (\% operator in C++ or Java, mod operator in Pascal).
Let's call an array of positive integers [a_1, a_2, ..., a_k] stable if for every permutation p of integers from 1 to k, and for every non-negative integer x, the following condition is met:
(((x mod a_1) mod a_2) ... mod a_{k - 1}) mod a_k = (((x mod a_{p_1}) mod a_{p_2}) ... mod a_{p_{k - 1}}) mod a_{p_k}
That is, for each non-negative integer x, the value of (((x mod a_1) mod a_2) ... mod a_{k - 1}) mod a_k does not change if we reorder the elements of the array a.
For two given integers n and k, calculate the number of stable arrays [a_1, a_2, ..., a_k] such that 1 ≤ a_1 < a_2 < ... < a_k ≤ n.
Input
The only line contains two integers n and k (1 ≤ n, k ≤ 5 ⋅ 10^5).
Output
Print one integer — the number of stable arrays [a_1, a_2, ..., a_k] such that 1 ≤ a_1 < a_2 < ... < a_k ≤ n. Since the answer may be large, print it modulo 998244353.
Examples
Input
7 3
Output
16
Input
3 7
Output
0
Input
1337 42
Output
95147305
Input
1 1
Output
1
Input
500000 1
Output
500000
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 998244353;
int t, n, k;
long long st(long long a, long long b) {
if (b == 0)
return 1;
else if (b % 2 == 0) {
long long aa = (a * a) % M;
return (st(aa, b / 2) % M);
} else {
return ((a * st(a, b - 1)) % M);
}
}
int main() {
vector<long long> f = vector<long long>(500005);
f[0] = 1;
f[1] = 1;
for (int i = 2; i < 500005; i++) {
f[i] = i * f[i - 1];
f[i] %= M;
}
cin >> n >> k;
k--;
long long ans = 0;
for (int i = 1; i <= n; i++) {
int N = n / i;
N--;
if (N >= k) ans += (f[N] * st(((f[k] * f[N - k]) % M), M - 2));
ans %= M;
}
cout << ans << "\n";
}
|
Note that the difference between easy and hard versions is that in hard version unavailable cells can become available again and in easy version can't. You can make hacks only if all versions are solved.
Ildar and Ivan are tired of chess, but they really like the chessboard, so they invented a new game. The field is a chessboard 2n × 2m: it has 2n rows, 2m columns, and the cell in row i and column j is colored white if i+j is even, and is colored black otherwise.
The game proceeds as follows: Ildar marks some of the white cells of the chessboard as unavailable, and asks Ivan to place n × m kings on the remaining white cells in such way, so that there are no kings attacking each other. A king can attack another king if they are located in the adjacent cells, sharing an edge or a corner.
Ildar would like to explore different combinations of cells. Initially all cells are marked as available, and then he has q queries. In each query he either marks a cell as unavailable, or marks the previously unavailable cell as available. After each query he would like to know whether it is possible to place the kings on the available cells in a desired way. Please help him!
Input
The first line of input contains three integers n, m, q (1 ≤ n, m, q ≤ 200 000) — the size of the board and the number of queries.
q lines follow, each of them contains a description of a query: two integers i and j, denoting a white cell on the board (1 ≤ i ≤ 2n, 1 ≤ j ≤ 2m, i + j is even). If the cell (i, j) was available before the query, then it becomes unavailable. Otherwise, if the cell was unavailable, it becomes available.
Output
Output q lines, i-th line should contain answer for a board after i queries of Ildar. This line should contain "YES" if it is possible to place the kings on the available cells in the desired way, or "NO" otherwise.
Examples
Input
1 3 3
1 1
1 5
2 4
Output
YES
YES
NO
Input
3 2 10
4 2
6 4
1 3
4 2
6 4
2 2
2 4
1 3
4 4
3 1
Output
YES
YES
NO
NO
YES
YES
NO
YES
YES
NO
Note
In the first example case after the second query only cells (1, 1) and (1, 5) are unavailable. Then Ivan can place three kings on cells (2, 2), (2, 4) and (2, 6).
After the third query three cells (1, 1), (1, 5) and (2, 4) are unavailable, so there remain only 3 available cells: (2, 2), (1, 3) and (2, 6). Ivan can not put 3 kings on those cells, because kings on cells (2, 2) and (1, 3) attack each other, since these cells share a corner.
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Set;
import java.io.IOException;
import java.util.Random;
import java.io.InputStreamReader;
import java.util.TreeSet;
import java.util.TreeMap;
import java.util.StringTokenizer;
import java.util.Map;
import java.io.BufferedReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
F2ChessStrikesBackHardVersion solver = new F2ChessStrikesBackHardVersion();
solver.solve(1, in, out);
out.close();
}
static class F2ChessStrikesBackHardVersion {
private static final String NO = "NO";
private static final String YES = "YES";
public void solve(int testNumber, InputReader in, PrintWriter out) {
in.nextInt(); // unused, N
in.nextInt(); // unused, M
int queries = in.nextInt();
Pii[] q = new Pii[queries];
for (int i = 0; i < queries; i++) {
q[i] = Pii.of(in.nextInt() - 1, in.nextInt() - 1);
}
Map<Integer, Integer> xCoord = coordinatesMap(q);
final int X = xCoord.size();
IntMinSegmentTree forward = new IntMinSegmentTree(X);
IntMaxSegmentTree backward = new IntMaxSegmentTree(X);
TreeSet<Integer>[] fY = new TreeSet[X];
TreeSet<Integer>[] bY = new TreeSet[X];
for (int x = 0; x < X; x++) {
fY[x] = new TreeSet<>();
fY[x].add(Integer.MAX_VALUE);
bY[x] = new TreeSet<>();
bY[x].add(Integer.MIN_VALUE);
}
Set<Integer> bad = new TreeSet<>();
for (int i = 0; i < queries; i++) {
Pii p = q[i];
boolean isForward = forward(p);
int x = xCoord.get(p.first);
TreeSet<Integer> y = isForward ? fY[x] : bY[x];
boolean remove = y.contains(p.second);
if (remove) {
y.remove(p.second);
} else {
y.add(p.second);
}
if (isForward)
forward.update(x, y.first());
else
backward.update(x, y.last());
if (!remove) {
if (isForward && p.second < backward.query(x, X)) {
bad.add(x);
}
if (!isForward && forward.query(0, x + 1) < p.second) {
bad.add(x);
}
} else {
Iterator<Integer> it = bad.iterator();
while (it.hasNext()) {
int j = it.next();
int l = forward.query(0, j + 1);
int r = backward.query(j, X);
if (l < r)
break;
it.remove();
}
}
boolean valid = bad.isEmpty();
out.println(valid ? YES : NO);
}
}
private static Map<Integer, Integer> coordinatesMap(Pii[] q) {
int[] coordinateArray = new int[q.length];
for (int i = 0; i < q.length; i++) {
coordinateArray[i] = q[i].first;
}
Util.safeSort(coordinateArray);
TreeMap<Integer, Integer> coordinates = new TreeMap<>();
for (int i = 0, j = 0; i < coordinateArray.length; i++) {
if (coordinates.containsKey(coordinateArray[i]))
continue;
coordinates.put(coordinateArray[i], j++);
}
return coordinates;
}
private static boolean forward(Pii a) {
return a.first % 2 == 0;
}
}
static class Pii implements Comparable<Pii> {
public final int first;
public final int second;
public Pii(int first, int second) {
this.first = first;
this.second = second;
}
public static Pii of(int first, int second) {
return new Pii(first, second);
}
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Pii pair = (Pii) o;
return first == pair.first && second == pair.second;
}
public int hashCode() {
return Arrays.hashCode(new int[]{first, second});
}
public String toString() {
return "(" + first + ", " + second + ')';
}
public int compareTo(Pii o) {
if (first != o.first)
return Integer.compare(first, o.first);
return Integer.compare(second, o.second);
}
}
static class IntMinSegmentTree {
public final int size;
public final int[] value;
protected final int identityElement;
public IntMinSegmentTree(int size) {
this.size = size;
value = new int[2 * size];
this.identityElement = Integer.MAX_VALUE;
Arrays.fill(value, identityElement);
}
public void update(int i, int v) {
i += size;
value[i] = v;
while (i > 1) {
i /= 2;
value[i] = Math.min(value[2 * i], value[2 * i + 1]);
}
}
public int query(int i, int j) {
int res_left = identityElement, res_right = identityElement;
for (i += size, j += size; i < j; i /= 2, j /= 2) {
if ((i & 1) == 1) {
res_left = Math.min(res_left, value[i++]);
}
if ((j & 1) == 1) {
res_right = Math.min(value[--j], res_right);
}
}
return Math.min(res_left, res_right);
}
}
static class IntMaxSegmentTree {
public final int size;
public final int[] value;
protected final int identityElement;
public IntMaxSegmentTree(int size) {
this.size = size;
value = new int[2 * size];
this.identityElement = Integer.MIN_VALUE;
Arrays.fill(value, identityElement);
}
public void update(int i, int v) {
i += size;
value[i] = v;
while (i > 1) {
i /= 2;
value[i] = Math.max(value[2 * i], value[2 * i + 1]);
}
}
public int query(int i, int j) {
int res_left = identityElement, res_right = identityElement;
for (i += size, j += size; i < j; i /= 2, j /= 2) {
if ((i & 1) == 1) {
res_left = Math.max(res_left, value[i++]);
}
if ((j & 1) == 1) {
res_right = Math.max(value[--j], res_right);
}
}
return Math.max(res_left, res_right);
}
}
static class InputReader {
public final 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());
}
}
static class Util {
public static void safeSort(int[] x) {
shuffle(x);
Arrays.sort(x);
}
public static void shuffle(int[] x) {
Random r = new Random();
for (int i = 0; i <= x.length - 2; i++) {
int j = i + r.nextInt(x.length - i);
swap(x, i, j);
}
}
public static void swap(int[] x, int i, int j) {
int t = x[i];
x[i] = x[j];
x[j] = t;
}
private Util() {
}
}
}
|
One day Natalia was walking in the woods when she met a little mushroom gnome. The gnome told her the following story:
Everybody knows that the mushroom gnomes' power lies in the magic mushrooms that grow in the native woods of the gnomes. There are n trees and m magic mushrooms in the woods: the i-th tree grows at a point on a straight line with coordinates ai and has the height of hi, the j-th mushroom grows at the point with coordinates bj and has magical powers zj.
But one day wild mushroommunchers, the sworn enemies of mushroom gnomes unleashed a terrible storm on their home forest. As a result, some of the trees began to fall and crush the magic mushrooms. The supreme oracle of mushroom gnomes calculated in advance the probability for each tree that it will fall to the left, to the right or will stand on. If the tree with the coordinate x and height h falls to the left, then all the mushrooms that belong to the right-open interval [x - h, x), are destroyed. If a tree falls to the right, then the mushrooms that belong to the left-open interval (x, x + h] are destroyed. Only those mushrooms that are not hit by a single tree survive.
Knowing that all the trees fall independently of each other (i.e., all the events are mutually independent, and besides, the trees do not interfere with other trees falling in an arbitrary direction), the supreme oracle was also able to quickly calculate what would be the expectation of the total power of the mushrooms which survived after the storm. His calculations ultimately saved the mushroom gnomes from imminent death.
Natalia, as a good Olympiad programmer, got interested in this story, and she decided to come up with a way to quickly calculate the expectation of the sum of the surviving mushrooms' power.
Input
The first line contains two integers n and m (1 ≤ n ≤ 105, 1 ≤ m ≤ 104) — the number of trees and mushrooms, respectively.
Each of the next n lines contain four integers — ai, hi, li, ri (|ai| ≤ 109, 1 ≤ hi ≤ 109, 0 ≤ li, ri, li + ri ≤ 100) which represent the coordinate of the i-th tree, its height, the percentage of the probabilities that the tree falls to the left and to the right, respectively (the remaining percentage is the probability that the tree will stand on).
Each of next m lines contain two integers bj, zj (|bj| ≤ 109, 1 ≤ zj ≤ 103) which represent the coordinate and the magical power of the j-th mushroom, respectively.
An arbitrary number of trees and mushrooms can grow in one point.
Output
Print a real number — the expectation of the total magical power of the surviving mushrooms. The result is accepted with relative or absolute accuracy 10 - 4.
Examples
Input
1 1
2 2 50 50
1 1
Output
0.5000000000
Input
2 1
2 2 50 50
4 2 50 50
3 1
Output
0.2500000000
Note
It is believed that the mushroom with the coordinate x belongs to the right-open interval [l, r) if and only if l ≤ x < r. Similarly, the mushroom with the coordinate x belongs to the left-open interval (l, r] if and only if l < x ≤ r.
In the first test the mushroom survives with the probability of 50%, depending on where the single tree falls.
In the second test the mushroom survives only if neither of the two trees falls on it. It occurs with the probability of 50% × 50% = 25%.
Pretest №12 is the large test with 105 trees and one mushroom.
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int x[100005 * 4 + 10005], num[100005 * 4 + 10005], cnt;
double p[100005 * 4 + 10005];
struct Tree {
int w, l, r, h;
} data[100005];
struct Mushroom {
int w, z;
} mush[10005];
int find(int w) {
int g = 0, h = cnt - 1;
while (g <= h) {
int mid = (g + h) / 2;
if (x[mid] == w)
return mid;
else if (x[mid] < w)
g = mid + 1;
else
h = mid - 1;
}
while (1)
;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d%d%d%d", &data[i].w, &data[i].h, &data[i].l, &data[i].r);
x[cnt++] = data[i].w + 1;
x[cnt++] = data[i].w;
x[cnt++] = data[i].w - data[i].h;
x[cnt++] = data[i].w + data[i].h + 1;
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &mush[i].w, &mush[i].z);
x[cnt++] = mush[i].w;
}
sort(x, x + cnt);
int k = cnt;
cnt = 1;
for (int i = 1; i < k; i++)
if (x[i] != x[cnt - 1]) x[cnt++] = x[i];
for (int i = 0; i < n; i++) {
if (data[i].l != 100) {
p[find(data[i].w - data[i].h)] += log((100.0 - data[i].l) / 100);
p[find(data[i].w)] -= log((100.0 - data[i].l) / 100);
} else {
num[find(data[i].w - data[i].h)]++;
num[find(data[i].w)]--;
}
if (data[i].r != 100) {
p[find(data[i].w + 1)] += log((100.0 - data[i].r) / 100);
p[find(data[i].w + data[i].h + 1)] -= log((100.0 - data[i].r) / 100);
} else {
num[find(data[i].w + 1)]++;
num[find(data[i].w + data[i].h + 1)]--;
}
}
for (int i = 1; i < cnt; i++) p[i] += p[i - 1];
for (int i = 1; i < cnt; i++) num[i] += num[i - 1];
double ans = 0;
for (int i = 0; i < m; i++) {
if (num[find(mush[i].w)] == 0) ans += exp(p[find(mush[i].w)]) * mush[i].z;
}
printf("%.7f\n", ans);
return 0;
}
|
John has Q closed intervals of consecutive 2K-bit numbers [l_i, r_i] and one 16-bit value v_i for each interval. (0 ≤ i < Q)
John wants to implement a function F that maps 2K-bit numbers to 16-bit numbers in such a way that inputs from each interval are mapped to that interval's value. In other words: $$$F(x) = v_i, \; for every 0 ≤ i < Q \; , and every x ∈ [l_i, r_i]$$$ The output of F for other inputs is unimportant.
John wants to make his implementation of F fast so he has decided to use lookup tables. A single 2K-bit lookup table would be too large to fit in memory, so instead John plans to use two K-bit lookup tables, LSBTable and MSBTable. His implementation will look like this: $$$ F(x) = LSBTable[lowKBits(x)] \; \& \; MSBTable[highKBits(x)]$$$ In other words it returns the "bitwise and" of results of looking up the K least significant bits in LSBTable and the K most significant bits in MSBTable.
John needs your help. Given K, Q and Q intervals [l_i, r_i] and values v_i, find any two lookup tables which can implement F or report that such tables don't exist.
Input
The first line contains two integers K and Q ( 1 <= K <= 16, 1 <= Q <= 2⋅ 10^5).
Each of the next Q lines contains three integers l_i, r_i and v_i. ( 0 ≤ l_i ≤ r_i < 2^{2K}, 0 ≤ v_i < 2^{16}).
Output
On the first line output "possible" (without quotes) if two tables satisfying the conditions exist, or "impossible" (without quotes) if they don't exist.
If a solution exists, in the next 2 ⋅ 2^K lines your program should output all values of the two lookup tables (LSBTable and MSBTable) it found. When there are multiple pairs of tables satisfying the conditions, your program may output any such pair.
On lines 1 + i output LSBTable[i]. (0 ≤ i < 2^K, 0 ≤ LSBTable[i] < 2^{16}).
On lines 1 + 2^K + i output MSBTable[i]. (0 ≤ i < 2^K, 0 ≤ MSBTable[i] < 2^{16}).
Examples
Input
1 2
0 2 1
3 3 3
Output
possible
1
3
1
3
Input
2 4
4 5 3
6 7 2
0 3 0
12 13 1
Output
possible
3
3
2
2
0
3
0
1
Input
2 3
4 4 3
5 6 2
12 14 1
Output
impossible
Note
A closed interval [a, b] includes both a and b.
In the first sample, tables LSBTable = [1,3] and MSBTable = [1,3] satisfy the conditions: F[0] = LSBTable[0] \& MSBTable[0] = 1 \& 1 = 1, F[1] = LSBTable[1] \& MSBTable[0] = 3 \& 1 = 1, F[2] = LSBTable[0] \& MSBTable[1] = 1 \& 3 = 1, F[3] = LSBTable[1] \& MSBTable[1] = 3 \& 3 = 3.
In the second sample, tables LSBTable = [3,3,2,2] and MSBTable = [0,3,0,1] satisfy all the conditions.
In the third sample there are no two lookup tables which can satisfy the conditions.
|
#include <bits/stdc++.h>
using namespace std;
const int MAXQ = 2e5;
vector<int> solve(int K, vector<tuple<uint32_t, uint32_t, int> > V) {
uint32_t mask = (((uint32_t)1) << K) - 1;
vector<int> HT(1 << K), LT(1 << K);
for (auto [l, r, v] : V)
if (v) {
uint32_t lhi = l >> K, llo = l & mask;
uint32_t rhi = r >> K, rlo = r & mask;
if (lhi == rhi) {
LT[llo]++;
if (rlo != ((1 << K) - 1)) LT[rlo + 1]--;
} else {
LT[llo]++;
LT[0]++;
if (rlo != ((1 << K) - 1)) LT[rlo + 1]--;
}
HT[lhi]++;
if (rhi != ((1 << K) - 1)) HT[rhi + 1]--;
}
for (int i = 0; i < (1 << K) - 1; ++i) HT[i + 1] += HT[i];
for (int i = 0; i < (1 << K); ++i)
if (HT[i]) HT[i] = 1;
for (int i = 0; i < (1 << K) - 1; ++i) LT[i + 1] += LT[i];
for (int i = 0; i < (1 << K); ++i)
if (LT[i]) LT[i] = 1;
auto ans = LT;
copy(HT.begin(), HT.end(), back_inserter(ans));
for (int i = 0; i < (1 << K) - 1; ++i) HT[i + 1] += HT[i];
for (int i = 0; i < (1 << K) - 1; ++i) LT[i + 1] += LT[i];
auto SH = [&](int L, int R) {
int ans = HT[R];
if (L) ans -= HT[L - 1];
return ans;
};
auto SL = [&](int L, int R) {
int ans = LT[R];
if (L) ans -= LT[L - 1];
return ans;
};
for (auto [l, r, v] : V)
if (!v) {
uint32_t lhi = l >> K, llo = l & mask;
uint32_t rhi = r >> K, rlo = r & mask;
if (lhi == rhi) {
if (SH(lhi, lhi) != 0 && SL(llo, rlo) != 0) return {};
} else {
if (SH(lhi, lhi) != 0 && SL(llo, (1 << K) - 1) != 0) return {};
if (SH(lhi + 1, rhi - 1) != 0 && SL(0, (1 << K) - 1) != 0) return {};
if (SH(rhi, rhi) != 0 && SL(0, rlo) != 0) return {};
}
}
return ans;
}
int K, Q;
uint32_t L[MAXQ], R[MAXQ], V[MAXQ];
int main() {
scanf("%d%d", &K, &Q);
for (int i = 0; i < Q; ++i) {
scanf("%" SCNu32 "%" SCNu32 "%" SCNu32, L + i, R + i, V + i);
}
vector<vector<int> > ans(16);
for (int i = 0; i < 16; ++i) {
vector<tuple<uint32_t, uint32_t, int> > P;
for (int j = 0; j < Q; ++j) P.emplace_back(L[j], R[j], (V[j] >> i) & 1);
ans[i] = solve(K, P);
if (ans[i].size() == 0) {
puts("impossible");
return 0;
}
}
puts("possible");
for (int i = 0; i < (2 << K); ++i) {
int r = 0;
for (int j = 0; j < 16; ++j)
if (ans[j][i]) r |= 1 << j;
printf("%d\n", r);
}
return 0;
}
|
Bertown is a city with n buildings in a straight line.
The city's security service discovered that some buildings were mined. A map was compiled, which is a string of length n, where the i-th character is "1" if there is a mine under the building number i and "0" otherwise.
Bertown's best sapper knows how to activate mines so that the buildings above them are not damaged. When a mine under the building numbered x is activated, it explodes and activates two adjacent mines under the buildings numbered x-1 and x+1 (if there were no mines under the building, then nothing happens). Thus, it is enough to activate any one mine on a continuous segment of mines to activate all the mines of this segment. For manual activation of one mine, the sapper takes a coins. He can repeat this operation as many times as you want.
Also, a sapper can place a mine under a building if it wasn't there. For such an operation, he takes b coins. He can also repeat this operation as many times as you want.
The sapper can carry out operations in any order.
You want to blow up all the mines in the city to make it safe. Find the minimum number of coins that the sapper will have to pay so that after his actions there are no mines left in the city.
Input
The first line contains one positive integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then t test cases follow.
Each test case begins with a line containing two integers a and b (1 ≤ a, b ≤ 1000) — the cost of activating and placing one mine, respectively.
The next line contains a map of mines in the city — a string consisting of zeros and ones.
The sum of the string lengths for all test cases does not exceed 10^5.
Output
For each test case, output one integer — the minimum number of coins that the sapper will have to pay.
Example
Input
2
1 1
01000010
5 1
01101110
Output
2
6
Note
In the second test case, if we place a mine under the fourth building and then activate it, then all mines on the field are activated. The cost of such operations is six, b=1 coin for placing a mine and a=5 coins for activating.
|
# ========== //\\ //|| ||====//||
# || // \\ || || // ||
# || //====\\ || || // ||
# || // \\ || || // ||
# ========== // \\ ======== ||//====||
# code
def solve():
a,b = map(int, input().split())
s = str(input())
n = len(s)
comp = []
score = 0
if '1' not in s:
print(0)
return
j = 0
while s[j] == '0':
j += 1
while j < n and s[j] == '1':
j += 1
score += a
while j < n:
i = j
while j < n and s[j] == '0':
j += 1
comp.append(j - i)
i = j
while j < n and s[j] == '1':
j += 1
if j != i:
score += a
if s[-1] == '0':
comp.pop()
comp.sort()
for i in comp:
newscore = score - a + i * b
score = min(score, newscore)
print(score)
def main():
t = 1
t = int(input())
for _ in range(t):
solve()
if __name__ == "__main__":
main()
|
There is a robot on a checkered field that is endless in all directions. Initially, the robot is located in the cell with coordinates (0, 0). He will execute commands which are described by a string of capital Latin letters 'L', 'R', 'D', 'U'. When a command is executed, the robot simply moves in the corresponding direction:
* 'L': one cell to the left (the x-coordinate of the current cell decreases by 1);
* 'R': one cell to the right (the x-coordinate of the current cell is increased by 1);
* 'D': one cell down (the y-coordinate of the current cell decreases by 1);
* 'U': one cell up (the y-coordinate of the current cell is increased by 1).
Your task is to put an obstacle in one cell of the field so that after executing the commands, the robot will return to the original cell of its path (0, 0). Of course, an obstacle cannot be placed in the starting cell (0, 0). It is guaranteed that if the obstacle is not placed, then the robot will not return to the starting cell.
An obstacle affects the movement of the robot in the following way: if it tries to go in a certain direction, and there is an obstacle, then it simply remains in place (the obstacle also remains, that is, it does not disappear).
Find any such cell of the field (other than (0, 0)) that if you put an obstacle there, the robot will return to the cell (0, 0) after the execution of all commands. If there is no solution, then report it.
Input
The first line contains one integer t (1 ≤ t ≤ 500) — the number of test cases.
Each test case consists of a single line containing s — the sequence of commands, which are uppercase Latin letters 'L', 'R', 'D', 'U' only. The length of s is between 1 and 5000, inclusive. Additional constraint on s: executing this sequence of commands leads the robot to some cell other than (0, 0), if there are no obstacles.
The sum of lengths of all s in a test doesn't exceed 5000.
Output
For each test case print a single line:
* if there is a solution, print two integers x and y (-10^9 ≤ x,y ≤ 10^9) such that an obstacle in (x, y) will force the robot to return back to the cell (0, 0);
* otherwise, print two zeroes (i. e. 0 0).
If there are multiple answers, you can print any of them.
Example
Input
4
L
RUUDL
LLUU
DDDUUUUU
Output
-1 0
1 2
0 0
0 1
|
///Astalavista Code........~CodeSlayer007
#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define Br cout<<endl
#define int long long
#define fe first
#define se second
#define double long double
#define all(v) v.begin(),v.end()
#define allr(v) v.rbegin(),v.rend()
#define PT(x) cout << (x) << endl
#define last(x) prev(x.end())
#define PP(x) cout << (x) << " "
#define PS(x) for(auto it: x)cout << it <<" "; cout << endl;
#define PTT(x) cout << (#x) << " is " << (x) << endl
#define lets_go ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef vector<ii> vii;
void PV(vi v) { for (int i = 0 ; i < v.size() ; i++) cout << v[i] << " " ; cout << endl;}
void PVV(vii v) {for (int i = 0 ; i < v.size() ; i++) cout << v[i].first << " " << v[i].second << endl;}
void PA(int v[], int n, int x = 0) { for (int i = x ; i < n + x; i++)cout << v[i] << ' ' ; cout << endl;}
void IN(int a[], int n, int x = 0) {for (int i = x; i < n + x; i++)cin >> a[i];}
inline void op() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
// <=================================================================================================================================
// <=================================================================================================================================
const int M = 1e9 + 7;
const int IM = 1e18 + 37;
const int N = 300 + 10;
signed main() {
lets_go
op();
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
// PT(s);
int x = 0, y = 0;
int n = s.size();
ii p = {0, 0};
for (int i = 0; i < n; i++) {
char cc = s[i];
if (cc == 'L')
x--;
if (cc == 'R')
x++;
if (cc == 'U')
y++;
if (cc == 'D')
y--;
if(x == 0 && y == 0)
continue ;
int px = 0, py = 0;
int id = 0;
for ( ; id < n; id++) {
char c = s[id];
if (c == 'L')
px--;
if (c == 'R')
px++;
if (c == 'U')
py++;
if (c == 'D')
py--;
if (px == x && py == y) { // vapis jao
if (c == 'L')
px++;
if (c == 'R')
px--;
if (c == 'U')
py--;
if (c == 'D')
py++;
}
}
if (px == 0 && py == 0) {
p = {x, y};
}
}
cout << p.fe << " " << p.se << endl;
}
return 0;
}
|
You are given two integers l and r in binary representation. Let g(x, y) be equal to the [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of all integers from x to y inclusive (that is x ⊕ (x+1) ⊕ ... ⊕ (y-1) ⊕ y). Let's define f(l, r) as the maximum of all values of g(x, y) satisfying l ≤ x ≤ y ≤ r.
Output f(l, r).
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the binary representation of r.
The second line contains the binary representation of l — a string of length n consisting of digits 0 and 1 (0 ≤ l < 2^n).
The third line contains the binary representation of r — a string of length n consisting of digits 0 and 1 (0 ≤ r < 2^n).
It is guaranteed that l ≤ r. The binary representation of r does not contain any extra leading zeros (if r=0, the binary representation of it consists of a single zero). The binary representation of l is preceded with leading zeros so that its length is equal to n.
Output
In a single line output the value of f(l, r) for the given pair of l and r in binary representation without extra leading zeros.
Examples
Input
7
0010011
1111010
Output
1111111
Input
4
1010
1101
Output
1101
Note
In sample test case l=19, r=122. f(x,y) is maximal and is equal to 127, with x=27, y=100, for example.
|
i=int;p=input
N=i(p());L=p();R=p()
l=i(L,2);r=i(R,2);a=R
if l-l%2<r:a=R[:-1]+'1'
if i(L[-1])and l+1==r:a=R
if L==R:a=L
if L[0]<R[0]:a='1'*N
print(a)
|
Baby Ehab is known for his love for a certain operation. He has an array a of length n, and he decided to keep doing the following operation on it:
* he picks 2 adjacent elements; he then removes them and places a single integer in their place: their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR). Note that the length of the array decreases by one.
Now he asks you if he can make all elements of the array equal. Since babies like to make your life harder, he requires that you leave at least 2 elements remaining.
Input
The first line contains an integer t (1 ≤ t ≤ 15) — the number of test cases you need to solve.
The first line of each test case contains an integers n (2 ≤ n ≤ 2000) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (0 ≤ a_i < 2^{30}) — the elements of the array a.
Output
If Baby Ehab can make all elements equal while leaving at least 2 elements standing, print "YES". Otherwise, print "NO".
Example
Input
2
3
0 2 2
4
2 3 1 10
Output
YES
NO
Note
In the first sample, he can remove the first 2 elements, 0 and 2, and replace them by 0 ⊕ 2=2. The array will be [2,2], so all the elements are equal.
In the second sample, there's no way to make all the elements equal.
|
import java.lang.*;
import java.util.*;
import java.io.*;
public class Main {
static FastScanner in = new FastScanner();
static void solve() {
int n = in.nextInt();
int[] pre = new int[n];
int val = 0;
for (int i = 0; i < n; ++i) {
int x = in.nextInt();
pre[i] = (i == 0 ? 0 : pre[i - 1]) ^ x;
}
boolean good = (pre[n - 1] == 0);
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
good = good | (pre[i] == (pre[j] ^ pre[i]) && pre[i] == (pre[n - 1] ^ pre[j]));
}
}
System.out.println(good ? "YES" : "NO");
}
public static void main(String[] args) {
int T = in.nextInt();
while (T-- > 0)
solve();
}
static class Pair<X, Y> {
X x;
Y y;
public Pair(X x, Y y) {
this.x = x;
this.y = y;
}
}
}
class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
|
After defeating a Blacklist Rival, you get a chance to draw 1 reward slip out of x hidden valid slips. Initially, x=3 and these hidden valid slips are Cash Slip, Impound Strike Release Marker and Pink Slip of Rival's Car. Initially, the probability of drawing these in a random guess are c, m, and p, respectively. There is also a volatility factor v. You can play any number of Rival Races as long as you don't draw a Pink Slip. Assume that you win each race and get a chance to draw a reward slip. In each draw, you draw one of the x valid items with their respective probabilities. Suppose you draw a particular item and its probability of drawing before the draw was a. Then,
* If the item was a Pink Slip, the quest is over, and you will not play any more races.
* Otherwise,
1. If a≤ v, the probability of the item drawn becomes 0 and the item is no longer a valid item for all the further draws, reducing x by 1. Moreover, the reduced probability a is distributed equally among the other remaining valid items.
2. If a > v, the probability of the item drawn reduces by v and the reduced probability is distributed equally among the other valid items.
For example,
* If (c,m,p)=(0.2,0.1,0.7) and v=0.1, after drawing Cash, the new probabilities will be (0.1,0.15,0.75).
* If (c,m,p)=(0.1,0.2,0.7) and v=0.2, after drawing Cash, the new probabilities will be (Invalid,0.25,0.75).
* If (c,m,p)=(0.2,Invalid,0.8) and v=0.1, after drawing Cash, the new probabilities will be (0.1,Invalid,0.9).
* If (c,m,p)=(0.1,Invalid,0.9) and v=0.2, after drawing Cash, the new probabilities will be (Invalid,Invalid,1.0).
You need the cars of Rivals. So, you need to find the expected number of races that you must play in order to draw a pink slip.
Input
The first line of input contains a single integer t (1≤ t≤ 10) — the number of test cases.
The first and the only line of each test case contains four real numbers c, m, p and v (0 < c,m,p < 1, c+m+p=1, 0.1≤ v≤ 0.9).
Additionally, it is guaranteed that each of c, m, p and v have at most 4 decimal places.
Output
For each test case, output a single line containing a single real number — the expected number of races that you must play in order to draw a Pink Slip.
Your answer is considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \frac{|a - b|}{max{(1, |b|)}} ≤ 10^{-6}.
Example
Input
4
0.2 0.2 0.6 0.2
0.4 0.2 0.4 0.8
0.4998 0.4998 0.0004 0.1666
0.3125 0.6561 0.0314 0.2048
Output
1.532000000000
1.860000000000
5.005050776521
4.260163673896
Note
For the first test case, the possible drawing sequences are:
* P with a probability of 0.6;
* CP with a probability of 0.2⋅ 0.7 = 0.14;
* CMP with a probability of 0.2⋅ 0.3⋅ 0.9 = 0.054;
* CMMP with a probability of 0.2⋅ 0.3⋅ 0.1⋅ 1 = 0.006;
* MP with a probability of 0.2⋅ 0.7 = 0.14;
* MCP with a probability of 0.2⋅ 0.3⋅ 0.9 = 0.054;
* MCCP with a probability of 0.2⋅ 0.3⋅ 0.1⋅ 1 = 0.006.
So, the expected number of races is equal to 1⋅ 0.6 + 2⋅ 0.14 + 3⋅ 0.054 + 4⋅ 0.006 + 2⋅ 0.14 + 3⋅ 0.054 + 4⋅ 0.006 = 1.532.
For the second test case, the possible drawing sequences are:
* P with a probability of 0.4;
* CP with a probability of 0.4⋅ 0.6 = 0.24;
* CMP with a probability of 0.4⋅ 0.4⋅ 1 = 0.16;
* MP with a probability of 0.2⋅ 0.5 = 0.1;
* MCP with a probability of 0.2⋅ 0.5⋅ 1 = 0.1.
So, the expected number of races is equal to 1⋅ 0.4 + 2⋅ 0.24 + 3⋅ 0.16 + 2⋅ 0.1 + 3⋅ 0.1 = 1.86.
|
a = 0
def dp(c, m, p, v, h, ans):
global a
a += h*p*ans
if (c > 1e-6):
if (m < 1e-6):
dp(c-min(c, v), 0, p+min(c, v), v, h+1, ans*c)
else:
dp(c-min(c, v), m+min(c, v)/2.0, p+min(c, v)/2.0, v, h+1, ans*c)
if (m > 1e-6):
if (c < 1e-6):
dp(0, m-min(m, v), p+min(m, v), v, h+1, ans*m)
else:
dp(c+min(m, v)/2.0, m-min(m, v), p+min(m, v)/2.0, v, h+1, ans*m)
for _ in range(int(input())):
c, m, p, v = map(float, input().split())
dp(c, m, p, v, 1.0, 1.0)
print("%.12f" % round(a, 12))
a = 0
|
"This problem is rubbish! There is not statement, and there are only 5 test cases. The problemsetter took liberties with this problem!" — people complained in the comments to one round on Codeforces. And even more... No, wait, the checker for the problem was alright, that's a mercy.
Input
The only line of the input contains an integer between 1 and 5, inclusive. All tests for this problem are different. The contents of the test case doesn't need to be equal to its index.
Output
The only line of the output contains an integer between 1 and 3, inclusive.
Examples
Note
This problem has no samples, since there so few test cases.
|
#include <bits/stdc++.h>
inline int getInt() {
int s;
scanf("%d", &s);
return s;
}
using namespace std;
int main() {
int ans[5] = {2, 3, 1, 2, 1};
int n = getInt();
printf("%d\n", ans[n - 1]);
return 0;
}
|
In the capital city of Berland, Bertown, demonstrations are against the recent election of the King of Berland. Berland opposition, led by Mr. Ovalny, believes that the elections were not fair enough and wants to organize a demonstration at one of the squares.
Bertown has n squares, numbered from 1 to n, they are numbered in the order of increasing distance between them and the city center. That is, square number 1 is central, and square number n is the farthest from the center. Naturally, the opposition wants to hold a meeting as close to the city center as possible (that is, they want an square with the minimum number).
There are exactly k (k < n) days left before the demonstration. Now all squares are free. But the Bertown city administration never sleeps, and the approval of an application for the demonstration threatens to become a very complex process. The process of approval lasts several days, but every day the following procedure takes place:
* The opposition shall apply to hold a demonstration at a free square (the one which isn't used by the administration).
* The administration tries to move the demonstration to the worst free square left. To do this, the administration organizes some long-term activities on the square, which is specified in the application of opposition. In other words, the administration starts using the square and it is no longer free. Then the administration proposes to move the opposition demonstration to the worst free square. If the opposition has applied for the worst free square then request is accepted and administration doesn't spend money. If the administration does not have enough money to organize an event on the square in question, the opposition's application is accepted. If administration doesn't have enough money to organize activity, then rest of administration's money spends and application is accepted
* If the application is not accepted, then the opposition can agree to the administration's proposal (that is, take the worst free square), or withdraw the current application and submit another one the next day. If there are no more days left before the meeting, the opposition has no choice but to agree to the proposal of City Hall. If application is accepted opposition can reject it. It means than opposition still can submit more applications later, but square remains free.
In order to organize an event on the square i, the administration needs to spend ai bourles. Because of the crisis the administration has only b bourles to confront the opposition. What is the best square that the opposition can take, if the administration will keep trying to occupy the square in question each time? Note that the administration's actions always depend only on the actions of the opposition.
Input
The first line contains two integers n and k — the number of squares and days left before the meeting, correspondingly (1 ≤ k < n ≤ 105).
The second line contains a single integer b — the number of bourles the administration has (1 ≤ b ≤ 1018).
The third line contains n space-separated integers ai — the sum of money, needed to organise an event on square i (1 ≤ ai ≤ 109).
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.
Output
Print a single number — the minimum number of the square where the opposition can organize the demonstration.
Examples
Input
5 2
8
2 4 5 3 1
Output
2
Input
5 2
8
3 2 4 1 5
Output
5
Input
5 4
1000000000000000
5 4 3 2 1
Output
5
Note
In the first sample the opposition can act like this. On day one it applies for square 3. The administration has to organize an event there and end up with 3 bourles. If on the second day the opposition applies for square 2, the administration won't have the money to intervene.
In the second sample the opposition has only the chance for the last square. If its first move occupies one of the first four squares, the administration is left with at least 4 bourles, which means that next day it can use its next move to move the opposition from any square to the last one.
In the third sample administration has a lot of money, so opposition can occupy only last square.
|
#include <bits/stdc++.h>
using namespace std;
class myistream {
static const int maxsize = 1000007, tmpsize = 50;
char *s, *tmp;
char *cur, *upperbound;
FILE *fp;
bool last_read;
bool end_of_file;
bool to_return;
void upd() {
int num = fread(s, sizeof(char), maxsize, fp);
if (num < maxsize) last_read = true, upperbound = s + num;
if (!num) end_of_file = true;
cur = s;
}
char scan() {
if (cur >= upperbound) {
if (last_read)
end_of_file = true;
else
upd();
}
return *cur++;
}
bool isspace(char c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t';
}
public:
myistream(FILE *_fp)
: last_read(false), end_of_file(false), to_return(false), fp(_fp) {
s = new char[maxsize + 2];
tmp = new char[tmpsize + 2];
upperbound = s + maxsize;
cur = s + maxsize;
}
~myistream() {
delete[] s;
delete[] tmp;
fclose(fp);
}
operator void *() const { return to_return ? 0 : (void *)this; }
bool operator!() const { return to_return; }
myistream &operator>>(int &a) {
if (!end_of_file) {
char c = scan();
while (isspace(c) && !end_of_file) c = scan();
if (end_of_file) {
to_return = true;
return *this;
}
a = 0;
bool nega = false;
if (c == '-') nega = true, c = scan();
while (!isspace(c) && !end_of_file) {
a = a * 10 + (((int)c) & 15);
c = scan();
}
if (nega) a = -a;
} else
to_return = true;
return *this;
}
myistream &operator>>(long long &a) {
if (!end_of_file) {
char c = scan();
while (isspace(c) && !end_of_file) c = scan();
if (end_of_file) {
to_return = true;
return *this;
}
a = 0;
bool nega = false;
if (c == '-') nega = true, c = scan();
while (!isspace(c) && !end_of_file) {
a = a * 10 + (((long long)c) & 15);
c = scan();
}
if (nega) a = -a;
} else
to_return = true;
return *this;
}
myistream &operator>>(char &c) {
if (!end_of_file) {
c = scan();
while (isspace(c) && !end_of_file) c = scan();
}
if (end_of_file) to_return = true;
return *this;
}
myistream &operator>>(bool &b) {
if (!end_of_file) {
char c = scan();
while (isspace(c) && !end_of_file) c = scan();
b = (c == '1');
}
if (end_of_file) to_return = true;
return *this;
}
myistream &operator>>(char *s) {
if (!end_of_file) {
char c = scan();
while (isspace(c) && !end_of_file) c = scan();
if (end_of_file) {
to_return = true;
return *this;
}
while (!isspace(c) && !end_of_file) *s++ = c, c = scan();
*s = '\0';
} else
to_return = true;
return *this;
}
myistream &operator>>(string &s) {
s.clear();
if (!end_of_file) {
char c = scan();
while (isspace(c) && !end_of_file) c = scan();
if (end_of_file) {
to_return = true;
return *this;
}
while (!isspace(c) && !end_of_file) s.push_back(c), c = scan();
} else
to_return = true;
return *this;
}
myistream &operator>>(double &d) {
if (!end_of_file) {
char *tp = tmp;
char c = scan();
while (isspace(c) && !end_of_file) c = scan();
if (end_of_file) {
to_return = true;
return *this;
}
while (!isspace(c) && !end_of_file) *tp++ = c, c = scan();
*tp = '\0';
sscanf(tmp, "%lf", &d);
} else
to_return = true;
return *this;
}
};
class myostreamEndlType {};
class myostreamSetPrecisionType {
public:
int precision;
myostreamSetPrecisionType(int _precision) : precision(_precision) {}
};
class myostream {
static const int maxsize = 1000007, tmpsize = 50;
char *s, *upperbound, *cur, *tmp;
FILE *fp;
int numberAfterPoint;
char doubleFormat[20];
void write(char c) {
if (cur >= upperbound) {
fwrite(s, sizeof(char), maxsize, fp);
cur = s;
}
*cur++ = c;
}
public:
myostream(FILE *_fp) : fp(_fp) {
s = new char[maxsize];
tmp = new char[tmpsize + 2];
upperbound = s + maxsize;
cur = s;
precision(6);
}
~myostream() {
fwrite(s, sizeof(char), cur - s, fp);
fclose(fp);
delete[] s;
}
void precision(int x) {
numberAfterPoint = x;
sprintf(doubleFormat, "%%.%dlf", x);
}
int precision(void) { return numberAfterPoint; }
myostream &operator<<(const myostreamSetPrecisionType &p) {
precision(p.precision);
return *this;
}
myostream &operator<<(const char &c) {
write(c);
return *this;
}
myostream &operator<<(const myostreamEndlType &e) {
write('\n');
return *this;
}
myostream &operator<<(const bool &b) {
write(b ? '1' : '0');
return *this;
}
myostream &operator<<(const char *c) {
for (const char *p = c; *p; p++) write(*p);
return *this;
}
myostream &operator<<(const string &c) { return *this << c.c_str(); }
myostream &operator<<(const size_t &a) { return *this << int(a); }
myostream &operator<<(const int &a) {
if (a == 0) {
write('0');
return *this;
}
int s = a;
if (s < 0) write('-'), s = -s;
char *tp = tmp;
while (s > 0) {
*tp++ = char((s % 10) | 48);
s /= 10;
}
for (--tp; tp >= tmp; --tp) write(*tp);
return *this;
}
myostream &operator<<(const long long &a) {
if (a == 0) {
write('0');
return *this;
}
long long s = a;
if (s < 0) write('-'), s = -s;
char *tp = tmp;
while (s > 0) {
*tp++ = char((s % 10) | 48);
s /= 10;
}
for (--tp; tp >= tmp; --tp) write(*tp);
return *this;
}
myostream &operator<<(const double &d) {
sprintf(tmp, doubleFormat, d);
*this << tmp;
return *this;
}
};
template <class T1, class T2>
struct ReadArrayType {
T1 *toread1;
T2 *toread2;
int count;
int *save;
ReadArrayType(T1 *_toread1, T2 *_toread2, int _count, int *_save)
: toread1(_toread1), toread2(_toread2), count(_count), save(_save) {}
};
template <class T>
ReadArrayType<T, int> RA(int &save, T *toread) {
return ReadArrayType<T, int>(toread, NULL, -1, &save);
}
template <class T>
ReadArrayType<T, int> RA(T *toread, int count = -1) {
return ReadArrayType<T, int>(toread, NULL, count, NULL);
}
template <class T1, class T2>
ReadArrayType<T1, T2> RA(int &save, T1 *toread1, T2 *toread2) {
return ReadArrayType<T1, T2>(toread1, toread2, -1, &save);
}
template <class T1, class T2>
ReadArrayType<T1, T2> RA(T1 *toread1, T2 *toread2, int count = -1) {
return ReadArrayType<T1, T2>(toread1, toread2, count, NULL);
}
template <class T1, class T2>
istream &operator>>(istream &in, const ReadArrayType<T1, T2> &r) {
int count = r.count;
if (count == -1) in >> count;
if (r.toread2 == NULL)
for (int i = 0; i < (count); ++i) in >> r.toread1[i];
else
for (int i = 0; i < (count); ++i) in >> r.toread1[i] >> r.toread2[i];
if (r.save != NULL) *r.save = count;
return in;
}
template <class T1, class T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
in >> p.first >> p.second;
return in;
}
template <class T>
istream &operator>>(istream &in, vector<T> &v) {
int sz;
in >> sz;
v.resize(sz);
for (int i = 0; i < (sz); ++i) cin >> v[i];
return in;
}
template <class T1, class T2>
myistream &operator>>(myistream &in, const ReadArrayType<T1, T2> &r) {
int count = r.count;
if (count == -1) in >> count;
if (r.toread2 == NULL)
for (int i = 0; i < (count); ++i) in >> r.toread1[i];
else
for (int i = 0; i < (count); ++i) in >> r.toread1[i] >> r.toread2[i];
if (r.save != NULL) *r.save = count;
return in;
}
template <class T1, class T2>
myistream &operator>>(myistream &in, pair<T1, T2> &p) {
in >> p.first >> p.second;
return in;
}
template <class T>
myistream &operator>>(myistream &in, vector<T> &v) {
int sz;
in >> sz;
v.resize(sz);
for (int i = 0; i < (sz); ++i) cin >> v[i];
return in;
}
template <class T>
struct ReadVectorType {
vector<T> &vec;
int count;
ReadVectorType(vector<T> &_vec, int _count) : vec(_vec), count(_count) {}
};
template <class T>
ReadVectorType<T> RV(vector<T> &vec, int count) {
return ReadVectorType<T>(vec, count);
}
template <class T>
istream &operator>>(istream &in, const ReadVectorType<T> &r) {
r.vec.resize(r.count);
for (int i = 0; i < (r.count); ++i) in >> r.vec[i];
return in;
}
template <class T>
myistream &operator>>(myistream &in, const ReadVectorType<T> &r) {
r.vec.resize(r.count);
for (int i = 0; i < (r.count); ++i) in >> r.vec[i];
return in;
}
myostreamEndlType myendl;
myistream mycin(stdin);
myostream mycout(stdout);
const int maxn = 100050;
int n, k;
long long b;
pair<int, int> a[maxn];
int bb[maxn];
bool used[maxn];
bool judge(int x) {
int maxV = 0, toGet = -1;
for (int i = 0; i < (x + 1); ++i)
if (maxV < bb[i]) maxV = bb[toGet = i];
long long sum = maxV;
int c = k - 1, i = 0;
while (c > 0) {
if (a[i].second == toGet) {
++i;
continue;
}
sum += a[i].first;
++i;
--c;
}
return sum > b;
}
int main(void) {
mycin >> n >> k >> b;
for (int i = 0; i < (n); ++i)
mycin >> a[i].first, a[i].second = i, bb[i] = a[i].first;
sort(a, a + n - 1, greater<pair<int, int> >());
int left = 0, right = n - 1;
while (left < right) {
int mid = (left + right) >> 1;
if (judge(mid))
right = mid;
else
left = mid + 1;
}
mycout << left + 1 << myendl;
}
|
The World Programming Olympics Medal is a metal disk, consisting of two parts: the first part is a ring with outer radius of r1 cm, inner radius of r2 cm, (0 < r2 < r1) made of metal with density p1 g/cm3. The second part is an inner disk with radius r2 cm, it is made of metal with density p2 g/cm3. The disk is nested inside the ring.
The Olympic jury decided that r1 will take one of possible values of x1, x2, ..., xn. It is up to jury to decide which particular value r1 will take. Similarly, the Olympic jury decided that p1 will take one of possible value of y1, y2, ..., ym, and p2 will take a value from list z1, z2, ..., zk.
According to most ancient traditions the ratio between the outer ring mass mout and the inner disk mass min must equal <image>, where A, B are constants taken from ancient books. Now, to start making medals, the jury needs to take values for r1, p1, p2 and calculate the suitable value of r2.
The jury wants to choose the value that would maximize radius r2. Help the jury find the sought value of r2. Value r2 doesn't have to be an integer.
Medal has a uniform thickness throughout the area, the thickness of the inner disk is the same as the thickness of the outer ring.
Input
The first input line contains an integer n and a sequence of integers x1, x2, ..., xn. The second input line contains an integer m and a sequence of integers y1, y2, ..., ym. The third input line contains an integer k and a sequence of integers z1, z2, ..., zk. The last line contains two integers A and B.
All numbers given in the input are positive and do not exceed 5000. Each of the three sequences contains distinct numbers. The numbers in the lines are separated by spaces.
Output
Print a single real number — the sought value r2 with absolute or relative error of at most 10 - 6. It is guaranteed that the solution that meets the problem requirements exists.
Examples
Input
3 1 2 3
1 2
3 3 2 1
1 2
Output
2.683281573000
Input
4 2 3 6 4
2 1 2
3 10 6 8
2 1
Output
2.267786838055
Note
In the first sample the jury should choose the following values: r1 = 3, p1 = 2, p2 = 1.
|
from math import sqrt
f = lambda: list(map(int, input().split()))
r1 = max(f()[1:])
p1s = f()[1:]
p2 = min(f()[1:])
a, b = f()
print(str(sqrt(max(b * p1 * r1**2 / float(a * p2 + b * p1) for p1 in p1s))))
|
There is a programming language in which every program is a non-empty sequence of "<" and ">" signs and digits. Let's explain how the interpreter of this programming language works. A program is interpreted using movement of instruction pointer (IP) which consists of two parts.
* Current character pointer (CP);
* Direction pointer (DP) which can point left or right;
Initially CP points to the leftmost character of the sequence and DP points to the right.
We repeat the following steps until the first moment that CP points to somewhere outside the sequence.
* If CP is pointing to a digit the interpreter prints that digit then CP moves one step according to the direction of DP. After that the value of the printed digit in the sequence decreases by one. If the printed digit was 0 then it cannot be decreased therefore it's erased from the sequence and the length of the sequence decreases by one.
* If CP is pointing to "<" or ">" then the direction of DP changes to "left" or "right" correspondingly. Then CP moves one step according to DP. If the new character that CP is pointing to is "<" or ">" then the previous character will be erased from the sequence.
If at any moment the CP goes outside of the sequence the execution is terminated.
It's obvious the every program in this language terminates after some steps.
We have a sequence s1, s2, ..., sn of "<", ">" and digits. You should answer q queries. Each query gives you l and r and asks how many of each digit will be printed if we run the sequence sl, sl + 1, ..., sr as an independent program in this language.
Input
The first line of input contains two integers n and q (1 ≤ n, q ≤ 100) — represents the length of the sequence s and the number of queries.
The second line contains s, a sequence of "<", ">" and digits (0..9) written from left to right. Note, that the characters of s are not separated with spaces.
The next q lines each contains two integers li and ri (1 ≤ li ≤ ri ≤ n) — the i-th query.
Output
For each query print 10 space separated integers: x0, x1, ..., x9 where xi equals the number of times the interpreter prints i while running the corresponding program. Print answers to the queries in the order they are given in input.
Examples
Input
7 4
1>3>22<
1 3
4 7
7 7
1 7
Output
0 1 0 1 0 0 0 0 0 0
2 2 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
2 3 2 1 0 0 0 0 0 0
|
import java.util.*;
import java.io.*;
import java.lang.*;
import static java.lang.System.*;
public class P239b{
static char[] code;
static int[] cnt;
static boolean[] removed;
static void simulate(int l, int r){
int cp = l;
int dp = 0;
char[] tmp = new char[code.length];
for(int i=0; i<code.length; i++) tmp[i] = code[i];
removed = new boolean[tmp.length];
while(cp>=l && cp<=r){
// out.printf("curr: %c\n", tmp[cp]);
if(Character.isDigit(tmp[cp])){
cnt[tmp[cp]-'0']++;
if(tmp[cp]>'0'){
tmp[cp]--;
}else{
removed[cp] = true;
}
if(dp==0){
cp++;
for(;cp<=r && removed[cp]; cp++);
}else{
cp--;
for(;cp>=l && removed[cp]; cp--);
}
}else if(tmp[cp]=='>'){
dp = 0;
int old = cp;
for(cp=cp+1; cp<=r && removed[cp]; cp++);
if(cp>r) break;
if(tmp[cp]=='>' || tmp[cp]=='<'){
removed[old] = true;
}
}else if(tmp[cp]=='<'){
dp = 1;
int old = cp;
for(cp=cp-1; cp>=l && removed[cp]; cp--);
if(cp<l) break;
if(tmp[cp]=='>' || tmp[cp]=='<'){
removed[old] = true;
}
}
}
}
public static void main(String[] args)throws Exception{
BufferedReader br = new BufferedReader(new InputStreamReader(in));
PrintStream ps = new PrintStream(new BufferedOutputStream(out));
Scanner sc = new Scanner(in);
while(sc.hasNext()){
int m = sc.nextInt();
int n = sc.nextInt();
code = sc.next().toCharArray();
for(int i=0; i<n; i++){
int l = sc.nextInt()-1;
int r = sc.nextInt()-1;
cnt = new int[10];
simulate(l, r);
for(int j=0; j<10; j++){
out.print(cnt[j]);
if(j!=9)out.print(" ");
}
out.println();
}
}
ps.flush();
}
}
|
You've got a table of size n × m. On the intersection of the i-th row (1 ≤ i ≤ n) and the j-th column (1 ≤ j ≤ m) there is a non-negative integer ai, j. Besides, you've got a non-negative integer k.
Your task is to find such pair of integers (a, b) that meets these conditions:
* k ≤ a ≤ n - k + 1;
* k ≤ b ≤ m - k + 1;
* let's denote the maximum of the function <image> among all integers x and y, that satisfy the inequalities k ≤ x ≤ n - k + 1 and k ≤ y ≤ m - k + 1, as mval; for the required pair of numbers the following equation must hold f(a, b) = mval.
Input
The first line contains three space-separated integers n, m and k (1 ≤ n, m ≤ 1000, <image>). Next n lines each contains m integers: the j-th number on the i-th line equals ai, j (0 ≤ ai, j ≤ 106).
The numbers in the lines are separated by spaces.
Output
Print the required pair of integers a and b. Separate the numbers by a space.
If there are multiple correct answers, you are allowed to print any of them.
Examples
Input
4 4 2
1 2 3 4
1 1 1 1
2 2 2 2
4 3 2 1
Output
3 2
Input
5 7 3
8 2 3 4 2 3 3
3 4 6 2 3 4 6
8 7 6 8 4 5 7
1 2 3 2 1 3 2
4 5 3 2 1 2 1
Output
3 3
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1010;
int n, m, k;
struct matrix {
int n, m;
long long a[MaxN][MaxN];
long long sy[MaxN][MaxN];
long long ty[MaxN][MaxN];
long long sv[MaxN * 2][MaxN];
long long tv[MaxN][MaxN];
long long st[MaxN][MaxN];
void set(int _n, int _m) {
n = _n;
m = _m;
}
long long getsy(int y, int L, int R) {
long long p = sy[R][y];
if (L >= 2) p -= sy[L - 1][y];
return p;
}
long long getsv(int p, int L, int R) {
if (p <= 1 || p > n + m) return 0;
long long s = sv[p][min(R, n)];
if (L >= 2) s -= sv[p][L - 1];
return s;
}
void init() {
for (int j = 1; j <= m; ++j)
for (int i = 1; i <= n; ++i) sy[i][j] = sy[i - 1][j] + a[i][j];
for (int j = 1; j <= m; ++j)
for (int i = 1; i <= n; ++i)
ty[i][j] = ty[i - 1][j] + (k + 1) * a[i][j] - getsy(j, i - k, i);
for (int p = 2; p <= n + m; ++p)
for (int i = 1; i <= n; ++i) {
sv[p][i] = sv[p][i - 1];
if (p - i >= 1 && p - i <= m) sv[p][i] += a[i][p - i];
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
tv[i][j] = tv[i][j - 1] + getsy(j, i - k + 1, i) -
getsv(i + j - k, i - k + 1, i);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
st[i][j] = st[i][j - 1] + ty[i][j] - tv[i][j - 1];
}
long long calc(int i, int j) { return st[i][j] - ty[i][j]; }
} T1, T2, T3, T4;
void init() {
cin >> n >> m >> k;
T1.set(n, m);
T2.set(m, n);
T3.set(n, m);
T4.set(m, n);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
int x;
scanf("%d", &x);
T1.a[i][j] = T2.a[m - j + 1][i] = T3.a[n - i + 1][m - j + 1] =
T4.a[j][n - i + 1] = x;
}
T1.init();
T2.init();
T3.init();
T4.init();
}
void work() {
long long ans = -1;
int a = k, b = k;
for (int i = k; i <= n - k + 1; ++i)
for (int j = k; j <= m - k + 1; ++j) {
long long p = T1.calc(i, j) + T2.calc(m - j + 1, i) +
T3.calc(n - i + 1, m - j + 1) + T4.calc(j, n - i + 1) +
k * T1.a[i][j];
if (p > ans) {
ans = p;
a = i;
b = j;
}
}
cout << a << " " << b << endl;
}
int main() {
init();
work();
return 0;
}
|
As you know, Vova has recently become a new shaman in the city of Ultima Thule. So, he has received the shaman knowledge about the correct bracket sequences. The shamans of Ultima Thule have been using lots of different types of brackets since prehistoric times. A bracket type is a positive integer. The shamans define a correct bracket sequence as follows:
* An empty sequence is a correct bracket sequence.
* If {a1, a2, ..., al} and {b1, b2, ..., bk} are correct bracket sequences, then sequence {a1, a2, ..., al, b1, b2, ..., bk} (their concatenation) also is a correct bracket sequence.
* If {a1, a2, ..., al} — is a correct bracket sequence, then sequence <image> also is a correct bracket sequence, where v (v > 0) is an integer.
For example, sequences {1, 1, - 1, 2, - 2, - 1} and {3, - 3} are correct bracket sequences, and {2, - 3} is not.
Moreover, after Vova became a shaman, he learned the most important correct bracket sequence {x1, x2, ..., xn}, consisting of n integers. As sequence x is the most important, Vova decided to encrypt it just in case.
Encrypting consists of two sequences. The first sequence {p1, p2, ..., pn} contains types of brackets, that is, pi = |xi| (1 ≤ i ≤ n). The second sequence {q1, q2, ..., qt} contains t integers — some positions (possibly, not all of them), which had negative numbers in sequence {x1, x2, ..., xn}.
Unfortunately, Vova forgot the main sequence. But he was lucky enough to keep the encryption: sequences {p1, p2, ..., pn} and {q1, q2, ..., qt}. Help Vova restore sequence x by the encryption. If there are multiple sequences that correspond to the encryption, restore any of them. If there are no such sequences, you should tell so.
Input
The first line of the input contains integer n (1 ≤ n ≤ 106). The second line contains n integers: p1, p2, ..., pn (1 ≤ pi ≤ 109).
The third line contains integer t (0 ≤ t ≤ n), followed by t distinct integers q1, q2, ..., qt (1 ≤ qi ≤ n).
The numbers in each line are separated by spaces.
Output
Print a single string "NO" (without the quotes) if Vova is mistaken and a suitable sequence {x1, x2, ..., xn} doesn't exist.
Otherwise, in the first line print "YES" (without the quotes) and in the second line print n integers x1, x2, ..., xn (|xi| = pi; xqj < 0). If there are multiple sequences that correspond to the encrypting, you are allowed to print any of them.
Examples
Input
2
1 1
0
Output
YES
1 -1
Input
4
1 1 1 1
1 3
Output
YES
1 1 -1 -1
Input
3
1 1 1
0
Output
NO
Input
4
1 2 2 1
2 3 4
Output
YES
1 2 -2 -1
|
#include <bits/stdc++.h>
using namespace std;
int a[1000100], c[1000100];
int main() {
int i, j, k, n, m, t;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
scanf("%d", &t);
for (i = 1; i <= t; i++) {
scanf("%d", &k);
a[k] = -fabs(a[k]);
}
m = 0;
for (i = n; i >= 1; i--) {
if (m > 0 && a[c[m]] <= 0 && a[i] == -a[c[m]]) {
m--;
} else if (m > 0 && a[c[m]] >= 0 && a[i] == a[c[m]]) {
a[c[m]] *= -1;
m--;
} else {
m++;
c[m] = i;
}
}
if (m != 0)
cout << "NO" << endl;
else {
cout << "YES" << endl;
cout << a[1];
for (i = 2; i <= n; i++) printf(" %d", a[i]);
}
return 0;
}
|
Rainbow built h cells in a row that are numbered from 1 to h from left to right. There are n cells with treasure. We call each of these n cells "Treasure Cell". The i-th "Treasure Cell" is the ai-th cell and the value of treasure in it is ci dollars.
Then, Freda went in the first cell. For now, she can go just k cells forward, or return to the first cell. That means Freda was able to reach the 1st, (k + 1)-th, (2·k + 1)-th, (3·k + 1)-th cells and so on.
Then Rainbow gave Freda m operations. Each operation is one of the following three types:
1. Add another method x: she can also go just x cells forward at any moment. For example, initially she has only one method k. If at some moment she has methods a1, a2, ..., ar then she can reach all the cells with number in form <image>, where vi — some non-negative integer.
2. Reduce the value of the treasure in the x-th "Treasure Cell" by y dollars. In other words, to apply assignment cx = cx - y.
3. Ask the value of the most valuable treasure among the cells Freda can reach. If Freda cannot reach any cell with the treasure then consider the value of the most valuable treasure equal to 0, and do nothing. Otherwise take the most valuable treasure away. If several "Treasure Cells" have the most valuable treasure, take the "Treasure Cell" with the minimum number (not necessarily with the minimum number of cell). After that the total number of cells with a treasure is decreased by one.
As a programmer, you are asked by Freda to write a program to answer each query.
Input
The first line of the input contains four integers: h (1 ≤ h ≤ 1018), n, m (1 ≤ n, m ≤ 105) and k (1 ≤ k ≤ 104).
Each of the next n lines contains two integers: ai (1 ≤ ai ≤ h), ci (1 ≤ ci ≤ 109). That means the i-th "Treasure Cell" is the ai-th cell and cost of the treasure in that cell is ci dollars. All the ai are distinct.
Each of the next m lines is in one of the three following formats:
* "1 x" — an operation of type 1, 1 ≤ x ≤ h;
* "2 x y" — an operation of type 2, 1 ≤ x ≤ n, 0 ≤ y < cx;
* "3" — an operation of type 3.
There are at most 20 operations of type 1. It's guaranteed that at any moment treasure in each cell has positive value. It's guaranteed that all operations is correct (no operation can decrease the value of the taken tresure).
Please, do not use the %lld specifier to read 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
For each operation of type 3, output an integer indicates the value (in dollars) of the most valuable treasure among the "Treasure Cells" Freda can reach. If there is no such treasure, output 0.
Examples
Input
10 3 5 2
5 50
7 60
8 100
2 2 5
3
1 3
3
3
Output
55
100
50
Note
In the sample, there are 10 cells and 3 "Treasure Cells". The first "Treasure Cell" is cell 5, having 50 dollars tresure in it. The second "Treasure Cell" is cell 7, having 60 dollars tresure in it. The third "Treasure Cell" is cell 8, having 100 dollars tresure in it.
At first, Freda can only reach cell 1, 3, 5, 7 and 9. In the first operation, we reduce the value in the second "Treasure Cell" from 60 to 55. Then the most valuable treasure among the "Treasure Cells" she can reach is max(50, 55) = 55. After the third operation, she can also go 3 cells forward each step, being able to reach cell 1, 3, 4, 5, 6, 7, 8, 9, 10. So the most valuable tresure is 100.
Noticed that she took the 55 dollars and 100 dollars treasure away, so the last answer is 50.
|
#include <bits/stdc++.h>
using namespace std;
struct record {
long long x, y;
bool operator<(const record &b) const { return x == b.x ? y > b.y : x < b.x; }
record() {}
record(long long _x, long long _y) {
x = _x;
y = _y;
}
};
vector<long long> p[10010];
long long a[100010];
long long c[100010];
long long d[10010];
priority_queue<record> q;
long long newk[100010];
long long cnt = 0;
long long h, n, m, k;
bool cmp(long long i, long long j) { return a[i] < a[j]; }
void spfa() {
queue<long long> bfs;
bool flag[10010];
for (long long i = 0; i < k; i++)
if (d[i] < 1e18 + 100) {
bfs.push(i);
flag[i] = true;
} else
flag[i] = false;
while (!bfs.empty()) {
long long now = bfs.front();
bfs.pop();
flag[now] = false;
for (long long i = 0; i < cnt; i++) {
long long next = d[now] + newk[i];
long long y = next % k;
if (next < d[y]) {
d[y] = next;
if (!flag[y]) {
bfs.push(y);
flag[y] = true;
}
}
}
}
for (long long i = 0; i < k; i++)
while (p[i].size() > 0 && a[p[i][p[i].size() - 1]] >= d[i]) {
q.push(record(c[p[i][p[i].size() - 1]], p[i][p[i].size() - 1]));
p[i].pop_back();
}
}
int main() {
cin >> h >> n >> m >> k;
for (long long i = 0; i < n; i++) {
cin >> a[i] >> c[i];
a[i]--;
p[a[i] % k].push_back(i);
}
for (long long i = 0; i < k; i++) {
sort(p[i].begin(), p[i].end(), cmp);
d[i] = 1e18 + 100;
}
d[0] = 0;
spfa();
while (m--) {
long long op;
cin >> op;
if (op == 1) {
cin >> newk[cnt++];
spfa();
} else if (op == 2) {
long long x, y;
cin >> x >> y;
x--;
c[x] -= y;
if (d[a[x] % k] <= a[x]) q.push(record(c[x], x));
} else if (op == 3) {
while (!q.empty() && q.top().x != c[q.top().y]) q.pop();
if (!q.empty()) {
cout << q.top().x << endl;
c[q.top().y] = 0;
q.pop();
} else
cout << 0 << endl;
}
}
return 0;
}
|
In a far away land, there are two cities near a river. One day, the cities decide that they have too little space and would like to reclaim some of the river area into land.
The river area can be represented by a grid with r rows and exactly two columns — each cell represents a rectangular area. The rows are numbered 1 through r from top to bottom, while the columns are numbered 1 and 2.
Initially, all of the cells are occupied by the river. The plan is to turn some of those cells into land one by one, with the cities alternately choosing a cell to reclaim, and continuing until no more cells can be reclaimed.
However, the river is also used as a major trade route. The cities need to make sure that ships will still be able to sail from one end of the river to the other. More formally, if a cell (r, c) has been reclaimed, it is not allowed to reclaim any of the cells (r - 1, 3 - c), (r, 3 - c), or (r + 1, 3 - c).
The cities are not on friendly terms, and each city wants to be the last city to reclaim a cell (they don't care about how many cells they reclaim, just who reclaims a cell last). The cities have already reclaimed n cells. Your job is to determine which city will be the last to reclaim a cell, assuming both choose cells optimally from current moment.
Input
The first line consists of two integers r and n (1 ≤ r ≤ 100, 0 ≤ n ≤ r). Then n lines follow, describing the cells that were already reclaimed. Each line consists of two integers: ri and ci (1 ≤ ri ≤ r, 1 ≤ ci ≤ 2), which represent the cell located at row ri and column ci. All of the lines describing the cells will be distinct, and the reclaimed cells will not violate the constraints above.
Output
Output "WIN" if the city whose turn it is to choose a cell can guarantee that they will be the last to choose a cell. Otherwise print "LOSE".
Examples
Input
3 1
1 1
Output
WIN
Input
12 2
4 1
8 1
Output
WIN
Input
1 1
1 2
Output
LOSE
Note
In the first example, there are 3 possible cells for the first city to reclaim: (2, 1), (3, 1), or (3, 2). The first two possibilities both lose, as they leave exactly one cell for the other city.
<image>
However, reclaiming the cell at (3, 2) leaves no more cells that can be reclaimed, and therefore the first city wins.
<image>
In the third example, there are no cells that can be reclaimed.
|
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.HashSet;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author ilyakor
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
TaskC solver = new TaskC();
solver.solve(1, in, out);
out.close();
}
}
class TaskC {
int[][][] d;
boolean[][][] u;
public void solve(int testNumber, InputReader in, OutputWriter out) {
int n = in.nextInt();
int k = in.nextInt();
boolean[][] a = new boolean[n][2];
for (int i = 0; i < k; ++i) {
int x = in.nextInt() - 1;
int y = in.nextInt() - 1;
a[x][y] = true;
}
d = new int[n + 1][4][4];
u = new boolean[n + 1][4][4];
int prev = 0;
int res = 0;
for (int i = 0; i < n; ) {
int j = i;
while (j < n && !a[j][0] && !a[j][1]) ++j;
int cur = 0;
if (j < n) {
if (a[j][0]) cur |= 2;
if (a[j][1]) cur |= 1;
}
int val = go(j - i, prev, cur);
res ^= val;
prev = cur;
i = j + 1;
}
out.printLine(res == 0 ? "LOSE" : "WIN");
}
private int go(int n, int ml, int mr) {
if (n <= 0) return 0;
if (u[n][ml][mr]) return d[n][ml][mr];
u[n][ml][mr] = true;
if (ml == 3) {
// Should be impossible, but anyway.
int res = go(n - 1, 0, mr);
d[n][ml][mr] = res;
return res;
}
if (mr == 3) {
// Should be impossible, but anyway.
int res = go(n - 1, ml, 0);
d[n][ml][mr] = res;
return res;
}
int res = 0;
int[][] a = new int[n][2];
if (ml % 2 == 1) a[0][0] = 1;
if ((ml / 2) % 2 == 1) a[0][1] = 1;
if (mr % 2 == 1) a[n - 1][0] = 1;
if ((mr / 2) % 2 == 1) a[n - 1][1] = 1;
HashSet<Integer> hs = new HashSet<Integer>();
for (int x = 0; x < n; ++x)
for (int y = 0; y < 2; ++y)
if (a[x][y] == 0) {
int cur = go(x, ml, (1 << (1 - y))) ^ go(n - x - 1, (1 << (1 - y)), mr);
hs.add(cur);
}
while (hs.contains(res)) ++res;
d[n][ml][mr] = res;
return res;
}
}
class InputReader {
private InputStream stream;
private byte[] buffer = new byte[10000];
private int cur;
private int count;
public InputReader(InputStream stream) {
this.stream = stream;
}
public static boolean isSpace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public int read() {
if (count == -1) {
throw new InputMismatchException();
}
try {
if (cur >= count) {
cur = 0;
count = stream.read(buffer);
if (count <= 0)
return -1;
}
} catch (IOException e) {
throw new InputMismatchException();
}
return buffer[cur++];
}
public int readSkipSpace() {
int c;
do {
c = read();
} while (isSpace(c));
return c;
}
public int nextInt() {
int sgn = 1;
int c = readSkipSpace();
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res = res * 10 + c - '0';
c = read();
} while (!isSpace(c));
res *= sgn;
return res;
}
}
class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(objects[i]);
}
}
public void printLine(Object... objects) {
print(objects);
writer.println();
}
public void close() {
writer.close();
}
}
|
Dima has a birthday soon! It's a big day! Saryozha's present to Dima is that Seryozha won't be in the room and won't disturb Dima and Inna as they celebrate the birthday. Inna's present to Dima is a stack, a queue and a deck.
Inna wants her present to show Dima how great a programmer he is. For that, she is going to give Dima commands one by one. There are two types of commands:
1. Add a given number into one of containers. For the queue and the stack, you can add elements only to the end. For the deck, you can add elements to the beginning and to the end.
2. Extract a number from each of at most three distinct containers. Tell all extracted numbers to Inna and then empty all containers. In the queue container you can extract numbers only from the beginning. In the stack container you can extract numbers only from the end. In the deck number you can extract numbers from the beginning and from the end. You cannot extract numbers from empty containers.
Every time Dima makes a command of the second type, Inna kisses Dima some (possibly zero) number of times. Dima knows Inna perfectly well, he is sure that this number equals the sum of numbers he extracts from containers during this operation.
As we've said before, Dima knows Inna perfectly well and he knows which commands Inna will give to Dima and the order of the commands. Help Dima find the strategy that lets him give as more kisses as possible for his birthday!
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of Inna's commands. Then n lines follow, describing Inna's commands. Each line consists an integer:
1. Integer a (1 ≤ a ≤ 105) means that Inna gives Dima a command to add number a into one of containers.
2. Integer 0 shows that Inna asks Dima to make at most three extractions from different containers.
Output
Each command of the input must correspond to one line of the output — Dima's action.
For the command of the first type (adding) print one word that corresponds to Dima's choice:
* pushStack — add to the end of the stack;
* pushQueue — add to the end of the queue;
* pushFront — add to the beginning of the deck;
* pushBack — add to the end of the deck.
For a command of the second type first print an integer k (0 ≤ k ≤ 3), that shows the number of extract operations, then print k words separated by space. The words can be:
* popStack — extract from the end of the stack;
* popQueue — extract from the beginning of the line;
* popFront — extract from the beginning from the deck;
* popBack — extract from the end of the deck.
The printed operations mustn't extract numbers from empty containers. Also, they must extract numbers from distinct containers.
The printed sequence of actions must lead to the maximum number of kisses. If there are multiple sequences of actions leading to the maximum number of kisses, you are allowed to print any of them.
Examples
Input
10
0
1
0
1
2
0
1
2
3
0
Output
0
pushStack
1 popStack
pushStack
pushQueue
2 popStack popQueue
pushStack
pushQueue
pushFront
3 popStack popQueue popFront
Input
4
1
2
3
0
Output
pushStack
pushQueue
pushFront
3 popStack popQueue popFront
|
#include <bits/stdc++.h>
using namespace std;
string aS = "pushStack";
string aQ = "pushQueue";
string aF = "pushFront";
string aB = "pushBack";
string pS = "popStack";
string pQ = "popQueue";
string pF = "popFront";
string pB = "popBack";
int main() {
ios_base::sync_with_stdio(false);
int qq;
cin >> qq;
vector<int> ar;
while (qq--) {
int t;
cin >> t;
int d = 0;
stack<int> s;
queue<int> q;
int _1 = 0, _2 = 0, _3 = 0;
if (t == 0) {
vector<int> x;
x = ar;
sort(x.rbegin(), x.rend());
for (int i = 0; i < ar.size(); i++) {
if (ar[i] == x[0] && !_1) {
_1 = 1;
if (q.empty()) {
q.push(t);
cout << aQ << "\n";
} else if (s.empty()) {
s.push(t);
cout << aS << "\n";
} else if (d == 0) {
d = 1;
cout << aB << "\n";
} else {
cout << aF << "\n";
}
} else if (ar.size() > 1 && ar[i] == x[1] && !_2) {
_2 = 1;
if (q.empty()) {
q.push(t);
cout << aQ << "\n";
} else if (s.empty()) {
s.push(t);
cout << aS << "\n";
} else if (d == 0) {
d = 1;
cout << aB << "\n";
} else {
cout << aF << "\n";
}
} else if (ar.size() > 2 && ar[i] == x[2] && !_3) {
_3 = 1;
if (q.empty()) {
q.push(t);
cout << aQ << "\n";
} else if (s.empty()) {
s.push(t);
cout << aS << "\n";
} else if (d == 0) {
d = 1;
cout << aB << "\n";
} else {
cout << aF << "\n";
}
} else {
cout << aF << "\n";
}
}
int cnt = 0;
if (d != 0) cnt++;
if (!s.empty()) cnt++;
if (!q.empty()) cnt++;
cout << cnt;
if (!s.empty()) {
cout << " " << pS;
}
if (!q.empty()) {
cout << " " << pQ;
}
if (d) {
cout << " " << pB;
}
cout << "\n";
ar.clear();
} else {
ar.push_back(t);
}
}
if (!ar.empty()) {
for (int i = 0; i < ar.size(); i++) {
cout << aB << "\n";
}
}
}
|
Sereja loves integer sequences very much. He especially likes stairs.
Sequence a1, a2, ..., a|a| (|a| is the length of the sequence) is stairs if there is such index i (1 ≤ i ≤ |a|), that the following condition is met:
a1 < a2 < ... < ai - 1 < ai > ai + 1 > ... > a|a| - 1 > a|a|.
For example, sequences [1, 2, 3, 2] and [4, 2] are stairs and sequence [3, 1, 2] isn't.
Sereja has m cards with numbers. He wants to put some cards on the table in a row to get a stair sequence. What maximum number of cards can he put on the table?
Input
The first line contains integer m (1 ≤ m ≤ 105) — the number of Sereja's cards. The second line contains m integers bi (1 ≤ bi ≤ 5000) — the numbers on the Sereja's cards.
Output
In the first line print the number of cards you can put on the table. In the second line print the resulting stairs.
Examples
Input
5
1 2 3 4 5
Output
5
5 4 3 2 1
Input
6
1 1 2 2 3 3
Output
5
1 2 3 2 1
|
from sys import stdin,stdout
from math import factorial as f
inp=stdin.readline
op=stdout.write
n=int(inp())
a=list(map(int,inp().split()))
a.sort()
# op(str(a))
if(len(set(a))==n):
op(str(len(a))+"\n")
a=[str(i) for i in a]
op(' '.join(a[::-1])+"\n")
else:
temp=float('inf')
i=0
rev=[]
while(i<len(a)):
if(a[i]==temp):
temp=a.pop(i)
rev.append(temp)
else:
temp=a[i]
a[i]=str(a[i])
i=i+1
rev=list(set(rev))
# a.sort()
rev.sort()
if(int(a[len(a)-1])==rev[len(rev)-1]):
rev.pop()
# op(str(rev)+'\n')
if(len(rev)==0):
temp=int(a.pop(0))
rev.append(temp)
rev.sort()
rev=[str(i) for i in rev]
op(str(len(a)+len(rev))+"\n")
op(' '.join(a)+' '+' '.join(rev[::-1]))
|
You have a nuts and lots of boxes. The boxes have a wonderful feature: if you put x (x ≥ 0) divisors (the spacial bars that can divide a box) to it, you get a box, divided into x + 1 sections.
You are minimalist. Therefore, on the one hand, you are against dividing some box into more than k sections. On the other hand, you are against putting more than v nuts into some section of the box. What is the minimum number of boxes you have to use if you want to put all the nuts in boxes, and you have b divisors?
Please note that you need to minimize the number of used boxes, not sections. You do not have to minimize the number of used divisors.
Input
The first line contains four space-separated integers k, a, b, v (2 ≤ k ≤ 1000; 1 ≤ a, b, v ≤ 1000) — the maximum number of sections in the box, the number of nuts, the number of divisors and the capacity of each section of the box.
Output
Print a single integer — the answer to the problem.
Examples
Input
3 10 3 3
Output
2
Input
3 10 1 3
Output
3
Input
100 100 1 1000
Output
1
Note
In the first sample you can act like this:
* Put two divisors to the first box. Now the first box has three sections and we can put three nuts into each section. Overall, the first box will have nine nuts.
* Do not put any divisors into the second box. Thus, the second box has one section for the last nut.
In the end we've put all the ten nuts into boxes.
The second sample is different as we have exactly one divisor and we put it to the first box. The next two boxes will have one section each.
|
import java.io.*;
import java.util.*;
public class p402a
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
System.out.println();
int k = sc.nextInt();
int a = sc.nextInt();
int b = sc.nextInt();
int v = sc.nextInt();
int space,space2;
int count;
if(b<k-1)
{
space = b+1;
count = 1;
if(space*v>=a) System.out.println(count);
else
{
a -= space*v;
System.out.println(count+(int)Math.ceil((double)a/(double)v));
}
}
else if(k==1)
{
count = (int)Math.ceil((double)a/(double)(k*v));
System.out.println(count);
}
else
{
space = (b/(k-1))*k;
count = b/(k-1);
space2 = space + (b%(k-1)) + 1;
if(space*v>=a) System.out.println((int)Math.ceil((double)a/(double)(k*v)));
else if(space2*v>=a) System.out.println(count+1);
else
{
a -= space2*v;
System.out.println(count+1+(int)Math.ceil((double)a/(double)v));
}
}
}
}
|
Once Volodya was at the museum and saw a regular chessboard as a museum piece. And there were only four chess pieces on it: two white rooks, a white king and a black king. "Aha, blacks certainly didn't win!", — Volodya said and was right for sure. And your task is to say whether whites had won or not.
Pieces on the chessboard are guaranteed to represent a correct position (every piece occupies one cell, no two pieces occupy the same cell and kings cannot take each other). Thus, your task is only to decide whether whites mate blacks. We would remind you that it means that the black king can be taken by one of the opponent's pieces at the moment and also it cannot move to an unbeaten position. A rook moves vertically or horizontally by any number of free cells (assuming there are no other pieces on its path), a king — to the adjacent cells (either by corner or by side). Certainly, pieces cannot leave the board. The black king might be able to take opponent's rooks at his turn (see sample 3).
Input
The input contains 4 space-separated piece positions: positions of the two rooks, the white king and the black king. Each position on 8 × 8 chessboard is denoted by two symbols — ('a' - 'h') and ('1' - '8') — which stand for horizontal and vertical coordinates of the cell occupied by the piece. It is guaranteed, that no two pieces occupy the same cell, and kings cannot take each other.
Output
Output should contain one word: "CHECKMATE" if whites mate blacks, and "OTHER" otherwise.
Examples
Input
a6 b4 c8 a8
Output
CHECKMATE
Input
a6 c4 b6 b8
Output
OTHER
Input
a2 b1 a3 a1
Output
OTHER
|
#include <bits/stdc++.h>
using namespace std;
struct Point {
Point(int _x = 0, int _y = 0) : x(_x), y(_y) {}
int x, y;
};
int table[8][8];
int dirx[4] = {-1, 0, 0, 1};
int diry[4] = {0, -1, 1, 0};
int main() {
Point a[4];
for (int i = 0; i < 4; ++i) {
char x, y;
scanf(" %c%c", &x, &y);
a[i] = Point(x - 'a', y - '1');
}
swap(a[2], a[3]);
Point a2 = a[2];
bool checkmate = true;
for (int dx = -1; dx <= 1; ++dx)
for (int dy = -1; dy <= 1; ++dy) {
a[2] = Point(a2.x + dx, a2.y + dy);
if (a[2].x < 0 || a[2].x > 7 || a[2].y < 0 || a[2].y > 7) continue;
memset(table, 0, sizeof(table));
for (int i = 0; i < 4; ++i) {
if (a[i].x == a[2].x && a[i].y == a[2].y) continue;
table[a[i].x][a[i].y] = 1;
}
for (int i = 0; i < 4; ++i) {
if (a[i].x == a[2].x && a[i].y == a[2].y) continue;
if (i == 3) {
for (int dx = -1; dx <= 1; ++dx)
for (int dy = -1; dy <= 1; ++dy) {
int xx = dx + a[i].x, yy = dy + a[i].y;
if (xx < 0 || yy < 0 || xx > 7 || yy > 7) continue;
table[xx][yy] = 1;
}
} else {
for (int j = 0; j < 4; ++j) {
int xx = a[i].x, yy = a[i].y;
while (true) {
xx += dirx[j], yy += diry[j];
if (xx < 0 || yy < 0 || xx > 7 || yy > 7) break;
if (table[xx][yy] == 1) break;
table[xx][yy] = 2;
}
}
}
}
if (table[a[2].x][a[2].y] == 0) checkmate = false;
}
if (checkmate)
printf("CHECKMATE\n");
else
printf("OTHER\n");
}
|
Devu wants to decorate his garden with flowers. He has purchased n boxes, where the i-th box contains fi flowers. All flowers in a single box are of the same color (hence they are indistinguishable). Also, no two boxes have flowers of the same color.
Now Devu wants to select exactly s flowers from the boxes to decorate his garden. Devu would like to know, in how many different ways can he select the flowers from each box? Since this number may be very large, he asks you to find the number modulo (109 + 7).
Devu considers two ways different if there is at least one box from which different number of flowers are selected in these two ways.
Input
The first line of input contains two space-separated integers n and s (1 ≤ n ≤ 20, 0 ≤ s ≤ 1014).
The second line contains n space-separated integers f1, f2, ... fn (0 ≤ fi ≤ 1012).
Output
Output a single integer — the number of ways in which Devu can select the flowers modulo (109 + 7).
Examples
Input
2 3
1 3
Output
2
Input
2 4
2 2
Output
1
Input
3 5
1 3 2
Output
3
Note
Sample 1. There are two ways of selecting 3 flowers: {1, 2} and {0, 3}.
Sample 2. There is only one way of selecting 4 flowers: {2, 2}.
Sample 3. There are three ways of selecting 5 flowers: {1, 2, 2}, {0, 3, 2}, and {1, 3, 1}.
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int n;
long long s;
long long f[22];
long long mult(long long a, long long b) { return (a * b) % mod; }
long long add(long long a, long long b) { return (a + b) % mod; }
long long inv(long long n) {
long long ret = 1;
for (int i = 0; (1LL << i) <= mod - 2; ++i) {
if ((((mod - 2) >> i) & 1) == 1) ret = mult(ret, n);
n = mult(n, n);
}
return ret;
}
long long I[22];
long long ways(long long s, int n) {
long long ret = 1;
for (long long i = s + n - 1; i > s; --i) ret = mult(ret, i % mod);
for (long long i = n - 1; i >= 1; --i) ret = mult(ret, I[i]);
return ret;
}
int main(void) {
cin >> n >> s;
for (int i = 0; i < n; ++i) cin >> f[i];
for (int i = 1; i < n; ++i) I[i] = inv(i);
long long sol = 0;
for (int mask = 0; mask < (1 << n); ++mask) {
long long rem = 0;
for (int i = 0; i < n; ++i)
if (((mask >> i) & 1) == 1) rem += f[i] + 1;
if (s - rem < 0) continue;
int sgn = (__builtin_popcount(mask) % 2) ? -1 : +1;
sol = add(sol, add(mod, sgn * ways(s - rem, n)));
}
cout << sol << endl;
return 0;
}
|
We saw the little game Marmot made for Mole's lunch. Now it's Marmot's dinner time and, as we all know, Marmot eats flowers. At every dinner he eats some red and white flowers. Therefore a dinner can be represented as a sequence of several flowers, some of them white and some of them red.
But, for a dinner to be tasty, there is a rule: Marmot wants to eat white flowers only in groups of size k.
Now Marmot wonders in how many ways he can eat between a and b flowers. As the number of ways could be very large, print it modulo 1000000007 (109 + 7).
Input
Input contains several test cases.
The first line contains two integers t and k (1 ≤ t, k ≤ 105), where t represents the number of test cases.
The next t lines contain two integers ai and bi (1 ≤ ai ≤ bi ≤ 105), describing the i-th test.
Output
Print t lines to the standard output. The i-th line should contain the number of ways in which Marmot can eat between ai and bi flowers at dinner modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 3
2 3
4 4
Output
6
5
5
Note
* For K = 2 and length 1 Marmot can eat (R).
* For K = 2 and length 2 Marmot can eat (RR) and (WW).
* For K = 2 and length 3 Marmot can eat (RRR), (RWW) and (WWR).
* For K = 2 and length 4 Marmot can eat, for example, (WWWW) or (RWWR), but for example he can't eat (WWWR).
|
#include <bits/stdc++.h>
using namespace std;
int v[100010];
int som[100010];
int t, k;
void pd() {
for (int i = 0; i < 100010 - 5; i++) {
if (i < k)
v[i] = 1;
else {
v[i] = v[i - 1] + v[i - k];
if (v[i] >= 1000000007) v[i] -= 1000000007;
}
}
}
int main() {
cin >> t >> k;
int ans;
int a, b;
pd();
ans = 0;
for (int j = 0; j < 100010 - 7; j++) {
ans += v[j];
if (ans >= 1000000007) ans -= 1000000007;
som[j] = ans;
}
for (int i = 0; i < t; i++) {
cin >> a >> b;
ans = som[b] - som[a] + v[a];
if (ans < 0)
ans += 1000000007;
else if (ans >= 1000000007)
ans -= 1000000007;
cout << ans << endl;
}
return 0;
}
|
You have written on a piece of paper an array of n positive integers a[1], a[2], ..., a[n] and m good pairs of integers (i1, j1), (i2, j2), ..., (im, jm). Each good pair (ik, jk) meets the following conditions: ik + jk is an odd number and 1 ≤ ik < jk ≤ n.
In one operation you can perform a sequence of actions:
* take one of the good pairs (ik, jk) and some integer v (v > 1), which divides both numbers a[ik] and a[jk];
* divide both numbers by v, i. e. perform the assignments: <image> and <image>.
Determine the maximum number of operations you can sequentially perform on the given array. Note that one pair may be used several times in the described operations.
Input
The first line contains two space-separated integers n, m (2 ≤ n ≤ 100, 1 ≤ m ≤ 100).
The second line contains n space-separated integers a[1], a[2], ..., a[n] (1 ≤ a[i] ≤ 109) — the description of the array.
The following m lines contain the description of good pairs. The k-th line contains two space-separated integers ik, jk (1 ≤ ik < jk ≤ n, ik + jk is an odd number).
It is guaranteed that all the good pairs are distinct.
Output
Output the answer for the problem.
Examples
Input
3 2
8 3 8
1 2
2 3
Output
0
Input
3 2
8 12 8
1 2
2 3
Output
2
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
struct Dinic {
int N, E;
vector<int> head, dis, ptr;
vector<int> to, prv, cap, flo;
Dinic(int N) : N(N), E(0), head(N, -1), dis(N) {}
void addEdge(int v, int u, int vu, int uv = 0) {
to.resize(E + 2);
prv.resize(E + 2);
cap.resize(E + 2);
flo.resize(E + 2);
to[E] = u, prv[E] = head[v], cap[E] = vu, head[v] = E++;
to[E] = v, prv[E] = head[u], cap[E] = uv, head[u] = E++;
}
void clear() {
E = 0;
fill(head.begin(), head.end(), -1);
}
bool bfs(int source, int sink) {
fill(dis.begin(), dis.end(), INF);
dis[source] = 0;
int h = 0, t = 0;
vector<int> q(N);
q[t++] = source;
while (h < t) {
int v = q[h++];
for (int e = head[v]; e != -1; e = prv[e]) {
if (cap[e] - flo[e] > 0 && dis[to[e]] > dis[v] + 1) {
dis[to[e]] = dis[v] + 1, q[t++] = to[e];
if (to[e] == sink) return 1;
}
}
}
return 0;
}
int dfs(int v, int sink, int flow = INF) {
if (v == sink || flow == 0) return flow;
int ret = 0;
for (int &e = ptr[v]; e != -1; e = prv[e]) {
if (dis[v] == dis[to[e]] - 1) {
int x = dfs(to[e], sink, min(flow, cap[e] - flo[e]));
flow -= x, ret += x;
flo[e] += x, flo[e ^ 1] -= x;
if (flow == 0) break;
}
}
return ret;
}
int maxFlow(int source, int sink) {
fill(flo.begin(), flo.end(), 0);
int ans = 0;
while (bfs(source, sink)) {
ptr = head;
ans += dfs(source, sink);
}
return ans;
}
};
struct primeFactor {
int id, p, c;
};
int main() {
int n, m;
cin >> n >> m;
vector<vector<primeFactor>> V(n);
int id = 0;
for (int i = 0; i < n; i++) {
int t;
scanf("%d", &t);
for (int j = 2; j * j <= t; j++) {
int c = 0;
while (t % j == 0) {
c++, t /= j;
}
if (c) V[i].push_back({id++, j, c});
}
if (t > 1) {
V[i].push_back({id++, t, 1});
}
}
int nodes = id + 2;
int S = id, T = id + 1;
Dinic G(nodes);
for (int i = 0; i < n; i++) {
if (i % 2) {
for (auto &p : V[i]) {
G.addEdge(p.id, T, p.c);
}
} else {
for (auto &p : V[i]) {
G.addEdge(S, p.id, p.c);
}
}
}
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
if (u % 2) swap(u, v);
for (auto &pu : V[u]) {
for (auto &pv : V[v]) {
if (pu.p == pv.p) {
G.addEdge(pu.id, pv.id, INF);
}
}
}
}
printf("%d\n", G.maxFlow(S, T));
}
|
Vasya plays one very well-known and extremely popular MMORPG game. His game character has k skill; currently the i-th of them equals to ai. Also this game has a common rating table in which the participants are ranked according to the product of all the skills of a hero in the descending order.
Vasya decided to 'upgrade' his character via the game store. This store offers n possible ways to improve the hero's skills; Each of these ways belongs to one of three types:
1. assign the i-th skill to b;
2. add b to the i-th skill;
3. multiply the i-th skill by b.
Unfortunately, a) every improvement can only be used once; b) the money on Vasya's card is enough only to purchase not more than m of the n improvements. Help Vasya to reach the highest ranking in the game. To do this tell Vasya which of improvements he has to purchase and in what order he should use them to make his rating become as high as possible. If there are several ways to achieve it, print any of them.
Input
The first line contains three numbers — k, n, m (1 ≤ k ≤ 105, 0 ≤ m ≤ n ≤ 105) — the number of skills, the number of improvements on sale and the number of them Vasya can afford.
The second line contains k space-separated numbers ai (1 ≤ ai ≤ 106), the initial values of skills.
Next n lines contain 3 space-separated numbers tj, ij, bj (1 ≤ tj ≤ 3, 1 ≤ ij ≤ k, 1 ≤ bj ≤ 106) — the type of the j-th improvement (1 for assigning, 2 for adding, 3 for multiplying), the skill to which it can be applied and the value of b for this improvement.
Output
The first line should contain a number l (0 ≤ l ≤ m) — the number of improvements you should use.
The second line should contain l distinct space-separated numbers vi (1 ≤ vi ≤ n) — the indices of improvements in the order in which they should be applied. The improvements are numbered starting from 1, in the order in which they appear in the input.
Examples
Input
2 4 3
13 20
1 1 14
1 2 30
2 1 6
3 2 2
Output
3
2 3 4
|
#include <bits/stdc++.h>
using namespace std;
struct Add {
long long x, d;
int i;
bool operator<(const Add& p) const {
return (long long)d * p.x > (long long)p.d * x;
}
} a[100005];
int cnt, d[100005], p[100005], sig[100005];
long long x[100005];
vector<pair<int, int>> chain[100005];
int main() {
int i, k, n, m;
scanf("%d%d%d", &k, &n, &m);
for (i = 1; i <= k; i++) scanf("%I64d", &x[i]);
for (i = 1; i <= n; i++) {
int opt, pos, ch;
scanf("%d%d%d", &opt, &pos, &ch);
sig[i] = opt;
if (opt == 1) {
if (d[pos] < ch - x[pos]) d[pos] = ch - x[pos], p[pos] = i;
} else if (opt == 2)
chain[pos].push_back(make_pair(ch, i));
else
a[cnt++] = (Add){1, ch - 1, i};
}
for (i = 1; i <= k; i++) {
if (d[i]) chain[i].push_back(make_pair(d[i], p[i]));
sort(chain[i].rbegin(), chain[i].rend());
for (auto e : chain[i]) {
a[cnt++] = (Add){x[i], e.first, e.second};
x[i] += e.first;
}
}
std::sort(a, a + cnt);
int ans = std::min(cnt, m);
printf("%d\n", ans);
for (i = 0; i < ans; i++)
if (sig[a[i].i] == 1) printf("%d ", a[i].i);
for (i = 0; i < ans; i++)
if (sig[a[i].i] == 2) printf("%d ", a[i].i);
for (i = 0; i < ans; i++)
if (sig[a[i].i] == 3) printf("%d ", a[i].i);
return 0;
}
|
The developers of Looksery have to write an efficient algorithm that detects faces on a picture. Unfortunately, they are currently busy preparing a contest for you, so you will have to do it for them.
In this problem an image is a rectangular table that consists of lowercase Latin letters. A face on the image is a 2 × 2 square, such that from the four letters of this square you can make word "face".
You need to write a program that determines the number of faces on the image. The squares that correspond to the faces can overlap.
Input
The first line contains two space-separated integers, n and m (1 ≤ n, m ≤ 50) — the height and the width of the image, respectively.
Next n lines define the image. Each line contains m lowercase Latin letters.
Output
In the single line print the number of faces on the image.
Examples
Input
4 4
xxxx
xfax
xcex
xxxx
Output
1
Input
4 2
xx
cf
ae
xx
Output
1
Input
2 3
fac
cef
Output
2
Input
1 4
face
Output
0
Note
In the first sample the image contains a single face, located in a square with the upper left corner at the second line and the second column:
<image>
In the second sample the image also contains exactly one face, its upper left corner is at the second row and the first column.
In the third sample two faces are shown:
<image>
In the fourth sample the image has no faces on it.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string theWord = "";
int shiftRight = 0;
int shiftDown = 0;
int faces = 0;
int n;
int m;
cin >> n;
cin >> m;
char arr[n][m];
char letter;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> letter;
arr[i][j] = letter;
}
}
for (int y = 0; y < n - 1; y++) {
for (int x = 0; x < m - 1; x++) {
for (int i = shiftDown; i < shiftDown + 2; i++) {
for (int j = shiftRight; j < shiftRight + 2; j++) {
theWord += arr[i][j];
}
}
if (theWord.find('f') != string::npos &&
theWord.find('a') != string::npos &&
theWord.find('c') != string::npos &&
theWord.find('e') != string::npos) {
faces++;
}
theWord.clear();
shiftRight++;
}
shiftRight = 0;
shiftDown++;
}
cout << faces << endl;
return 0;
}
|
Note the unusual memory limit for the problem.
People working in MDCS (Microsoft Development Center Serbia) like partying. They usually go to night clubs on Friday and Saturday.
There are N people working in MDCS and there are N clubs in the city. Unfortunately, if there is more than one Microsoft employee in night club, level of coolness goes infinitely high and party is over, so club owners will never let more than one Microsoft employee enter their club in the same week (just to be sure).
You are organizing night life for Microsoft employees and you have statistics about how much every employee likes Friday and Saturday parties for all clubs.
You need to match people with clubs maximizing overall sum of their happiness (they are happy as much as they like the club), while half of people should go clubbing on Friday and the other half on Saturday.
Input
The first line contains integer N — number of employees in MDCS.
Then an N × N matrix follows, where element in i-th row and j-th column is an integer number that represents how much i-th person likes j-th club’s Friday party.
Then another N × N matrix follows, where element in i-th row and j-th column is an integer number that represents how much i-th person likes j-th club’s Saturday party.
* 2 ≤ N ≤ 20
* N is even
* 0 ≤ level of likeness ≤ 106
* All values are integers
Output
Output should contain a single integer — maximum sum of happiness possible.
Examples
Input
4
1 2 3 4
2 3 4 1
3 4 1 2
4 1 2 3
5 8 7 1
6 9 81 3
55 78 1 6
1 1 1 1
Output
167
Note
Here is how we matched people with clubs:
Friday: 1st person with 4th club (4 happiness) and 4th person with 1st club (4 happiness).
Saturday: 2nd person with 3rd club (81 happiness) and 3rd person with 2nd club (78 happiness).
4+4+81+78 = 167
|
#include <bits/stdc++.h>
bool used[21];
char P[21], way[21];
int n, m, res, U[21], V[21], minv[21], ar[21][21], fri[21][21], sat[21][21];
int hungarian(int i) {
int j, i0, i1, j0, j1, cur, delta;
P[0] = i, j0 = 0;
for (j = 0; j <= m; j++) minv[j] = (1 << 27), used[j] = false;
do {
used[j0] = true;
i0 = P[j0], j1 = 0, delta = (1 << 27);
for (j = 1; j <= m; j++) {
if (!used[j]) {
cur = ar[i0][j] - U[i0] - V[j];
if (cur < minv[j]) {
minv[j] = cur;
way[j] = j0;
}
if (minv[j] < delta) {
delta = minv[j];
j1 = j;
}
}
}
for (j = 0; j <= m; j++) {
if (used[j]) {
U[P[j]] += delta;
V[j] -= delta;
} else
minv[j] -= delta;
}
j0 = j1;
} while (P[j0] != 0);
do {
j1 = way[j0];
P[j0] = P[j1];
j0 = j1;
} while (j0 != 0);
return -V[0];
}
void backtrack(int i, int f, int s) {
if (i == n) return;
char C[21], D[21];
int j, x, A[21], B[21];
if (f) {
for (j = 0; j <= m; j++)
A[j] = U[j], B[j] = V[j], C[j] = P[j], D[j] = way[j];
for (j = 0; j < m; j++) ar[i + 1][j + 1] = -fri[i][j];
x = -hungarian(i + 1);
backtrack(i + 1, f - 1, s);
if (x > res) res = x;
for (j = 0; j <= m; j++)
U[j] = A[j], V[j] = B[j], P[j] = C[j], way[j] = D[j];
}
if (s) {
for (j = 0; j <= m; j++)
A[j] = U[j], B[j] = V[j], C[j] = P[j], D[j] = way[j];
for (j = 0; j < m; j++) ar[i + 1][j + 1] = -sat[i][j];
x = -hungarian(i + 1);
backtrack(i + 1, f, s - 1);
if (x > res) res = x;
for (j = 0; j <= m; j++)
U[j] = A[j], V[j] = B[j], P[j] = C[j], way[j] = D[j];
}
}
int main() {
int i, j, k, x;
while (scanf("%d", &n) != EOF) {
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
scanf("%d", &fri[i][j]);
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
scanf("%d", &sat[i][j]);
}
}
res = 0, m = n;
memset(way, 0, sizeof(way)), memset(U, 0, sizeof(U)),
memset(V, 0, sizeof(V)), memset(P, 0, sizeof(P));
backtrack(0, n >> 1, n >> 1);
printf("%d\n", res);
}
return 0;
}
|
Find the number of k-divisible numbers on the segment [a, b]. In other words you need to find the number of such integer values x that a ≤ x ≤ b and x is divisible by k.
Input
The only line contains three space-separated integers k, a and b (1 ≤ k ≤ 1018; - 1018 ≤ a ≤ b ≤ 1018).
Output
Print the required number.
Examples
Input
1 1 10
Output
10
Input
2 -4 4
Output
5
|
k, a, b = map(int, input().split())
def Do(a, b,):
suma = 0
if a < 0:
if b == 0:
print(-a // k + 1)
if b > 0:
suma = 1
a = -a
if a % k == 0:
if b % k == 0:
suma += b // k + a // k
print(suma)
else:
suma += b // k + a // k
print(suma)
else:
if b % k == 0:
suma += b // k + a // k
print(suma)
else:
suma += b // k + a // k
print(suma)
if b < 0:
el = a
a = -b
b = -el
if a % k == 0:
if b % k == 0:
suma = 1
suma += b // k - a // k
print(suma)
else:
suma = 1
suma += b // k - a // k
print(suma)
else:
if b % k == 0:
suma += b // k - a // k
print(suma)
else:
suma += b // k - a // k
print(suma)
else:
if a % k == 0:
if b % k == 0:
suma = 1
suma += b // k - a // k
print(suma)
else:
suma = 1
suma += b // k - a // k
print(suma)
else:
if b % k == 0:
suma += b // k - a // k
print(suma)
else:
suma += b // k - a // k
print(suma)
if a == b:
if a % k == 0:
print(1)
else:
print(0)
else:
Do(a, b)
|
Cat Noku has obtained a map of the night sky. On this map, he found a constellation with n stars numbered from 1 to n. For each i, the i-th star is located at coordinates (xi, yi). No two stars are located at the same position.
In the evening Noku is going to take a look at the night sky. He would like to find three distinct stars and form a triangle. The triangle must have positive area. In addition, all other stars must lie strictly outside of this triangle. He is having trouble finding the answer and would like your help. Your job is to find the indices of three stars that would form a triangle that satisfies all the conditions.
It is guaranteed that there is no line such that all stars lie on that line. It can be proven that if the previous condition is satisfied, there exists a solution to this problem.
Input
The first line of the input contains a single integer n (3 ≤ n ≤ 100 000).
Each of the next n lines contains two integers xi and yi ( - 109 ≤ xi, yi ≤ 109).
It is guaranteed that no two stars lie at the same point, and there does not exist a line such that all stars lie on that line.
Output
Print three distinct integers on a single line — the indices of the three points that form a triangle that satisfies the conditions stated in the problem.
If there are multiple possible answers, you may print any of them.
Examples
Input
3
0 1
1 0
1 1
Output
1 2 3
Input
5
0 0
0 2
2 0
2 2
1 1
Output
1 3 5
Note
In the first sample, we can print the three indices in any order.
In the second sample, we have the following picture.
<image>
Note that the triangle formed by starts 1, 4 and 3 doesn't satisfy the conditions stated in the problem, as point 5 is not strictly outside of this triangle (it lies on it's border).
|
f = lambda: list(map(int, input().split()))
d = lambda x, y: (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2
r = lambda x, y, z: (x[0] - y[0]) * (x[1] - z[1]) == (x[1] - y[1]) * (x[0] - z[0])
n = int(input())
t = [f() for i in range(n)]
j = k = -1
b = c = 0
x = t.pop()
for i in range(n - 1):
a = d(x, t[i])
if j < 0 or a < b: j, b = i, a
y = t.pop(j)
for i in range(n - 2):
if r(x, y, t[i]): continue
a = d(x, t[i])
if k < 0 or a < c: k, c = i, a
print(n, j + 1, k + 2 - (j > k))
|
Limak is a little polar bear. He loves connecting with other bears via social networks. He has n friends and his relation with the i-th of them is described by a unique integer ti. The bigger this value is, the better the friendship is. No two friends have the same value ti.
Spring is starting and the Winter sleep is over for bears. Limak has just woken up and logged in. All his friends still sleep and thus none of them is online. Some (maybe all) of them will appear online in the next hours, one at a time.
The system displays friends who are online. On the screen there is space to display at most k friends. If there are more than k friends online then the system displays only k best of them — those with biggest ti.
Your task is to handle queries of two types:
* "1 id" — Friend id becomes online. It's guaranteed that he wasn't online before.
* "2 id" — Check whether friend id is displayed by the system. Print "YES" or "NO" in a separate line.
Are you able to help Limak and answer all queries of the second type?
Input
The first line contains three integers n, k and q (1 ≤ n, q ≤ 150 000, 1 ≤ k ≤ min(6, n)) — the number of friends, the maximum number of displayed online friends and the number of queries, respectively.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 109) where ti describes how good is Limak's relation with the i-th friend.
The i-th of the following q lines contains two integers typei and idi (1 ≤ typei ≤ 2, 1 ≤ idi ≤ n) — the i-th query. If typei = 1 then a friend idi becomes online. If typei = 2 then you should check whether a friend idi is displayed.
It's guaranteed that no two queries of the first type will have the same idi becuase one friend can't become online twice. Also, it's guaranteed that at least one query will be of the second type (typei = 2) so the output won't be empty.
Output
For each query of the second type print one line with the answer — "YES" (without quotes) if the given friend is displayed and "NO" (without quotes) otherwise.
Examples
Input
4 2 8
300 950 500 200
1 3
2 4
2 3
1 1
1 2
2 1
2 2
2 3
Output
NO
YES
NO
YES
YES
Input
6 3 9
50 20 51 17 99 24
1 3
1 4
1 5
1 2
2 4
2 2
1 1
2 4
2 3
Output
NO
YES
NO
YES
Note
In the first sample, Limak has 4 friends who all sleep initially. At first, the system displays nobody because nobody is online. There are the following 8 queries:
1. "1 3" — Friend 3 becomes online.
2. "2 4" — We should check if friend 4 is displayed. He isn't even online and thus we print "NO".
3. "2 3" — We should check if friend 3 is displayed. Right now he is the only friend online and the system displays him. We should print "YES".
4. "1 1" — Friend 1 becomes online. The system now displays both friend 1 and friend 3.
5. "1 2" — Friend 2 becomes online. There are 3 friends online now but we were given k = 2 so only two friends can be displayed. Limak has worse relation with friend 1 than with other two online friends (t1 < t2, t3) so friend 1 won't be displayed
6. "2 1" — Print "NO".
7. "2 2" — Print "YES".
8. "2 3" — Print "YES".
|
import sys
window = set()
n, k, q = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
for i in range(q):
a, b = [int(x) for x in input().split()]
if (a == 1):
if (len(window) < k):
window.add(arr[b - 1])
else:
window.add(arr[b - 1])
m = min(window)
window.remove(m)
else:
print("YES" if arr[b - 1] in window else "NO") #bcz all value all unique and we can check for them value also
|
The famous sculptor Cicasso is a Reberlandian spy!
These is breaking news in Berlandian papers today. And now the sculptor is hiding. This time you give the shelter to the maestro. You have a protected bunker and you provide it to your friend. You set the security system in such way that only you can open the bunker. To open it one should solve the problem which is hard for others but is simple for you.
Every day the bunker generates a codeword s. Every time someone wants to enter the bunker, integer n appears on the screen. As the answer one should enter another integer — the residue modulo 109 + 7 of the number of strings of length n that consist only of lowercase English letters and contain the string s as the subsequence.
The subsequence of string a is a string b that can be derived from the string a by removing some symbols from it (maybe none or all of them). In particular any string is the subsequence of itself. For example, the string "cfo" is the subsequence of the string "codeforces".
You haven't implemented the algorithm that calculates the correct answers yet and you should do that ASAP.
Input
The first line contains integer m (1 ≤ m ≤ 105) — the number of the events in the test case.
The second line contains nonempty string s — the string generated by the bunker for the current day.
The next m lines contain the description of the events. The description starts from integer t — the type of the event.
If t = 1 consider a new day has come and now a new string s is used. In that case the same line contains a new value of the string s.
If t = 2 integer n is given (1 ≤ n ≤ 105). This event means that it's needed to find the answer for the current string s and the value n.
The sum of lengths of all generated strings doesn't exceed 105. All of the given strings consist only of lowercase English letters.
Output
For each query of the type 2 print the answer modulo 109 + 7 on the separate line.
Example
Input
3
a
2 2
1 bc
2 5
Output
51
162626
Note
In the first event words of the form "a?" and "?a" are counted, where ? is an arbitrary symbol. There are 26 words of each of these types, but the word "aa" satisfies both patterns, so the answer is 51.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, P = 1e9 + 7;
int n, m, Q, fc[N], ifc[N], pw[N], len[N];
char s[N];
bool vis[N];
vector<int> f[N];
int inv(int x) { return x == 1 ? x : 1LL * (P - P / x) * inv(P % x) % P; }
int C(int n, int m) {
return n < m ? 0 : 1LL * fc[n] * ifc[n - m] % P * ifc[m] % P;
}
int main() {
pw[0] = fc[0] = 1;
for (int i = 1; i <= N - 5; ++i)
pw[i] = 25LL * pw[i - 1] % P, fc[i] = 1LL * i * fc[i - 1] % P;
ifc[N - 5] = inv(fc[N - 5]);
for (int i = N - 6; ~i; --i) ifc[i] = 1LL * (i + 1) * ifc[i + 1] % P;
for (scanf("%d%s", &Q, s), m = strlen(s); Q--;) {
int op;
scanf("%d", &op);
if (op == 1)
scanf("%s", s), m = strlen(s);
else {
scanf("%d", &n);
if (!vis[m]) {
f[m].push_back(0), vis[m] = 1;
for (int i = 1; i <= N - 5; ++i)
f[m].push_back((1LL * C(i - 1, m - 1) * (i < m ? 0 : pw[i - m]) % P +
26LL * f[m][i - 1] % P) %
P);
}
printf("%d\n", f[m][n]);
}
}
return 0;
}
|
Way to go! Heidi now knows how many brains there must be for her to get one. But throwing herself in the midst of a clutch of hungry zombies is quite a risky endeavor. Hence Heidi wonders: what is the smallest number of brains that must be in the chest for her to get out at all (possibly empty-handed, but alive)?
The brain dinner night will evolve just as in the previous subtask: the same crowd is present, the N - 1 zombies have the exact same mindset as before and Heidi is to make the first proposal, which must be accepted by at least half of the attendees for her to survive.
Input
The only line of input contains one integer: N, the number of attendees (1 ≤ N ≤ 109).
Output
Output one integer: the smallest number of brains in the chest which allows Heidi to merely survive.
Examples
Input
1
Output
0
Input
3
Output
1
Input
99
Output
49
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a;
long long dva = 2;
cin >> a;
if (a % 2 == 1)
cout << (a - 1) / 2;
else {
while (dva * 2 <= a) {
dva *= 2;
}
cout << (a - dva) / 2;
}
return 0;
}
|
There are n casinos lined in a row. If Memory plays at casino i, he has probability pi to win and move to the casino on the right (i + 1) or exit the row (if i = n), and a probability 1 - pi to lose and move to the casino on the left (i - 1) or also exit the row (if i = 1).
We say that Memory dominates on the interval i... j if he completes a walk such that,
* He starts on casino i.
* He never looses in casino i.
* He finishes his walk by winning in casino j.
Note that Memory can still walk left of the 1-st casino and right of the casino n and that always finishes the process.
Now Memory has some requests, in one of the following forms:
* 1 i a b: Set <image>.
* 2 l r: Print the probability that Memory will dominate on the interval l... r, i.e. compute the probability that Memory will first leave the segment l... r after winning at casino r, if she starts in casino l.
It is guaranteed that at any moment of time p is a non-decreasing sequence, i.e. pi ≤ pi + 1 for all i from 1 to n - 1.
Please help Memory by answering all his requests!
Input
The first line of the input contains two integers n and q(1 ≤ n, q ≤ 100 000), — number of casinos and number of requests respectively.
The next n lines each contain integers ai and bi (1 ≤ ai < bi ≤ 109) — <image> is the probability pi of winning in casino i.
The next q lines each contain queries of one of the types specified above (1 ≤ a < b ≤ 109, 1 ≤ i ≤ n, 1 ≤ l ≤ r ≤ n).
It's guaranteed that there will be at least one query of type 2, i.e. the output will be non-empty. Additionally, it is guaranteed that p forms a non-decreasing sequence at all times.
Output
Print a real number for every request of type 2 — the probability that boy will "dominate" on that interval. Your answer will be considered correct if its absolute error does not exceed 10 - 4.
Namely: let's assume that one of your answers is a, and the corresponding answer of the jury is b. The checker program will consider your answer correct if |a - b| ≤ 10 - 4.
Example
Input
3 13
1 3
1 2
2 3
2 1 1
2 1 2
2 1 3
2 2 2
2 2 3
2 3 3
1 2 2 3
2 1 1
2 1 2
2 1 3
2 2 2
2 2 3
2 3 3
Output
0.3333333333
0.2000000000
0.1666666667
0.5000000000
0.4000000000
0.6666666667
0.3333333333
0.2500000000
0.2222222222
0.6666666667
0.5714285714
0.6666666667
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
pair<long double, long double> st[4 * N];
int n, q;
template <typename T>
pair<T, T> operator+(const pair<T, T> &a, const pair<T, T> &b) {
pair<T, T> res;
res.first = a.first + b.first * a.second;
res.second = a.second * b.second;
return res;
}
void update(int id, int l, int r, int pos, long double val) {
if (l > pos || r < pos) return;
if (l == r) {
st[id] = make_pair(val, val);
return;
}
int mid = (l + r) >> 1;
update(id << 1, l, mid, pos, val);
update(id << 1 | 1, mid + 1, r, pos, val);
st[id] = st[id << 1] + st[id << 1 | 1];
}
pair<long double, long double> getsum(int id, int l, int r, int u, int v) {
if (l > v || r < u) return make_pair(0, 1);
if (l >= u && r <= v) return st[id];
int mid = (l + r) >> 1;
pair<long double, long double> lnode = getsum(id << 1, l, mid, u, v);
pair<long double, long double> rnode = getsum(id << 1 | 1, mid + 1, r, u, v);
return lnode + rnode;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q;
for (int i = 1; i <= n; i++) {
int a, b;
cin >> a >> b;
long double p = (long double)a / b;
update(1, 1, n, i, (1.0L - p) / p);
}
while (q--) {
int op;
cin >> op;
if (op == 1) {
int pos, a, b;
cin >> pos >> a >> b;
long double p = (long double)a / b;
update(1, 1, n, pos, (1.0L - p) / p);
} else {
int l, r;
cin >> l >> r;
long double res = 1 + getsum(1, 1, n, l, r).first;
long double ans = (1.0L / res);
if (ans != ans) ans = 0;
cout << fixed << setprecision(9) << ans << "\n";
}
}
return 0;
}
|
Kostya is a genial sculptor, he has an idea: to carve a marble sculpture in the shape of a sphere. Kostya has a friend Zahar who works at a career. Zahar knows about Kostya's idea and wants to present him a rectangular parallelepiped of marble from which he can carve the sphere.
Zahar has n stones which are rectangular parallelepipeds. The edges sizes of the i-th of them are ai, bi and ci. He can take no more than two stones and present them to Kostya.
If Zahar takes two stones, he should glue them together on one of the faces in order to get a new piece of rectangular parallelepiped of marble. Thus, it is possible to glue a pair of stones together if and only if two faces on which they are glued together match as rectangles. In such gluing it is allowed to rotate and flip the stones in any way.
Help Zahar choose such a present so that Kostya can carve a sphere of the maximum possible volume and present it to Zahar.
Input
The first line contains the integer n (1 ≤ n ≤ 105).
n lines follow, in the i-th of which there are three integers ai, bi and ci (1 ≤ ai, bi, ci ≤ 109) — the lengths of edges of the i-th stone. Note, that two stones may have exactly the same sizes, but they still will be considered two different stones.
Output
In the first line print k (1 ≤ k ≤ 2) the number of stones which Zahar has chosen. In the second line print k distinct integers from 1 to n — the numbers of stones which Zahar needs to choose. Consider that stones are numbered from 1 to n in the order as they are given in the input data.
You can print the stones in arbitrary order. If there are several answers print any of them.
Examples
Input
6
5 5 5
3 2 4
1 4 1
2 1 3
3 2 4
3 3 4
Output
1
1
Input
7
10 7 8
5 10 3
4 2 6
5 5 5
10 2 8
4 2 1
7 7 7
Output
2
1 5
Note
In the first example we can connect the pairs of stones:
* 2 and 4, the size of the parallelepiped: 3 × 2 × 5, the radius of the inscribed sphere 1
* 2 and 5, the size of the parallelepiped: 3 × 2 × 8 or 6 × 2 × 4 or 3 × 4 × 4, the radius of the inscribed sphere 1, or 1, or 1.5 respectively.
* 2 and 6, the size of the parallelepiped: 3 × 5 × 4, the radius of the inscribed sphere 1.5
* 4 and 5, the size of the parallelepiped: 3 × 2 × 5, the radius of the inscribed sphere 1
* 5 and 6, the size of the parallelepiped: 3 × 4 × 5, the radius of the inscribed sphere 1.5
Or take only one stone:
* 1 the size of the parallelepiped: 5 × 5 × 5, the radius of the inscribed sphere 2.5
* 2 the size of the parallelepiped: 3 × 2 × 4, the radius of the inscribed sphere 1
* 3 the size of the parallelepiped: 1 × 4 × 1, the radius of the inscribed sphere 0.5
* 4 the size of the parallelepiped: 2 × 1 × 3, the radius of the inscribed sphere 0.5
* 5 the size of the parallelepiped: 3 × 2 × 4, the radius of the inscribed sphere 1
* 6 the size of the parallelepiped: 3 × 3 × 4, the radius of the inscribed sphere 1.5
It is most profitable to take only the first stone.
|
n = int(input())
data = {}
ans = 0
res = 0
pos = 0
ind = []
for i in range(n):
tmp = sorted(list(map(int, input().split())))
if min(tmp) > ans:
ans = min(tmp)
ind = [i, -1]
t = (tmp[1], tmp[2])
if t in data:
third, _ = data[t]
if min([third + tmp[0], tmp[1], tmp[2]]) > ans:
ans = min([third + tmp[0], tmp[1], tmp[2]])
ind = [i, data[t][1]]
if third < tmp[0]:
data[t] = (tmp[0], i)
else:
data[t] = (tmp[0], i)
if ind[1] == -1:
print(1)
print(ind[0] + 1)
else:
print(2)
print(ind[0] + 1, ind[1] + 1)
|
Bash got tired on his journey to become the greatest Pokemon master. So he decides to take a break and play with functions.
Bash defines a function f0(n), which denotes the number of ways of factoring n into two factors p and q such that gcd(p, q) = 1. In other words, f0(n) is the number of ordered pairs of positive integers (p, q) such that p·q = n and gcd(p, q) = 1.
But Bash felt that it was too easy to calculate this function. So he defined a series of functions, where fr + 1 is defined as:
<image>
Where (u, v) is any ordered pair of positive integers, they need not to be co-prime.
Now Bash wants to know the value of fr(n) for different r and n. Since the value could be huge, he would like to know the value modulo 109 + 7. Help him!
Input
The first line contains an integer q (1 ≤ q ≤ 106) — the number of values Bash wants to know.
Each of the next q lines contain two integers r and n (0 ≤ r ≤ 106, 1 ≤ n ≤ 106), which denote Bash wants to know the value fr(n).
Output
Print q integers. For each pair of r and n given, print fr(n) modulo 109 + 7 on a separate line.
Example
Input
5
0 30
1 25
3 65
2 5
4 48
Output
8
5
25
4
630
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, MOD = 1e9 + 7;
inline int read() {
char c = getchar();
int x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int Q, n, r, d[N][21];
int notp[N], p[N];
void sieve(int n) {
for (int i = 2; i <= n; i++) {
if (!notp[i]) p[++p[0]] = i;
for (int j = 1; j <= p[0] && i * p[j] <= n; j++) {
notp[i * p[j]] = 1;
if (i % p[j] == 0) break;
}
}
}
void dp() {
for (int i = 1; i <= 20; i++) d[0][i] = 2;
for (int i = 1; i < N; i++) {
d[i][0] = 1;
for (int j = 1; j <= 20; j++) d[i][j] = (d[i - 1][j] + d[i][j - 1]) % MOD;
}
}
void solve(int r, int n) {
long long ans = 1;
int m = sqrt(n);
for (int i = 1; i <= p[0] && p[i] <= m; i++)
if (n % p[i] == 0) {
int e = 0;
while (n % p[i] == 0) e++, n /= p[i];
ans = (ans * d[r][e]) % MOD;
}
if (n != 1) ans = (ans * d[r][1]) % MOD;
printf("%I64d\n", ans);
}
int main() {
sieve(N - 1);
dp();
Q = read();
while (Q--) {
r = read();
n = read();
solve(r, n);
}
}
|
Polycarp is crazy about round numbers. He especially likes the numbers divisible by 10k.
In the given number of n Polycarp wants to remove the least number of digits to get a number that is divisible by 10k. For example, if k = 3, in the number 30020 it is enough to delete a single digit (2). In this case, the result is 3000 that is divisible by 103 = 1000.
Write a program that prints the minimum number of digits to be deleted from the given integer number n, so that the result is divisible by 10k. The result should not start with the unnecessary leading zero (i.e., zero can start only the number 0, which is required to be written as exactly one digit).
It is guaranteed that the answer exists.
Input
The only line of the input contains two integer numbers n and k (0 ≤ n ≤ 2 000 000 000, 1 ≤ k ≤ 9).
It is guaranteed that the answer exists. All numbers in the input are written in traditional notation of integers, that is, without any extra leading zeros.
Output
Print w — the required minimal number of digits to erase. After removing the appropriate w digits from the number n, the result should have a value that is divisible by 10k. The result can start with digit 0 in the single case (the result is zero and written by exactly the only digit 0).
Examples
Input
30020 3
Output
1
Input
100 9
Output
2
Input
10203049 2
Output
3
Note
In the example 2 you can remove two digits: 1 and any 0. The result is number 0 which is divisible by any number.
|
n , k = map(int,input().split())
n = list(str(n))
counter = 0
zero_counter = 0
if n.count('0') >= k :
for i in range(len(n)-1 , -1 , -1):
if (n[i] != '0'):
counter += 1
if (n[i] == '0'):
zero_counter += 1
if (zero_counter == k):
break
print(counter)
else:
print(len(n) - 1)
|
Heidi's friend Jenny is asking Heidi to deliver an important letter to one of their common friends. Since Jenny is Irish, Heidi thinks that this might be a prank. More precisely, she suspects that the message she is asked to deliver states: "Send the fool further!", and upon reading it the recipient will ask Heidi to deliver the same message to yet another friend (that the recipient has in common with Heidi), and so on.
Heidi believes that her friends want to avoid awkward situations, so she will not be made to visit the same person (including Jenny) twice. She also knows how much it costs to travel between any two of her friends who know each other. She wants to know: what is the maximal amount of money she will waste on travel if it really is a prank?
Heidi's n friends are labeled 0 through n - 1, and their network of connections forms a tree. In other words, every two of her friends a, b know each other, possibly indirectly (there is a sequence of friends starting from a and ending on b and such that each two consecutive friends in the sequence know each other directly), and there are exactly n - 1 pairs of friends who know each other directly.
Jenny is given the number 0.
Input
The first line of the input contains the number of friends n (3 ≤ n ≤ 100). The next n - 1 lines each contain three space-separated integers u, v and c (0 ≤ u, v ≤ n - 1, 1 ≤ c ≤ 104), meaning that u and v are friends (know each other directly) and the cost for travelling between u and v is c.
It is guaranteed that the social network of the input forms a tree.
Output
Output a single integer – the maximum sum of costs.
Examples
Input
4
0 1 4
0 2 2
2 3 3
Output
5
Input
6
1 2 3
0 2 100
1 4 2
0 3 7
3 5 10
Output
105
Input
11
1 0 1664
2 0 881
3 2 4670
4 2 1555
5 1 1870
6 2 1265
7 2 288
8 7 2266
9 2 1536
10 6 3378
Output
5551
Note
In the second example, the worst-case scenario goes like this: Jenny sends Heidi to the friend labeled by number 2 (incurring a cost of 100), then friend 2 sends her to friend 1 (costing Heidi 3), and finally friend 1 relays her to friend 4 (incurring an additional cost of 2).
|
def dfs(u,cur):
global ans
vis[u]=True
flag=True
for x in vec[u] :
v=x[0]
c=x[1]
if not vis[v] :
dfs(v,cur+c)
flag=False
if flag:
ans=max(cur,ans)
ans=0
vec=[]
vis=[]
i=0
n=int(input())
while(i<n) :
vec.append([])
vis.append(False)
i+=1
i=1
while(i<n):
u,v,c=(int(x) for x in input().split(' '))
vec[u].append((v,c))
vec[v].append((u,c))
i+=1
dfs(0,0)
print(ans)
|
Ivan wants to write a letter to his friend. The letter is a string s consisting of lowercase Latin letters.
Unfortunately, when Ivan started writing the letter, he realised that it is very long and writing the whole letter may take extremely long time. So he wants to write the compressed version of string s instead of the string itself.
The compressed version of string s is a sequence of strings c1, s1, c2, s2, ..., ck, sk, where ci is the decimal representation of number ai (without any leading zeroes) and si is some string consisting of lowercase Latin letters. If Ivan writes string s1 exactly a1 times, then string s2 exactly a2 times, and so on, the result will be string s.
The length of a compressed version is |c1| + |s1| + |c2| + |s2|... |ck| + |sk|. Among all compressed versions Ivan wants to choose a version such that its length is minimum possible. Help Ivan to determine minimum possible length.
Input
The only line of input contains one string s consisting of lowercase Latin letters (1 ≤ |s| ≤ 8000).
Output
Output one integer number — the minimum possible length of a compressed version of s.
Examples
Input
aaaaaaaaaa
Output
3
Input
abcab
Output
6
Input
cczabababab
Output
7
Note
In the first example Ivan will choose this compressed version: c1 is 10, s1 is a.
In the second example Ivan will choose this compressed version: c1 is 1, s1 is abcab.
In the third example Ivan will choose this compressed version: c1 is 2, s1 is c, c2 is 1, s2 is z, c3 is 4, s3 is ab.
|
#include <bits/stdc++.h>
using namespace std;
int MOD = 1e9 + 7;
int PRIME = 102838201;
int INF = 1e9;
vector<string> &split(const std::string &s, char delim, vector<string> &e) {
stringstream ss(s);
string item;
while (getline(ss, item, delim)) e.push_back(item);
return e;
}
int Pow(int a, int b, int Mo) {
int ans = 1;
for (; b; b >>= 1, a = a * a % Mo)
if (b & 1) ans = ans * a % Mo;
return ans;
}
int nCr(int n, int r) {
static int MAXF = 1e6;
static std::vector<int> fact(MAXF, 1);
for (int i = 1; i < MAXF; ++i) fact[i] = (fact[i - 1] * i) % MOD;
MAXF = 0;
return (fact[n] * Pow((fact[r] * fact[n - r]) % MOD, MOD - 2, MOD)) % MOD;
}
vector<int> Zfunc(string &s) {
int n = s.length();
vector<int> z(n, 0);
for (int i = 1, l = 0, r = 0; i < n; i++) {
if (i <= r) z[i] = min(z[i - l], r - i + 1);
while (i + z[i] < n && s[i + z[i]] == s[z[i]]) z[i]++;
if (r < i + z[i] - 1) l = i, r = i + z[i] - 1;
}
z[0] = s.length();
return z;
}
int solve() { return 0; }
int di(int x) {
int c = 0;
while (x > 0) {
x /= 10;
c++;
}
if (!c) c++;
return c;
}
std::vector<int> DP;
std::vector<std::vector<int> > lon;
int n;
int moves = 0;
int main(int argc, char const *argv[]) {
std::ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
n = s.length();
DP.resize(n + 1, INF);
lon.resize(n + 1);
DP[n] = 0;
for (int i = 0; i < n; ++i) {
string s2 = s.substr(i, n - i);
lon[i] = Zfunc(s2);
}
for (int index = n - 1; index >= 0; --index) {
int ans = 1 + n - index;
for (int j = index; j < n; ++j) {
ans = min(1 + j - index + 1 + DP[(j + 1)], ans);
}
for (int p = 1; p + index < n; ++p) {
int common = lon[index][p] + p;
int repeatedlen = (common) / p;
for (int k = 1; k <= repeatedlen; ++k) {
ans = min(di(k) + p + DP[(k * p + index)], ans);
}
}
DP[index] = ans;
}
cout << DP[0];
return 0;
}
|
A never-ending, fast-changing and dream-like world unfolds, as the secret door opens.
A world is an unordered graph G, in whose vertex set V(G) there are two special vertices s(G) and t(G). An initial world has vertex set {s(G), t(G)} and an edge between them.
A total of n changes took place in an initial world. In each change, a new vertex w is added into V(G), an existing edge (u, v) is chosen, and two edges (u, w) and (v, w) are added into E(G). Note that it's possible that some edges are chosen in more than one change.
It's known that the capacity of the minimum s-t cut of the resulting graph is m, that is, at least m edges need to be removed in order to make s(G) and t(G) disconnected.
Count the number of non-similar worlds that can be built under the constraints, modulo 109 + 7. We define two worlds similar, if they are isomorphic and there is isomorphism in which the s and t vertices are not relabelled. Formally, two worlds G and H are considered similar, if there is a bijection between their vertex sets <image>, such that:
* f(s(G)) = s(H);
* f(t(G)) = t(H);
* Two vertices u and v of G are adjacent in G if and only if f(u) and f(v) are adjacent in H.
Input
The first and only line of input contains two space-separated integers n, m (1 ≤ n, m ≤ 50) — the number of operations performed and the minimum cut, respectively.
Output
Output one integer — the number of non-similar worlds that can be built, modulo 109 + 7.
Examples
Input
3 2
Output
6
Input
4 4
Output
3
Input
7 3
Output
1196
Input
31 8
Output
64921457
Note
In the first example, the following 6 worlds are pairwise non-similar and satisfy the constraints, with s(G) marked in green, t(G) marked in blue, and one of their minimum cuts in light blue.
<image>
In the second example, the following 3 worlds satisfy the constraints.
<image>
|
#include <bits/stdc++.h>
using namespace std;
inline void Add(int& x, int y) { x = (x + y) % 1000000007; }
int i, j, k, n, m, p, q, f[60][60], g[60][60], F[60][60], t, inv[60];
int c;
int main() {
scanf("%d%d", &n, &m);
for (i = 2, inv[0] = inv[1] = 1; i <= n; i++)
inv[i] =
1ll * inv[1000000007 % i] * (1000000007 - 1000000007 / i) % 1000000007;
f[0][1] = 1;
for (i = 1; i <= n; i++)
for (j = 1; j <= i + 1; j++) {
for (p = 0; p <= i - 1; p++) {
for (q = j; q <= p + 1; q++)
Add(g[i][j], 1ll * f[p][q] * f[i - 1 - p][j] % 1000000007);
for (q = j + 1; q <= i - p; q++)
Add(g[i][j], 1ll * f[p][j] * f[i - 1 - p][q] % 1000000007);
}
memset(F, 0, sizeof(F));
for (k = 0; k <= n; k++)
for (p = 1; p <= k + 1; p++) {
c = 1;
for (q = 1; k + q * i <= n; q++) {
c = 1ll * c * (g[i][j] + q - 1) % 1000000007 * inv[q] % 1000000007;
Add(F[k + q * i][p + q * j], 1ll * f[k][p] * c % 1000000007);
}
}
for (k = 0; k <= n; k++)
for (p = 1; p <= k + 1; p++) Add(f[k][p], F[k][p]);
}
cout << f[n][m] << endl;
return 0;
}
|
You are given an array a1, a2, ..., an consisting of n integers, and an integer k. You have to split the array into exactly k non-empty subsegments. You'll then compute the minimum integer on each subsegment, and take the maximum integer over the k obtained minimums. What is the maximum possible integer you can get?
Definitions of subsegment and array splitting are given in notes.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105) — the size of the array a and the number of subsegments you have to split the array to.
The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print single integer — the maximum possible integer you can get if you split the array into k non-empty subsegments and take maximum of minimums on the subsegments.
Examples
Input
5 2
1 2 3 4 5
Output
5
Input
5 1
-4 -5 -3 -2 -1
Output
-5
Note
A subsegment [l, r] (l ≤ r) of array a is the sequence al, al + 1, ..., ar.
Splitting of array a of n elements into k subsegments [l1, r1], [l2, r2], ..., [lk, rk] (l1 = 1, rk = n, li = ri - 1 + 1 for all i > 1) is k sequences (al1, ..., ar1), ..., (alk, ..., ark).
In the first example you should split the array into subsegments [1, 4] and [5, 5] that results in sequences (1, 2, 3, 4) and (5). The minimums are min(1, 2, 3, 4) = 1 and min(5) = 5. The resulting maximum is max(1, 5) = 5. It is obvious that you can't reach greater result.
In the second example the only option you have is to split the array into one subsegment [1, 5], that results in one sequence ( - 4, - 5, - 3, - 2, - 1). The only minimum is min( - 4, - 5, - 3, - 2, - 1) = - 5. The resulting maximum is - 5.
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9 + 113;
const long long maxn = 1e5 + 113;
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
vector<int> s1;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
s1.push_back(a);
}
int ans = s1[0];
if (k == 1) {
for (int i = 0; i < n; i++) ans = min(ans, s1[i]);
cout << ans;
return 0;
}
int maxn = s1[0];
for (int i = 0; i < n; i++) maxn = max(maxn, s1[i]);
if (k >= 3) {
cout << maxn;
return 0;
}
if (k == 2) {
cout << max(s1[0], s1[s1.size() - 1]);
return 0;
}
}
|
Are you going to Scarborough Fair?
Parsley, sage, rosemary and thyme.
Remember me to one who lives there.
He once was the true love of mine.
Willem is taking the girl to the highest building in island No.28, however, neither of them knows how to get there.
Willem asks his friend, Grick for directions, Grick helped them, and gave them a task.
Although the girl wants to help, Willem insists on doing it by himself.
Grick gave Willem a string of length n.
Willem needs to do m operations, each operation has four parameters l, r, c1, c2, which means that all symbols c1 in range [l, r] (from l-th to r-th, including l and r) are changed into c2. String is 1-indexed.
Grick wants to know the final string after all the m operations.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 100).
The second line contains a string s of length n, consisting of lowercase English letters.
Each of the next m lines contains four parameters l, r, c1, c2 (1 ≤ l ≤ r ≤ n, c1, c2 are lowercase English letters), separated by space.
Output
Output string s after performing m operations described above.
Examples
Input
3 1
ioi
1 1 i n
Output
noi
Input
5 3
wxhak
3 3 h x
1 5 x a
1 3 w g
Output
gaaak
Note
For the second example:
After the first operation, the string is wxxak.
After the second operation, the string is waaak.
After the third operation, the string is gaaak.
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class IOtest {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
StringTokenizer str = new StringTokenizer(in.readLine());
int n = Integer.parseInt(str.nextToken());
int m = Integer.parseInt(str.nextToken());
StringBuilder strb = new StringBuilder(in.readLine());
int l[] = new int[m];
int r[] = new int[m];
char c1[] = new char[m];
char c2[] = new char[m];
int j = 0;
while (j < m) {
str = new StringTokenizer(in.readLine());
l[j] = Integer.parseInt(str.nextToken());
r[j] = Integer.parseInt(str.nextToken());
c1[j] = str.nextToken().charAt(0);
c2[j] = str.nextToken().charAt(0);
j++;
}
j = 0;
while (j < m) {
int i = l[j] - 1;
while (i <= r[j] - 1) {
if (strb.charAt(i) == c1[j])
strb.setCharAt(i, c2[j]);
i++;
}
j++;
}
out.println(strb.toString());
out.flush();
}
public static boolean isEvenBit(int i) {
return (i & 1) == 0;
}
}
|
As the guys fried the radio station facilities, the school principal gave them tasks as a punishment. Dustin's task was to add comments to nginx configuration for school's website. The school has n servers. Each server has a name and an ip (names aren't necessarily unique, but ips are). Dustin knows the ip and name of each server. For simplicity, we'll assume that an nginx command is of form "command ip;" where command is a string consisting of English lowercase letter only, and ip is the ip of one of school servers.
<image>
Each ip is of form "a.b.c.d" where a, b, c and d are non-negative integers less than or equal to 255 (with no leading zeros). The nginx configuration file Dustin has to add comments to has m commands. Nobody ever memorizes the ips of servers, so to understand the configuration better, Dustin has to comment the name of server that the ip belongs to at the end of each line (after each command). More formally, if a line is "command ip;" Dustin has to replace it with "command ip; #name" where name is the name of the server with ip equal to ip.
Dustin doesn't know anything about nginx, so he panicked again and his friends asked you to do his task for him.
Input
The first line of input contains two integers n and m (1 ≤ n, m ≤ 1000).
The next n lines contain the names and ips of the servers. Each line contains a string name, name of the server and a string ip, ip of the server, separated by space (1 ≤ |name| ≤ 10, name only consists of English lowercase letters). It is guaranteed that all ip are distinct.
The next m lines contain the commands in the configuration file. Each line is of form "command ip;" (1 ≤ |command| ≤ 10, command only consists of English lowercase letters). It is guaranteed that ip belongs to one of the n school servers.
Output
Print m lines, the commands in the configuration file after Dustin did his task.
Examples
Input
2 2
main 192.168.0.2
replica 192.168.0.1
block 192.168.0.1;
proxy 192.168.0.2;
Output
block 192.168.0.1; #replica
proxy 192.168.0.2; #main
Input
3 5
google 8.8.8.8
codeforces 212.193.33.27
server 138.197.64.57
redirect 138.197.64.57;
block 8.8.8.8;
cf 212.193.33.27;
unblock 8.8.8.8;
check 138.197.64.57;
Output
redirect 138.197.64.57; #server
block 8.8.8.8; #google
cf 212.193.33.27; #codeforces
unblock 8.8.8.8; #google
check 138.197.64.57; #server
|
a , b = map(int , input().split())
names = dict()
for i in range(a):
x , y = input().split()
names[y] = x
for i in range(b):
com = input()
h = com.split()[-1][:-1]
print(f"{com} #{names[h]}")
|
Right now she actually isn't. But she will be, if you don't solve this problem.
You are given integers n, k, A and B. There is a number x, which is initially equal to n. You are allowed to perform two types of operations:
1. Subtract 1 from x. This operation costs you A coins.
2. Divide x by k. Can be performed only if x is divisible by k. This operation costs you B coins.
What is the minimum amount of coins you have to pay to make x equal to 1?
Input
The first line contains a single integer n (1 ≤ n ≤ 2·109).
The second line contains a single integer k (1 ≤ k ≤ 2·109).
The third line contains a single integer A (1 ≤ A ≤ 2·109).
The fourth line contains a single integer B (1 ≤ B ≤ 2·109).
Output
Output a single integer — the minimum amount of coins you have to pay to make x equal to 1.
Examples
Input
9
2
3
1
Output
6
Input
5
5
2
20
Output
8
Input
19
3
4
2
Output
12
Note
In the first testcase, the optimal strategy is as follows:
* Subtract 1 from x (9 → 8) paying 3 coins.
* Divide x by 2 (8 → 4) paying 1 coin.
* Divide x by 2 (4 → 2) paying 1 coin.
* Divide x by 2 (2 → 1) paying 1 coin.
The total cost is 6 coins.
In the second test case the optimal strategy is to subtract 1 from x 4 times paying 8 coins in total.
|
import java.util.*;
import java.io.*;
import java.lang.*;
public class codeforces
{
public static void main(String[] args)
{
InputReader in = new InputReader(System.in);
PrintWriter pw = new PrintWriter(System.out);
//Code starts..
long n = in.nextInt();;
long k = in.nextInt();
long a = in.nextInt();
long b = in.nextInt();
long ans = 0;
if(k>1)
{
while(n!=1)
{
if(n%k!=0)
{
ans += (n - k*(n/k))*a;
n = k*(n/k);
}
if(n>k )
{
if(b <= a*(n -(n/k)))
{
ans += b;
n /=k;
}
else
{
ans += a*(n -(n/k));
n /= k;
}
}
if(n==k)
{
ans += Math.min(b, (n-1)*a);
n=1;
}
if(n<k)
{
ans += (n-1)*a;
n = 1;
}
}
pw.print(ans);
}
else
pw.println((n-1)*a);
//Code ends....
pw.flush();
pw.close();
}
static class InputReader
{
private final InputStream stream;
private final byte[] buf = new byte[8192];
private int curChar, snumChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream)
{
this.stream = stream;
}
public int snext()
{
if (snumChars == -1)
throw new InputMismatchException();
if (curChar >= snumChars)
{
curChar = 0;
try
{
snumChars = stream.read(buf);
}
catch (IOException e)
{
throw new InputMismatchException();
}
if (snumChars <= 0)
return -1;
}
return buf[curChar++];
}
public int nextInt()
{
int c = snext();
while (isSpaceChar(c))
{
c = snext();
}
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = snext();
}
int res = 0;
do
{
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = snext();
} while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong()
{
int c = snext();
while (isSpaceChar(c))
{
c = snext();
}
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = snext();
}
long res = 0;
do
{
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = snext();
} while (!isSpaceChar(c));
return res * sgn;
}
public int[] nextIntArray(int n)
{
int a[] = new int[n];
for (int i = 0; i < n; i++)
{
a[i] = nextInt();
}
return a;
}
public String readString()
{
int c = snext();
while (isSpaceChar(c))
{
c = snext();
}
StringBuilder res = new StringBuilder();
do
{
res.appendCodePoint(c);
c = snext();
} while (!isSpaceChar(c));
return res.toString();
}
public String nextLine()
{
int c = snext();
while (isSpaceChar(c))
c = snext();
StringBuilder res = new StringBuilder();
do
{
res.appendCodePoint(c);
c = snext();
} while (!isEndOfLine(c));
return res.toString();
}
public boolean isSpaceChar(int c)
{
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
private boolean isEndOfLine(int c)
{
return c == '\n' || c == '\r' || c == -1;
}
public interface SpaceCharFilter
{
public boolean isSpaceChar(int ch);
}
}
public static long c = 0;
public static long mod = 1000000007;
public static int d;
public static int p;
public static int q;
public static int gcd(int p2, int p22)
{
if (p2 == 0)
return (int) p22;
return gcd(p22%p2, p2);
}
public static int findGCD(int arr[], int n)
{
int result = arr[0];
for (int i=1; i<n; i++)
result = gcd(arr[i], result);
return result;
}
public static long lcm(int[] numbers) {
long lcm = 1;
int divisor = 2;
while (true) {
int cnt = 0;
boolean divisible = false;
for (int i = 0; i < numbers.length; i++) {
if (numbers[i] == 0) {
return 0;
} else if (numbers[i] < 0) {
numbers[i] = numbers[i] * (-1);
}
if (numbers[i] == 1) {
cnt++;
}
if (numbers[i] % divisor == 0) {
divisible = true;
numbers[i] = numbers[i] / divisor;
}
}
if (divisible) {
lcm = lcm * divisor;
} else {
divisor++;
}
if (cnt == numbers.length) {
return lcm;
}
}
}
public static long fact(long n) {
long factorial = 1;
for(int i = 1; i <= n; i++)
{
factorial *= i;
}
return factorial;
}
public static int lowerLimit(int[] a, int n) {
int ans = 0;
int ll = 0;
int rl = a.length-1;
// System.out.println(a[rl]+" "+n);
if(a[0]>n)
return 0;
if(a[0]==n)
return 1;
else if(a[rl]<=n)
return rl+1;
while(ll<=rl)
{
int mid = (ll+rl)/2;
if(a[mid]==n)
{
ans = mid + 1;
break;
}
else if(a[mid]>n)
{
rl = mid-1;
}
else
{
ans = mid+1;
ll = mid+1;
}
}
return ans;
}
public static long choose(long total, long choose){
if(total < choose)
return 0;
if(choose == 0 || choose == total)
return 1;
return (choose(total-1,choose-1)+choose(total-1,choose))%mod;
}
public static int[] suffle(int[] a,Random gen)
{
int n = a.length;
for(int i=0;i<n;i++)
{
int ind = gen.nextInt(n-i)+i;
int temp = a[ind];
a[ind] = a[i];
a[i] = temp;
}
return a;
}
public static int floorSearch(int arr[], int low, int high, int x)
{
if (low > high)
return -1;
if (x > arr[high])
return high;
int mid = (low+high)/2;
if (mid > 0 && arr[mid-1] < x && x < arr[mid])
return mid-1;
if (x < arr[mid])
return floorSearch(arr, low, mid-1, x);
return floorSearch(arr, mid+1, high, x);
}
public static void swap(int a, int b){
int temp = a;
a = b;
b = temp;
}
public static ArrayList<Integer> primeFactorization(int n)
{
ArrayList<Integer> a =new ArrayList<Integer>();
for(int i=2;i*i<=n;i++)
{
while(n%i==0)
{
a.add(i);
n/=i;
}
}
if(n!=1)
a.add(n);
return a;
}
public static void sieve(boolean[] isPrime,int n)
{
for(int i=1;i<n;i++)
isPrime[i] = true;
isPrime[0] = false;
isPrime[1] = false;
for(int i=2;i*i<n;i++)
{
if(isPrime[i] == true)
{
for(int j=(2*i);j<n;j+=i)
isPrime[j] = false;
}
}
}
public static int GCD(int a,int b)
{
if(b==0)
return a;
else
return GCD(b,a%b);
}
public static long GCD(long a,long b)
{
if(b==0)
return a;
else
return GCD(b,a%b);
}
public static void extendedEuclid(int A,int B)
{
if(B==0)
{
d = A;
p = 1 ;
q = 0;
}
else
{
extendedEuclid(B, A%B);
int temp = p;
p = q;
q = temp - (A/B)*q;
}
}
public static long LCM(long a,long b)
{
return (a*b)/GCD(a,b);
}
public static int LCM(int a,int b)
{
return (a*b)/GCD(a,b);
}
public static int binaryExponentiation(int x,int n)
{
int result=1;
while(n>0)
{
if(n % 2 ==1)
result=result * x;
x=x*x;
n=n/2;
}
return result;
}
public static long binaryExponentiation(long x,long n)
{
long result=1;
while(n>0)
{
if(n % 2 ==1)
result=result * x;
x=(x%mod * x%mod)%mod;
n=n/2;
}
return result;
}
public static int modularExponentiation(int x,int n,int M)
{
int result=1;
while(n>0)
{
if(n % 2 ==1)
result=(result * x)%M;
x=(x*x)%M;
n=n/2;
}
return result;
}
public static long modularExponentiation(long x,long n,long M)
{
long result=1;
while(n>0)
{
if(n % 2 ==1)
result=(result * x)%M;
x=(x*x)%M;
n=n/2;
}
return result;
}
public static int modInverse(int A,int M)
{
return modularExponentiation(A,M-2,M);
}
public static long modInverse(long A,long M)
{
return modularExponentiation(A,M-2,M);
}
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;
}
static class pair implements Comparable<pair>
{
Integer x, y;
pair(int x,int y)
{
this.x=x;
this.y=y;
}
public int compareTo(pair o) {
int result = x.compareTo(o.x);
if(result==0)
result = y.compareTo(o.y);
return result;
}
public String toString()
{
return x+" "+y;
}
public boolean equals(Object o)
{
if (o instanceof pair)
{
pair p = (pair)o;
return p.x == x && p.y == y ;
}
return false;
}
public int hashCode()
{
return new Long(x).hashCode()*31 + new Long(y).hashCode();
}
}
static class node implements Comparable<node>
{
Integer x, y, z;
node(int x,int y, int z)
{
this.x=x;
this.y=y;
this.z=z;
}
public int compareTo(pair o) {
int result = x.compareTo(o.x);
if(result==0)
result = y.compareTo(o.y);
if(result==0)
result = z.compareTo(z);
return result;
}
@Override
public int compareTo(node o) {
// TODO Auto-generated method stub
return 0;
}
}
}
|
Vitya has learned that the answer for The Ultimate Question of Life, the Universe, and Everything is not the integer 54 42, but an increasing integer sequence a_1, …, a_n. In order to not reveal the secret earlier than needed, Vitya encrypted the answer and obtained the sequence b_1, …, b_n using the following rules:
* b_1 = a_1;
* b_i = a_i ⊕ a_{i - 1} for all i from 2 to n, where x ⊕ y is the [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of x and y.
It is easy to see that the original sequence can be obtained using the rule a_i = b_1 ⊕ … ⊕ b_i.
However, some time later Vitya discovered that the integers b_i in the cypher got shuffled, and it can happen that when decrypted using the rule mentioned above, it can produce a sequence that is not increasing. In order to save his reputation in the scientific community, Vasya decided to find some permutation of integers b_i so that the sequence a_i = b_1 ⊕ … ⊕ b_i is strictly increasing. Help him find such a permutation or determine that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5).
The second line contains n integers b_1, …, b_n (1 ≤ b_i < 2^{60}).
Output
If there are no valid permutations, print a single line containing "No".
Otherwise in the first line print the word "Yes", and in the second line print integers b'_1, …, b'_n — a valid permutation of integers b_i. The unordered multisets \\{b_1, …, b_n\} and \\{b'_1, …, b'_n\} should be equal, i. e. for each integer x the number of occurrences of x in the first multiset should be equal to the number of occurrences of x in the second multiset. Apart from this, the sequence a_i = b'_1 ⊕ … ⊕ b'_i should be strictly increasing.
If there are multiple answers, print any of them.
Examples
Input
3
1 2 3
Output
No
Input
6
4 7 7 12 31 61
Output
Yes
4 12 7 31 7 61
Note
In the first example no permutation is valid.
In the second example the given answer lead to the sequence a_1 = 4, a_2 = 8, a_3 = 15, a_4 = 16, a_5 = 23, a_6 = 42.
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAX = 3e5 + 5;
int n;
long long int num[MAX];
stack<int> s[100];
vector<long long> v;
int hb[MAX];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
long long int x = 0;
for (int i = 1; i <= n; i++) {
cin >> num[i];
x ^= num[i];
for (int j = 60; j >= 0; j--) {
if ((num[i] & (1ll << j))) {
hb[i] = j;
break;
}
}
s[hb[i]].push(i);
}
for (int i = 1; i <= n; i++) {
int can = 0;
for (int j = 0; j <= 60; j++)
if (((x & (1ll << j)) != 0) && (!s[j].empty())) {
can = s[j].top();
s[j].pop();
break;
}
if (can == 0) {
cout << "No";
return 0;
}
v.push_back(num[can]);
x ^= num[can];
}
reverse(v.begin(), v.end());
cout << "Yes" << endl;
for (int i = 0; i < n; i++) cout << v[i] << ' ';
return 0;
}
|
Nikita likes tasks on order statistics, for example, he can easily find the k-th number in increasing order on a segment of an array. But now Nikita wonders how many segments of an array there are such that a given number x is the k-th number in increasing order on this segment. In other words, you should find the number of segments of a given array such that there are exactly k numbers of this segment which are less than x.
Nikita wants to get answer for this question for each k from 0 to n, where n is the size of the array.
Input
The first line contains two integers n and x (1 ≤ n ≤ 2 ⋅ 10^5, -10^9 ≤ x ≤ 10^9).
The second line contains n integers a_1, a_2, …, a_n (-10^9 ≤ a_i ≤ 10^9) — the given array.
Output
Print n+1 integers, where the i-th number is the answer for Nikita's question for k=i-1.
Examples
Input
5 3
1 2 3 4 5
Output
6 5 4 0 0 0
Input
2 6
-5 9
Output
1 2 0
Input
6 99
-1 -1 -1 -1 -1 -1
Output
0 6 5 4 3 2 1
|
#include <bits/stdc++.h>
using namespace std;
struct cplx {
double re, im;
cplx() : re(0), im(0) {}
cplx(double r, double i) : re(r), im(i) {}
cplx operator+(const cplx &rhs) const {
return cplx(re + rhs.re, im + rhs.im);
}
cplx operator-(const cplx &rhs) const {
return cplx(re - rhs.re, im - rhs.im);
}
cplx operator*(const cplx &rhs) const {
return cplx(re * rhs.re - im * rhs.im, re * rhs.im + im * rhs.re);
}
cplx conj() const { return cplx(re, -im); }
};
const int maxn = 524288;
const double pi = acos(-1);
cplx omega[maxn + 1];
void prefft() {
for (int i = 0; i <= maxn; ++i)
omega[i] = cplx(cos(2 * pi * i / maxn), sin(2 * pi * i / maxn));
}
void bitrev(vector<cplx> &v, int n) {
int z = __builtin_ctz(n) - 1;
for (int i = 0; i < n; ++i) {
int x = 0;
for (int j = 0; (1 << j) < n; ++j) x ^= (((i >> j & 1)) << (z - j));
if (x > i) swap(v[x], v[i]);
}
}
void fft(vector<cplx> &v, int n) {
bitrev(v, n);
for (int s = 2; s <= n; s <<= 1) {
int z = s >> 1;
for (int i = 0; i < n; i += s) {
for (int k = 0; k < z; ++k) {
cplx x = v[i + z + k] * omega[maxn / s * k];
v[i + z + k] = v[i + k] - x;
v[i + k] = v[i + k] + x;
}
}
}
}
void ifft(vector<cplx> &v, int n) {
fft(v, n);
reverse(v.begin() + 1, v.end());
for (int i = 0; i < n; ++i) v[i] = v[i] * cplx(1. / n, 0);
}
vector<long long> conv(const vector<int> &a, const vector<int> &b) {
int sz = 1;
while (sz < a.size() + b.size() - 1) sz <<= 1;
vector<cplx> v(sz);
for (int i = 0; i < sz; ++i) {
double re = i < a.size() ? a[i] : 0;
double im = i < b.size() ? b[i] : 0;
v[i] = cplx(re, im);
}
fft(v, sz);
for (int i = 0; i <= sz / 2; ++i) {
int j = (sz - i) & (sz - 1);
cplx x = (v[i] + v[j].conj()) * (v[i] - v[j].conj()) * cplx(0, -0.25);
if (j != i)
v[j] = (v[j] + v[i].conj()) * (v[j] - v[i].conj()) * cplx(0, -0.25);
v[i] = x;
}
ifft(v, sz);
vector<long long> c(sz);
for (int i = 0; i < sz; ++i) c[i] = v[i].re + 0.5;
while (c.size() && c.back() == 0) c.pop_back();
return c;
}
int a[maxn], s[maxn];
int c[maxn];
int main() {
prefft();
int n, x;
scanf("%d %d", &n, &x);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), s[i] = s[i - 1] + (a[i] < x);
for (int i = 0; i <= n; ++i) ++c[s[i]];
vector<int> a(n + 1), b(n + 1);
for (int i = 0; i <= n; ++i) a[i] = c[i];
for (int i = 0; i <= n; ++i) b[n - i] = c[i];
vector<long long> r = conv(a, b);
memset(c, 0, sizeof(c));
c[0]++;
long long ans = 0;
for (int i = 1; i <= n; ++i) ans += c[s[i]], ++c[s[i]];
printf("%lld ", ans);
for (int i = 1; i <= n; ++i) printf("%lld ", r[i + n]);
puts("");
return 0;
}
|
Atul opens a book store and soon he recives his first bill form his wholeseller. To see the bill is correct or not he try to cross check the bill. since he is weak at mathematics he ask you to sove his problem
P is product Q is quantity of product and T is total cost i.e P *Q=T
INPUT
first line of input contains no of products N
Next N lines contains P,Q,T seperated by space
OUTPUT
Print "YES" if P *Q=T
else print "NO"
for each input
Constrains
0< P, Q< 10000
0<T<1000000000
SAMPLE INPUT
3
5 6 30
12 50 500
150 50 7500
SAMPLE OUTPUT
YES
NO
YES
Explanation
first line is no of product i.e 3
1st line is 5 pens each costs 6 then product is 30 so output is "YES"
2nd line 12 copy each costs 50 then product is 600 so output is "NO"
3rd line is 50 books each costs 150 then product is 7500 so output is "YES"
|
def getres(p,q,t):
if p*q == t:
print "YES"
else:
print "NO"
n = int(raw_input())
for mem in range(n):
p,q,t = [ int(x) for x in raw_input().split() ]
getres(p,q,t)
|
Raju has a crush on girl of his class. He wanted to become close friend of her so he started trying to impress her. She came to know about raju and she also likes him but she is not ready to tell him about her feelings. She gave him a task,she will ask him a chocolate weighs x and raju has to get chocolate of exact weight from the series of chocolate stores which are present in the university. if he succeeds in it she will say "I Like You" else she will get anger and will tell "I Hate You". Raju came to know about his task and he don't want to loose his girl first impression so he wants a help from you to impress his crush.
NOTE: X weight should be one or only 2 different weights of other chocolates.
SAMPLE INPUT
5
5 2 3 4 1
4
10
4
2
12
SAMPLE OUTPUT
I Hate You
I Like You
I Like You
I Hate You
|
T = int(raw_input())
num = map(int,raw_input().split())
N = len(num)
for i in range(N):
for j in range(i + 1, N):
num.append(num[i] + num[j])
N = int(raw_input())
for i in range(N):
j = int(raw_input())
if j in num:
print "I Like You"
else:
print "I Hate You"
|
Its NU-Tech'15 and participants are pouring in large numbers. Its the first day of the fest and everybody has gathered around the registration desks but are confused on receiving a set of very large numbers on the registration slip. They are later told by the volunteers that in order to get their respective registration numbers, they are supposed to add all the numbers, then add the digits of the sum and the then again add the digits of the new sum and continue till the answer consists of a single digit. That digit is their Registration ID. Help the participants to decipher their NU-Tech Ids.
Input:
First line contains an integer n. n lines follow each containing a "Large Number".
Output:
Print the Registration IDs of the student.
Constraints:
1 ≤ n ≤500
1 ≤ Large Number ≤ 2^1000
SAMPLE INPUT
2
23
99
SAMPLE OUTPUT
5
|
case = int(raw_input())
lst = []
def num_sum(n):
st = str(n)
ln = len(st)
val = False
total = 0
for i in range(0, ln):
total += int(st[i])
return total
def one_check(num):
val = False
if(len(str(num)) == 1):
val = True
else:
val = False
return val
for i in range(0, case):
num = int(raw_input())
lst.append(num)
total = sum(lst)
while(1):
total = num_sum(total)
if(one_check(total)):
print(total)
break
else:
continue
|
You are given 3 points - middles of the sides of some triangle. Find coordinates of the triangle vertices.
Input
Input has 3 lines with 2 space-separated reals each - coordinates of the middles of the sides.
Output
Output 3 lines with 2 space-separated reals - coordinates of the triangle vertices. Each number should have exactly 4 digits after dot. Vertices should be sorted in first coordinate ascending order. If two points have the same first coordinate than they should have second coordinate ascending order.
Constraints
0 ≤ xi, yi ≤ 1000
SAMPLE INPUT
5.00 3.00
4.0 4.0
5.0 5.000
SAMPLE OUTPUT
4.0000 2.0000
4.0000 6.0000
6.0000 4.0000
|
x1, y1 = tuple(map(float, raw_input().split()))
x2, y2 = tuple(map(float, raw_input().split()))
x3, y3 = tuple(map(float, raw_input().split()))
X3 = x1+x2-x3; Y3 = y1+y2-y3;
X2 = x1+x3-x2; Y2 = y1+y3-y2;
X1 = x3+x2-x1; Y1 = y3+y2-y1;
out = [[X1, Y1], [X2, Y2], [X3, Y3]]
out.sort()
for i in out:
print "%.4f %.4f" % (i[0], i[1])
|
Little Vaishnavi is bored during the vacation which is going on. Being the only little girl in the neighbourhood she did not have any one else to play with. Her parents are so strict that they will not let her out of the house even to see what the kids from the other houses are playing.
So she decided to make a game of her own. As of now there is construction going on in her house there were lots of plywood sheets of rectangular size in her house. Now she is making a small game. She will take 5 such plywood pieces, out of which she will be taking one which is damaged! It can be placed anywhere among the 5 pieces.Now she will start jumping on the plywood and will be counting the number of jumps.
Say she will start from 1 and then she will go to plywood 2, then 3,then 4 and then 5th piece. After reaching the 5th plywood she will come back to 4th plywood, then to 3rd, than to 2nd and then to 1st. After that she will again jump to 2nd and then 3rd and so on! But as we know out of the 5 plywood pieces one will be defective. It will not support more than K jumps. After the Kth jump on the defective piece it will break.
Given the position of the defective plywood and the value of K we have to tell our cute Vaishnavi upto what will be the maximum of the count go up to?
Input:
The first line contains T, the number of test cases.
Followed by T lines each contain two numbers M and K
2 integers M and K where M is the position of the defective piece among the 5 pieces and K is the maximum jumps that can be made on the defective piece.
Output:
For every Test case Print the maximum count till vaishnavi can go up to.
Separate the answers for each test case by an empty line.
Constraints :
1 ≤ T ≤ 100
1 ≤ M ≤ 5
0 ≤ K ≤ 10^5
Problem Setter : Bipin Baburaj
Problem Tester : Darshak Mehta
SAMPLE INPUT
2
2 3
1 0
SAMPLE OUTPUT
15
0
Explanation
TestCase#1:
First Vaishnavi will jump from 1st ->2nd ->3rd ->4th->5th->4th->3rd->2nd->1st->2nd-> 3rd->4th->5th->4th->3rd.
If she moves to 2 then it will break so count is 15
|
T=input()
for _ in xrange(T):
[M,K]=map(int,raw_input().split())
ans=0
if(K==0):
print M-1
else:
ans=(K-1)*4 + 5
if(M!=5 and M!=1):
if(K&1==1):
ans+=4-M
elif(K&1==0):
ans+=M-2
else:
if(M==1):
ans=8*K
elif(M==5):
ans=4+8*K
print ans
|
Solve the mystery.
Input :
First line contains T - No. of test cases.
For each test case there are two lines.
first line contains N.
Second line contains N space separated integers A[1] to A[N].
Output :
Print answer of the mystery in separate lines.
Constraints :
1 ≤ T ≤ 10
1 ≤ N ≤ 10^5
0 ≤ A[i] ≤ 10^5
SAMPLE INPUT
6
3
2 2 2
3
1 2 3
5
2 2 3 3 4
5
1 2 3 4 5
4
2 4 5 6
6
1 2 3 1 2 3
SAMPLE OUTPUT
0
4
6
9
5
8
|
from sys import stdin
t = int(stdin.readline())
for _ in xrange(t):
n = int(stdin.readline())
a = map(int,stdin.readline().split())
ans = 0
for i in a:
if i%2:
ans += i
print ans
|
Alfie was a prisoner in mythland. Though Alfie was a witty and intelligent guy.He was confident of escaping prison.After few days of observation,He figured out that the prison consists of (N × N) cells.i.e The shape of prison was (N × N) matrix. Few of the cells of the prison contained motion detectors.So Alfie planned that while escaping the prison he will avoid those cells containing motion detectors.Yet before executing his plan,Alfie wants to know the total number of unique possible paths which he can take to escape the prison.Initially Alfie is in cell
(1,1) while the exit of the cell (N,N).
note:->Alfie can move in all four direction{ if his current location is (X,Y), he can move to either
(X+1,Y), (X-1,Y), (X,Y+1), (X,Y-1) }. If the first cell (1,1) and the last cell(N,N) contain motion detectors,then Alfie can't break out of the prison.
INPUT:
The first line contain number of test cases "T".T test cases follow.The first line of each test case contains an integer "N",(i.e the size of the (N × N) matrix).The next n lines contain N space separated values either 0 or 1."1" represents a cell containing motion detectors.
OUTPUT:
output total number of unique possible paths which he can take to escape the prison.
Constraint:
1 ≤ T ≤ 20
1 ≤ N ≤ 20
SAMPLE INPUT
3
4
0 1 1 0
0 0 1 0
0 0 0 0
0 1 1 0
4
0 0 0 1
0 0 0 0
1 1 1 0
1 0 0 0
4
0 1 1 0
0 0 1 1
0 0 0 0
0 1 0 0
SAMPLE OUTPUT
2
4
4
|
#https://www.hackerearth.com/problem/algorithm/prison-break-5/
answers = []
for t in range(int(raw_input())):
grid = []
n = int(raw_input())
for i in range(n):
grid.append([int(x) for x in raw_input().split()])
count = 0
S = [[[0,0]]]
while S:
currPath = S.pop(0)
pos = currPath[-1]
if pos == [n-1,n-1]:
count += 1
moves = []
x,y = pos
if x+1 < n:
if grid[x+1][y] == 0:
moves.append([x+1,y])
if y+1 < n:
if grid[x][y+1] == 0:
moves.append([x,y+1])
if y > 0:
if grid[x][y-1] == 0:
moves.append([x,y-1])
if x > 0:
if grid[x-1][y] == 0:
moves.append([x-1,y])
for move in moves:
if move not in currPath:
S.append(currPath + [move])
answers.append(count)
for ans in answers:
print ans
|
You have a long list of tasks that you need to do today. To accomplish task i you need Mi minutes, and the deadline for this task is Di. You need not complete a task at a stretch. You can complete a part of it, switch to another task, and then switch back.
You've realized that it might not be possible to complete all the tasks by their deadline. So you decide to do them in such a manner that the maximum amount by which a task's completion time overshoots its deadline is minimized.
Input Format
The first line contains the number of tasks, T. Each of the next T lines contains two integers, Di and Mi.
Output Format
T lines. The ith line contains the value of the maximum amount by which a task's completion time overshoots its deadline, when the first i tasks on your list are scheduled optimally.
Constraints
1≤T≤10^5
1≤Di≤10^5
1≤Mi≤10^3
SAMPLE INPUT
5
2 2
1 1
4 3
10 1
2 1
SAMPLE OUTPUT
0
1
2
2
3
|
import sys
import math
stdin = sys.stdin
Mid= lambda x : ((x[0] + x[1])>>1)
Lowbit = lambda x : (x&(-x))
used = {}
class Task:
def __init__(self , _d , _m , _index):
self.d = int(_d)
self.m = int(_m)
self.index = int(_index)
def __lt__(self , other):
if (self.d == other.d):
return self.m > other.m
else:
return self.d < other.d
def __repr__(self):
return str((self.d , self.m))
class Node:
def __init__(self):
self.val = 0
self.idx = 0
self.add = 0
self.cover = (0 , 0)
self.lChild = None
self.rChild = None
def __lt__(self , other):
if (self.idx not in used):
return True
if (other.idx not in used):
return False
return self.val < other.val
def __repr__(self):
return str(self.val)
def build(self , cover):
self.cover = cover
self.idx = cover[0]
if (cover[0] == cover[1]):
return
mid = Mid(cover)
self.lChild = Node()
self.rChild = Node()
self.lChild.build( (cover[0] , mid) )
self.rChild.build( (mid + 1 , cover[1]) )
def addDown(self):
#try
self.lChild.addValue(self.add)
self.rChild.addValue(self.add)
self.add = 0
def addValue(self , add):
self.val += add
self.add += add
def update(self , cover, add):
if (cover[0] <= self.cover[0] and cover[1] >= self.cover[1]):
self.addValue(add)
return
if (self.add):
self.addDown()
mid = Mid(self.cover)
if (cover[0] <= mid):
self.lChild.update(cover , add)
if (cover[1] > mid):
self.rChild.update(cover , add)
ret = max( self.lChild , self.rChild )
self.val = ret.val
self.idx = ret.idx
def query(self , cover):
if (cover[0] == self.cover[0] and cover[1] == self.cover[1]):
return self
if (self.add):
self.addDown()
mid = Mid(self.cover)
if (cover[1] <= mid):
return self.lChild.query(cover)
elif (cover[0] > mid):
return self.rChild.query(cover)
else:
vl = self.lChild.query( (cover[0] , mid) )
vr = self.rChild.query( (mid + 1 , cover[1]) )
return max(vl , vr)
class BinIdxTree:
def __init__(self , size):
self.S = [0 for i in range(size+10)]
def add(self , x , c):
while (x <= n):
self.S[x] += c
x += Lowbit(x)
def getsum(self , x):
res = 0
while (x > 0):
res += self.S[x]
x -= Lowbit(x)
return res
line = stdin.readline()
n = int(line)
segTreeRoot = Node()
segTreeRoot.build((1 , n))
bTree = BinIdxTree(n)
##try
taskList = []
rank = [0 for i in range(n+1)]
for i in range(n):
line = stdin.readline()
[d , m] = [int(x) for x in line.split()]
t = Task(d , m , i)
taskList.append(t)
taskList.sort()
for i in range(n):
rank[ taskList[i].index ] = i
ans = 0
for i in range(n):
p = rank[i] + 1
bTree.add(p , taskList[p-1].m)
used[p] = True
segTreeRoot.update((p , p) , - taskList[p-1].d)
segTreeRoot.update((p , n) , taskList[p-1].m)
res = bTree.getsum(p) - taskList[p-1].d
res = 0 if res < 0 else res
if (p + 1 <= n):
resNode = segTreeRoot.query((p + 1 , n))
p = resNode.idx
if (p in used):
s =bTree.getsum(p) - taskList[p-1].d
res = s if s > res else res
ans = res if res > ans else ans
print ans
|
You are a product engineer and would like to improve the quality of duct tapes that your company manufactures. An entire tape can be represented as a single row of N cells. Each cell has its Stickiness factor, which stands for its ability to stick to an object. We say that a tape is a good quality product, if and only if the total sum of Stickiness factors of grid cells in any of its subarray of size K is at least D.
To make a quality product, consider an augment operation in which you can choose any subarray of size at most K and a real number (say R), and multiply Stickiness factor of all its cells by R. For each augment operation, the subarray and the value of R can be chosen arbitrarily. However, the size of chosen subarray for augmentation can be at most K, as mentioned before.
Your task is to calculate the minimum number of augment operations needed to be performed in order to transform the given tape to a good quality product.
INPUT
The first line contains three space separated integers N, K and D, as described above. The next line contains N space separated integers, i^th of which (denoted by Ai) denotes the Stickiness factor of i^th cell.
OUTPUT
Output in single line, an integer, which denotes the minimum number of augment operations needed to be performed in order to transform the tape to a good quality product. In case, if it is impossible to achieve, print -1 instead.
CONSTRAINTS
1 ≤ N, D ≤ 10^5
1 ≤ K ≤ N
0 ≤ Ai ≤ 10^5
SAMPLE INPUT
3 2 4
1 1 1
SAMPLE OUTPUT
1
Explanation
We can multiply the second element by 3. Now the tape becomes: 1 3 1.
Any subarray of size 2 has now sum = 4, which satisfies the required condition. We used 1 augment operation, hence the answer is 1.
|
def solve(n,k,d,l):
ll = [0]*n
p,j = 0,-1
for i in xrange(n):
if l[i] == 0:
if i - j >= k: return -1
else:
p,j = l[i],i
ll[i] = (p,j)
r = 0
t = 0
for i in xrange(k-1): t += l[i]
i = k-1
while i < n:
if i != k-1: t -= l[i-k]
t += l[i]
if t < d:
r += 1
g,j = ll[i]
if j+k-1 >= n: return r
g,j2 = ll[j+k-1]
if j2 + k >= n: return r
t = 0
for ii in xrange(j2+1,j2+k): t += l[ii]
i = j2+k
else: i += 1
return r
n,k,d = map(int,raw_input().strip().split())
l = map(int,raw_input().strip().split())
print solve(n,k,d,l)
|
After Governor's attack on prison, Rick found himself surrounded by walkers. They are coming towards him from all sides. Now, suppose Rick have infinite number of bullets with him. Suppose Rick need 1 bullet to kill each walker (yeah he is good in killing walkers. They need to be shot at head. See, how good he is). Now as soon as he kills 1 walker rest of the walkers move forward by 1 m. There are n walkers each at some distance from Rick. If any walker is able to reach Rick, he dies. Now, you need to tell if he survives or not. If he survives print "Rick now go and save Carl and Judas" else print "Goodbye Rick" followed by no.of walkers he was able to kill before he died in next line. One more thing Rick's gun can fire 6 shots without reload. It takes him 1 sec to reload and during this time walkers move 1 m forward.
[Input]
First line contains an integer t indicating number of test cases.
Next line contains an integer n denoting no.of walkers followed by n space separated integers denoting the distance of walkers from him.
[Output]
For each test case output one line denoting the answer as explained above.
[Constraints]
1 ≤ t ≤ 100
1 ≤ n ≤ 100000
1 ≤ dis[i] ≤ 50000
SAMPLE INPUT
2
5
2 4 2 5 6
4
2 2 2 2
SAMPLE OUTPUT
Rick now go and save Carl and Judas
Goodbye Rick
2
|
T = int(raw_input());
while T > 0:
T = T-1;
N = int(raw_input());
arr = raw_input().split(' ');
A = map(int, arr);
A.sort();
index = 0;
minute = 1;
myR = 1;
while index < N:
if minute > A[index]:
print 'Goodbye Rick';
print index;
break;
if myR % 6 == 0:
minute += 1;
myR = 0;
myR += 1;
minute += 1;
index += 1;
if index >= N:
print 'Rick now go and save Carl and Judas';
|
There are N Snuke Cats numbered 1, 2, \ldots, N, where N is even.
Each Snuke Cat wears a red scarf, on which his favorite non-negative integer is written.
Recently, they learned the operation called xor (exclusive OR).
What is xor?
For n non-negative integers x_1, x_2, \ldots, x_n, their xor, x_1~\textrm{xor}~x_2~\textrm{xor}~\ldots~\textrm{xor}~x_n is defined as follows:
* When x_1~\textrm{xor}~x_2~\textrm{xor}~\ldots~\textrm{xor}~x_n is written in base two, the digit in the 2^k's place (k \geq 0) is 1 if the number of integers among x_1, x_2, \ldots, x_n whose binary representations have 1 in the 2^k's place is odd, and 0 if that count is even.
For example, 3~\textrm{xor}~5 = 6.
They wanted to use this operation quickly, so each of them calculated the xor of the integers written on their scarfs except his scarf.
We know that the xor calculated by Snuke Cat i, that is, the xor of the integers written on the scarfs except the scarf of Snuke Cat i is a_i. Using this information, restore the integer written on the scarf of each Snuke Cat.
Constraints
* All values in input are integers.
* 2 \leq N \leq 200000
* N is even.
* 0 \leq a_i \leq 10^9
* There exists a combination of integers on the scarfs that is consistent with the given information.
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 \ldots a_N
Output
Print a line containing N integers separated with space.
The i-th of the integers from the left should represent the integer written on the scarf of Snuke Cat i.
If there are multiple possible solutions, you may print any of them.
Example
Input
4
20 11 9 24
Output
26 5 7 22
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[n]; //a_max = 10^9
int XORsum = 0;
for(int i=0;i<n;i++){
a[i] = sc.nextInt();
XORsum ^= a[i];
}
for(int i=0;i<n;i++){
if(i != 0){
System.out.print(" ");
}
System.out.print(XORsum ^ a[i]);
}
System.out.println();
}
}
|
An SNS has N users - User 1, User 2, \cdots, User N.
Between these N users, there are some relationships - M friendships and K blockships.
For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User A_i and User B_i.
For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User C_i and User D_i.
We define User a to be a friend candidate for User b when all of the following four conditions are satisfied:
* a \neq b.
* There is not a friendship between User a and User b.
* There is not a blockship between User a and User b.
* There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.
For each user i = 1, 2, ... N, how many friend candidates does it have?
Constraints
* All values in input are integers.
* 2 ≤ N ≤ 10^5
* 0 \leq M \leq 10^5
* 0 \leq K \leq 10^5
* 1 \leq A_i, B_i \leq N
* A_i \neq B_i
* 1 \leq C_i, D_i \leq N
* C_i \neq D_i
* (A_i, B_i) \neq (A_j, B_j) (i \neq j)
* (A_i, B_i) \neq (B_j, A_j)
* (C_i, D_i) \neq (C_j, D_j) (i \neq j)
* (C_i, D_i) \neq (D_j, C_j)
* (A_i, B_i) \neq (C_j, D_j)
* (A_i, B_i) \neq (D_j, C_j)
Input
Input is given from Standard Input in the following format:
N M K
A_1 B_1
\vdots
A_M B_M
C_1 D_1
\vdots
C_K D_K
Output
Print the answers in order, with space in between.
Examples
Input
4 4 1
2 1
1 3
3 2
3 4
4 1
Output
0 1 0 1
Input
5 10 0
1 2
1 3
1 4
1 5
3 2
2 4
2 5
4 3
5 3
4 5
Output
0 0 0 0 0
Input
10 9 3
10 1
6 7
8 2
2 5
8 4
7 3
10 9
6 4
5 8
2 6
7 5
3 1
Output
1 3 5 4 3 3 3 3 1 0
|
#include <bits/stdc++.h>
using namespace std;
#define N 100100
#define SIGMA 26
vector <int> a[N];
vector <int> b[N];
int cnt[N], c[N];
int x, y, n, m, k, i, nr, curr, j;
void df (int nod, int comp){
c[nod] = comp;
++cnt[comp];
for (int it = 0; it < a[nod].size(); ++it)
if (!c[a[nod][it]])
df (a[nod][it], comp);
}
int main()
{
cin >> n >> m >> k;
for (i = 0; i < m; ++i){
cin >> x >> y;
--x;--y;
a[x].push_back (y);
a[y].push_back (x);
}
for (i = 0; i < k; ++i){
cin >> x >> y;
--x;--y;
b[x].push_back (y);
b[y].push_back (x);
}
nr = 1;
for (i = 0; i < n; ++i){
if (!c[i]){
df (i, nr);
++nr;
}
}
for (i = 0; i < n; ++i){
curr = cnt[c[i]] - a[i].size();
for (j = 0; j < b[i].size(); ++j)
if (c[b[i][j]] == c[i])
--curr;
cout << curr - 1<< " ";
}
return 0;
}
|
Given is an integer N.
Takahashi chooses an integer a from the positive integers not greater than N with equal probability.
Find the probability that a is odd.
Constraints
* 1 \leq N \leq 100
Input
Input is given from Standard Input in the following format:
N
Output
Print the probability that a is odd. Your output will be considered correct when its absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4
Output
0.5000000000
Input
5
Output
0.6000000000
Input
1
Output
1.0000000000
|
N = input()
print "%.10f"%((N+1)/2/float(N))
|
Your friend gave you a dequeue D as a birthday present.
D is a horizontal cylinder that contains a row of N jewels.
The values of the jewels are V_1, V_2, ..., V_N from left to right. There may be jewels with negative values.
In the beginning, you have no jewel in your hands.
You can perform at most K operations on D, chosen from the following, at most K times (possibly zero):
* Operation A: Take out the leftmost jewel contained in D and have it in your hand. You cannot do this operation when D is empty.
* Operation B: Take out the rightmost jewel contained in D and have it in your hand. You cannot do this operation when D is empty.
* Operation C: Choose a jewel in your hands and insert it to the left end of D. You cannot do this operation when you have no jewel in your hand.
* Operation D: Choose a jewel in your hands and insert it to the right end of D. You cannot do this operation when you have no jewel in your hand.
Find the maximum possible sum of the values of jewels in your hands after the operations.
Constraints
* All values in input are integers.
* 1 \leq N \leq 50
* 1 \leq K \leq 100
* -10^7 \leq V_i \leq 10^7
Input
Input is given from Standard Input in the following format:
N K
V_1 V_2 ... V_N
Output
Print the maximum possible sum of the values of jewels in your hands after the operations.
Examples
Input
6 4
-10 8 2 1 2 6
Output
14
Input
6 4
-6 -100 50 -2 -5 -3
Output
44
Input
6 3
-6 -100 50 -2 -5 -3
Output
0
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.Collections;
import java.util.ArrayList;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author cunbidun
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
DEqueue solver = new DEqueue();
solver.solve(1, in, out);
out.close();
}
static class DEqueue {
private static final int INF = (int) 2e9 + 7;
private InputReader in;
private PrintWriter out;
public void solve(int testNumber, InputReader in, PrintWriter out) {
this.in = in;
this.out = out;
int n = in.nextInt();
int k = in.nextInt();
int[] a = in.nextIntArray(n, 1);
int ans = 0;
for (int l = 0; l <= n; l++) {
for (int r = 0; r <= n; r++) {
if (l + r <= MaxMin.Min(n, k)) {
int cur = 0;
ArrayList<Integer> L = new ArrayList<>();
L.add(-INF);
ArrayList<Integer> R = new ArrayList<>();
R.add(-INF);
for (int i = 1; i <= l; i++)
L.add(a[i]);
for (int i = n; i >= n - r + 1; i--)
R.add(a[i]);
int[] curL = new int[L.size()];
int[] curR = new int[R.size()];
Collections.sort(L);
Collections.sort(R);
// System.out.println(l + " " + r);
// for (int i : L) System.out.print(i + " ");
// System.out.println();
// for (int i : R) System.out.print(i + " ");
// System.out.println();
for (int i = 1; i <= l; i++) {
curL[i] = curL[i - 1] + L.get(i);
}
for (int i = 1; i <= r; i++) {
curR[i] = curR[i - 1] + R.get(i);
}
int num = l + r;
for (int i = 0; i <= l; i++) {
for (int j = 0; j <= r; j++) {
if (i + j + num <= k) {
cur = MaxMin.Max(cur, curL[l] + curR[r] - (curL[i] + curR[j]));
}
}
}
ans = MaxMin.Max(ans, cur);
}
}
}
out.println(ans);
}
}
static class InputReader extends InputStream {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public int nextInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public int[] nextIntArray(int length, int stIndex) {
int[] arr = new int[length + stIndex];
for (int i = stIndex; i < stIndex + length; i++)
arr[i] = nextInt();
return arr;
}
private static boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
static class MaxMin {
public static <T extends Comparable<T>> T Max(T x, T y) {
T max = x;
if (y.compareTo(max) > 0) max = y;
return max;
}
public static <T extends Comparable<T>> T Min(T x, T y) {
T min = x;
if (y.compareTo(min) < 0) min = y;
return min;
}
}
}
|
There are N slimes lining up in a row. Initially, the i-th slime from the left has a size of a_i.
Taro is trying to combine all the slimes into a larger slime. He will perform the following operation repeatedly until there is only one slime:
* Choose two adjacent slimes, and combine them into a new slime. The new slime has a size of x + y, where x and y are the sizes of the slimes before combining them. Here, a cost of x + y is incurred. The positional relationship of the slimes does not change while combining slimes.
Find the minimum possible total cost incurred.
Constraints
* All values in input are integers.
* 2 \leq N \leq 400
* 1 \leq a_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 \ldots a_N
Output
Print the minimum possible total cost incurred.
Examples
Input
4
10 20 30 40
Output
190
Input
5
10 10 10 10 10
Output
120
Input
3
1000000000 1000000000 1000000000
Output
5000000000
Input
6
7 6 8 6 1 1
Output
68
|
#include <iostream>
using namespace std;
int n;
long long a[404], b[404], d[404][404];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], b[i] = b[i - 1] + a[i];
for (int i = 1; i < n; i++) for (int j = 1; j + i <= n; j++) {
d[j][j + i] = 1e18;
for (int k = j; k < j + i; k++) d[j][j + i] = min(d[j][j + i], d[j][k] + d[k + 1][j + i]);
d[j][j + i] += b[j + i] - b[j - 1];
}
cout << d[1][n] << '\n';
}
|
In the State of Takahashi in AtCoderian Federation, there are N cities, numbered 1, 2, ..., N. M bidirectional roads connect these cities. The i-th road connects City A_i and City B_i. Every road connects two distinct cities. Also, for any two cities, there is at most one road that directly connects them.
One day, it was decided that the State of Takahashi would be divided into two states, Taka and Hashi. After the division, each city in Takahashi would belong to either Taka or Hashi. It is acceptable for all the cities to belong Taka, or for all the cities to belong Hashi. Here, the following condition should be satisfied:
* Any two cities in the same state, Taka or Hashi, are directly connected by a road.
Find the minimum possible number of roads whose endpoint cities belong to the same state. If it is impossible to divide the cities into Taka and Hashi so that the condition is satisfied, print `-1`.
Constraints
* 2 \leq N \leq 700
* 0 \leq M \leq N(N-1)/2
* 1 \leq A_i \leq N
* 1 \leq B_i \leq N
* A_i \neq B_i
* If i \neq j, at least one of the following holds: A_i \neq A_j and B_i \neq B_j.
* If i \neq j, at least one of the following holds: A_i \neq B_j and B_i \neq A_j.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Print the answer.
Examples
Input
5 5
1 2
1 3
3 4
3 5
4 5
Output
4
Input
5 1
1 2
Output
-1
Input
4 3
1 2
1 3
2 3
Output
3
Input
10 39
7 2
7 1
5 6
5 8
9 10
2 8
8 7
3 10
10 1
8 10
2 3
7 4
3 9
4 10
3 4
6 1
6 7
9 5
9 7
6 9
9 4
4 6
7 5
8 3
2 5
9 2
10 7
8 6
8 9
7 3
5 3
4 5
6 3
2 10
5 10
4 2
6 2
8 4
10 6
Output
21
|
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
//template
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define rrep(i,a,b) for(int i=(a);i>(b);i--)
#define ALL(v) (v).begin(),(v).end()
typedef long long int ll;
const int inf = 0x3fffffff; const ll INF = 0x1fffffffffffffff; const double eps=1e-12;
void tostr(ll x,string& res){while(x)res+=('0'+(x%10)),x/=10; reverse(ALL(res)); return;}
template<class T> inline bool chmax(T& a,T b){ if(a<b){a=b;return 1;}return 0; }
template<class T> inline bool chmin(T& a,T b){ if(a>b){a=b;return 1;}return 0; }
//end
int n,m,g[710][710];
int col[710], cnt[2];
bitset<710> dp;
void dfs(int x,int c){
if(col[x]==-1)col[x]=c;
else if(col[x]!=c){puts("-1"); exit(0);}
else return;
cnt[c]++;
rep(nxt,0,n)if(g[x][nxt]&&x!=nxt)dfs(nxt,c^1);
}
int main(){
scanf("%d%d",&n,&m);
fill(g[0],g[n],1);
rep(i,0,m){
int x,y; scanf("%d%d",&x,&y); x--; y--;
g[x][y]=g[y][x]=0;
}
dp=1; memset(col,-1,sizeof(col));
rep(i,0,n)if(col[i]==-1){
cnt[0]=cnt[1]=0; dfs(i,0);
dp=(dp<<cnt[0])|(dp<<cnt[1]);
}
ll res=INF;
rep(i,0,n)if(dp[i])chmin(res,1LL*i*(i-1)/2+1LL*(n-i)*(n-i-1)/2);
printf("%lld\n",res);
return 0;
}
|
A railroad running from west to east in Atcoder Kingdom is now complete.
There are N stations on the railroad, numbered 1 through N from west to east.
Tomorrow, the opening ceremony of the railroad will take place.
On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.
The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.
Here, it is guaranteed that F_i divides S_i.
That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.
For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.
Constraints
* 1≤N≤500
* 1≤C_i≤100
* 1≤S_i≤10^5
* 1≤F_i≤10
* S_i％F_i=0
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
C_1 S_1 F_1
:
C_{N-1} S_{N-1} F_{N-1}
Output
Print N lines. Assuming that we are at Station i (1≤i≤N) when the ceremony begins, if the earliest possible time we can reach Station N is x seconds after the ceremony begins, the i-th line should contain x.
Examples
Input
3
6 5 1
1 10 1
Output
12
11
0
Input
4
12 24 6
52 16 4
99 2 2
Output
187
167
101
0
Input
4
12 13 1
44 17 17
66 4096 64
Output
4162
4162
4162
0
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
vector<int> C(510), S(510), F(510);
cin >> N;
for(int i=0; i<N-1; i++) cin >> C[i] >> S[i] >> F[i];
for(int j=0; j<N; j++){
int t = 0;
for(int i=j; i<N-1; i++){
if(t < S[i]){
t = S[i];
} else {
while(t % F[i] != 0) t++;
}
t += C[i];
}
cout << t << endl;
}
}
|
We have a grid with H rows and W columns of squares. Snuke is painting these squares in colors 1, 2, ..., N. Here, the following conditions should be satisfied:
* For each i (1 ≤ i ≤ N), there are exactly a_i squares painted in Color i. Here, a_1 + a_2 + ... + a_N = H W.
* For each i (1 ≤ i ≤ N), the squares painted in Color i are 4-connected. That is, every square painted in Color i can be reached from every square painted in Color i by repeatedly traveling to a horizontally or vertically adjacent square painted in Color i.
Find a way to paint the squares so that the conditions are satisfied. It can be shown that a solution always exists.
Constraints
* 1 ≤ H, W ≤ 100
* 1 ≤ N ≤ H W
* a_i ≥ 1
* a_1 + a_2 + ... + a_N = H W
Input
Input is given from Standard Input in the following format:
H W
N
a_1 a_2 ... a_N
Output
Print one way to paint the squares that satisfies the conditions. Output in the following format:
c_{1 1} ... c_{1 W}
:
c_{H 1} ... c_{H W}
Here, c_{i j} is the color of the square at the i-th row from the top and j-th column from the left.
Examples
Input
2 2
3
2 1 1
Output
1 1
2 3
Input
3 5
5
1 2 3 4 5
Output
1 4 4 4 3
2 5 4 5 3
2 5 5 5 3
Input
1 1
1
1
Output
1
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author HossamDoma
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskD solver = new TaskD();
solver.solve(1, in, out);
out.close();
}
static class TaskD {
public void solve(int testNumber, InputReader in, PrintWriter out) {
int h = in.nextInt();
int w = in.nextInt();
int n = in.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; ++i) {
a[i] = in.nextInt();
}
int[][] ans = new int[h][w];
int i = 0;
int j = 0;
boolean[][] vis = new boolean[h][w];
int cur = 0;
int tot = 0;
int tt = h * w;
int[] dx = {0, 1, 0, -1};
int[] dy = {1, 0, -1, 0};
for (int idx = 0; tot < tt; idx = (idx + 1) % 4, i += dx[idx], j += dy[idx]) {
while (i >= 0 && j >= 0 && i < h && j < w && !vis[i][j]) {
vis[i][j] = true;
ans[i][j] = cur + 1;
a[cur]--;
tot++;
if (a[cur] == 0) cur++;
i += dx[idx];
j += dy[idx];
}
//roll_back
i -= dx[idx];
j -= dy[idx];
}
for (int ii = 0; ii < h; ++ii)
for (int jj = 0; jj < w; ++jj)
out.print(ans[ii][jj] + (jj == w - 1 ? "\n" : " "));
}
}
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());
}
}
}
|
Snuke loves working out. He is now exercising N times.
Before he starts exercising, his power is 1. After he exercises for the i-th time, his power gets multiplied by i.
Find Snuke's power after he exercises N times. Since the answer can be extremely large, print the answer modulo 10^{9}+7.
Constraints
* 1 ≤ N ≤ 10^{5}
Input
The input is given from Standard Input in the following format:
N
Output
Print the answer modulo 10^{9}+7.
Examples
Input
3
Output
6
Input
10
Output
3628800
Input
100000
Output
457992974
|
a = 1
for i in range(1,int(input())+1):
a = (a*i)%(10**9+7)
print(a)
|
AtCoDeer the deer is seeing a quick report of election results on TV. Two candidates are standing for the election: Takahashi and Aoki. The report shows the ratio of the current numbers of votes the two candidates have obtained, but not the actual numbers of votes. AtCoDeer has checked the report N times, and when he checked it for the i-th (1≦i≦N) time, the ratio was T_i:A_i. It is known that each candidate had at least one vote when he checked the report for the first time.
Find the minimum possible total number of votes obtained by the two candidates when he checked the report for the N-th time. It can be assumed that the number of votes obtained by each candidate never decreases.
Constraints
* 1≦N≦1000
* 1≦T_i,A_i≦1000 (1≦i≦N)
* T_i and A_i (1≦i≦N) are coprime.
* It is guaranteed that the correct answer is at most 10^{18}.
Input
The input is given from Standard Input in the following format:
N
T_1 A_1
T_2 A_2
:
T_N A_N
Output
Print the minimum possible total number of votes obtained by Takahashi and Aoki when AtCoDeer checked the report for the N-th time.
Examples
Input
3
2 3
1 1
3 2
Output
10
Input
4
1 1
1 1
1 5
1 100
Output
101
Input
5
3 10
48 17
31 199
231 23
3 2
Output
6930
|
n = input()
t, a = 1, 1
for i in range(n):
xs = map(int, raw_input().split())
m = max((t + xs[0] - 1) / xs[0], (a + xs[1] - 1) / xs[1])
t, a = xs[0] * m, xs[1] * m
print t + a
|
I have a sequence defined as follows:
* All even-numbered terms are equal to the previous term multiplied by 2.
* All odd-numbered terms are equal to the previous term divided by 3.
Create a program that reads the first term a of this sequence and outputs the sum s (10) from the first term to the tenth term.
Input
The input consists of multiple test cases. For each test case, a real number a (1.0 ≤ a ≤ 10.0) representing the first term of the sequence is given in one row.
The number of test cases does not exceed 50.
Output
Print s (10) on one line for each test case.
The output may contain an error of 0.000001 or less.
Example
Input
1.0
2.0
3.0
Output
7.81481481
15.62962963
23.44444444
|
import java.io.*;
public class Main {
public static void main(String[] argv) throws IOException {
//*
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
while (true) {
String s = in.readLine();
if (s == null) {
break;
}
f(s);
}
//*/
}
public static void f(String s) {
double a = 0;
try {
a = Double.parseDouble(s);
if (a < 1.0 || 10.0 < a) {
return;
}
} catch (NumberFormatException numberFormatException) {
return;
}
double sum = a;
for (int i = 2; i <= 10; i++) {
if (i % 2 == 0) {
a *= 2;
} else {
a /= 3;
}
sum += a;
}
System.out.printf("%.8f\n", sum);
}
}
|
In April 2008, Aizuwakamatsu City succeeded in making yakitori with a length of 20 m 85 cm. The chicken used at this time is Aizu local chicken, which is a specialty of Aizu. Aizu local chicken is very delicious, but it is difficult to breed, so the production volume is small and the price is high.
<image>
Relatives come to visit Ichiro's house from afar today. Mom decided to cook chicken and entertain her relatives. A nearby butcher shop sells two types of chicken, Aizu chicken and regular chicken. The mother gave Ichiro the following instructions and asked the butcher to go and buy chicken.
* If you run out of chicken, you will be in trouble, so buy more chicken than you have decided.
* Buy as many Aizu local chickens as your budget allows (must buy Aizu local chickens).
* Buy as much regular chicken as possible with the rest of the Aizu chicken (don't buy if you don't have enough budget).
When Ichiro went to the butcher shop, the amount of Aizu chicken that could be bought by one person was limited due to lack of stock. When Ichiro follows all the instructions given by his mother when shopping, how many grams of Aizu chicken and regular chicken will Ichiro buy?
Enter the lower limit of the amount of chicken to buy q1, the budget b, the price of 100 grams of Aizu chicken at this butcher c1, the price of 100 grams of regular chicken c2, and the upper limit of the amount of Aizu chicken that one person can buy q2. Create a program that outputs the amount of Aizu chicken and ordinary chicken that Ichiro buys in units of 100 grams. However, if you cannot buy at this butcher's shop as instructed by your mother, please output "NA".
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
q1 b c1 c2 q2
The data q1 and q2, which represent the amount of chicken, are specified in units of 100 grams. Also, b, c1, c2, q1, and q2 are integers between 1 and 1,000,000.
The number of datasets does not exceed 50.
Output
For each data set, the amount of Aizu chicken purchased by Ichiro and the amount of normal chicken (separated by half-width spaces) or "NA" is output on one line.
Example
Input
48 9297 240 126 32
20 3010 157 141 7
30 117002 5680 962 15
8 1673 1712 190 22
64 8478 87 54 307
23 5477 117 92 12
50 7558 1396 187 17
279 88677 4522 514 14
0
Output
28 20
7 13
15 33
NA
97 0
12 44
NA
NA
|
//45
#include<iostream>
using namespace std;
int main(){
for(int q,b,c,cc,qq;cin>>q>>b>>c>>cc>>qq,q;){
int a=0;
int n=b/cc;
int r=b-n*cc;
for(;;){
int nr=r;
int nn=n;
while(nr<c){
nr+=cc;
nn--;
}
if(nn<0||a+1+nn<q||a+1>qq)break;
a++;
n=nn;
r=nr-c;
}
if(a+n<q||a==0){
cout<<"NA"<<endl;
}else{
cout<<a<<' '<<n<<endl;
}
}
return 0;
}
|
The educational program (AHK Education) of the Aiz Broadcasting Association broadcasts a handicraft program for children, "Play with Tsukuro". This time I will make a box with sticks, but I would like to see if I can make a rectangular parallelepiped using the 12 sticks I prepared. However, the stick must not be cut or broken.
Given the lengths of the twelve bars, write a program to determine if you can create a rectangular parallelepiped with all of them as sides.
Input
The input is given in the following format.
e1 e2 ... e12
The input consists of one line and is given the integer ei (1 ≤ ei ≤ 100) representing the length of each bar.
Output
If a rectangular parallelepiped can be created, "yes" is output, and if it cannot be created, "no" is output. However, since a cube is a kind of rectangular parallelepiped, "yes" is output even if it is a cube.
Examples
Input
1 1 3 4 8 9 7 3 4 5 5 5
Output
no
Input
1 1 2 2 3 1 2 3 3 3 1 2
Output
yes
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int a[12];
for(int i = 0;i < 12;i++) cin >> a[i];
sort(a,a+12);
if(a[0] == a[3] && a[4] == a[7] && a[8] == a[11]){
cout << "yes" << endl;
}
else cout << "no" << endl;
return 0;
}
|
Railroad Trip
There are N cities in the JOI country, numbered 1, 2, ..., and N, respectively. In addition, there are N − 1 railroads, which are numbered 1, 2, ..., and N − 1, respectively. The railroad i (1 ≤ i ≤ N − 1) connects the city i and the city i + 1 in both directions.
There are two ways to get on the JOI railway, one is to use a paper ticket and the other is to use an IC card.
* The fare for boarding the railway i with a paper ticket is Ai yen.
* The fare for boarding the railway i with an IC card is Bi Yen. However, in order to board the railway i with an IC card, it is necessary to purchase an IC card that can be used with the railway i in advance. It costs Ci yen to purchase an IC card that can be used on the railway i. Once purchased, the IC card can be used any number of times.
Since the IC card makes it easier to process the amount, the fare for boarding with an IC card is cheaper than the fare for boarding with a paper ticket. That is, for i = 1, 2, ..., N − 1, Ai> Bi holds. Since the specifications of IC cards are all different for each railroad, the IC card that can be used on railroad i cannot be used on other railroads for any i.
You decide to travel all over the JOI country. We plan to start from the city P1 and visit the cities in the order of P2, P3, ..., PM. The trip consists of an M-1 day journey. On day j (1 ≤ j ≤ M − 1), travel by rail from city Pj to city Pj + 1. At this time, it may move by connecting several railroads. You may also visit the same city more than once. The railroads in JOI are so fast that you can travel from any city to any city in a day.
You currently do not have an IC card for any railroad. You want to purchase some railroad IC cards in advance and minimize the cost of this trip, that is, the sum of the IC card purchase cost and the railroad fare you boarded.
Task
Given the number of cities in the JOI country, the itinerary of the trip, and the fare and IC card price for each railroad in the JOI country. At this time, create a program to find the minimum amount of money required for the trip.
input
Read the following data from standard input.
* On the first line, integers N and M are written with blanks as delimiters. Each of these represents that there are N cities in the JOI country and the trip consists of an M-1 day journey.
* On the second line, M integers P1, P2, ..., PM are written with a space as a delimiter. These represent the rail movement from city Pj to city Pj + 1 on day j (1 ≤ j ≤ M − 1).
* On the i-th line (1 ≤ i ≤ N − 1) of the following N − 1 lines, three integers Ai, Bi, and Ci are written separated by blanks. These indicate that the fare when boarding the railway i with a paper ticket is Ai yen, the fare when boarding with an IC card is Bi yen, and the amount of the IC card that can be used on the railway i is Ci yen.
output
On the standard output, output an integer that represents the minimum value of the travel amount in yen on one line.
Limits
All input data satisfy the following conditions.
* 2 ≤ N ≤ 100 000.
* 2 ≤ M ≤ 100 000.
* 1 ≤ Bi <Ai ≤ 100 000 (1 ≤ i ≤ N − 1).
* 1 ≤ Ci ≤ 100 000 (1 ≤ i ≤ N − 1).
* 1 ≤ Pj ≤ N (1 ≤ j ≤ M).
* Pj ≠ Pj + 1 (1 ≤ j ≤ M − 1).
Input / output example
Input example 1
4 4
1 3 2 4
120 90 100
110 50 80
250 70 130
Output example 1
550
In this case, the method to minimize the cost of travel is as follows.
* Purchase IC cards for Railroad 2 and Railroad 3. This costs 80 + 130 = 210 yen.
* On the first day, move from city 1 to city 2 using a paper ticket, and then move from city 2 to city 3 using an IC card. This costs 120 + 50 = 170 yen.
* On the second day, move from city 3 to city 2 using an IC card. This costs 50 yen.
* On the third day, move from city 2 to city 3 using an IC card, and then move from city 3 to city 4 using an IC card. This costs 50 + 70 = 120 yen.
When moving in this way, the total amount of money spent on the trip is 210 + 170 + 50 + 120 = 550 yen. Since this is the minimum, it outputs 550.
Input example 2
8 5
7 5 3 5 4
12 5 8
16 2 1
3 1 5
17 12 17
19 7 5
12 2 19
4 1 3
Output example 2
81
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4 4
1 3 2 4
120 90 100
110 50 80
250 70 130
Output
550
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int p[100000];
int a[100000], b[100000], c[100000];
int t[100000];
int main()
{
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++){
scanf("%d", &p[i]);
p[i]--;
}
for (int i = 0; i < n - 1; i++){
scanf("%d %d %d", &a[i], &b[i], &c[i]);
}
for (int i = 0; i < m - 1; i++){
int fr = min(p[i], p[i + 1]);
int to = max(p[i], p[i + 1]);
t[fr]++;
t[to]--;
}
for (int i = 0; i < n - 1; i++){
t[i + 1] += t[i];
}
long long res = 0;
for (int i = 0; i < n; i++){
long long A = (long long)a[i] * t[i];
long long B = (long long)b[i] * t[i] + c[i];
res += min(A, B);
}
printf("%lld\n", res);
return 0;
}
|
In mathematics, some plain words have special meanings. The word "net" is one of such technical terms. In mathematics, the word "net" is sometimes used to mean a plane shape which can be folded into some solid shape.
The following are a solid shape (Figure 1) and one of its net (Figure 2).
<image>| <image>
---|---
Figure 1: a prism| Figure 2: a net of a prism
Nets corresponding to a solid shape are not unique. For example, Figure 3 shows three of the nets of a cube.
<image>
---
Figure 3: examples of nets of a cube
In this problem, we consider nets of dice. The definition of a die is as follows.
1. A die is a cube, each face marked with a number between one and six.
2. Numbers on faces of a die are different from each other.
3. The sum of two numbers on the opposite faces is always 7.
Usually, a die is used in pair with another die. The plural form of the word "die" is "dice".
Some examples of proper nets of dice are shown in Figure 4, and those of improper ones are shown in Figure 5.
<image>
---
Figure 4: examples of proper nets of dice
<image>
---
Figure 5: examples of improper nets
The reasons why each example in Figure 5 is improper are as follows.
(a) The sum of two numbers on the opposite faces is not always 7. (b) Some faces are marked with the same number. (c) This is not a net of a cube. Some faces overlap each other. (d) This is not a net of a cube. Some faces overlap each other and one face of a cube is not covered. (e) This is not a net of a cube. The plane shape is cut off into two parts. The face marked with '2' is isolated. (f) This is not a net of a cube. The plane shape is cut off into two parts. (g) There is an extra face marked with '5'.
Notice that there are two kinds of dice. For example, the solid shapes formed from the first two examples in Figure 4 are mirror images of each other.
Any net of a die can be expressed on a sheet of 5x5 mesh like the one in Figure 6. In the figure, gray squares are the parts to be cut off. When we represent the sheet of mesh by numbers as in Figure 7, squares cut off are marked with zeros.
<image>| <image>
---|---
Figure 6: 5x5 mesh| Figure 7: representation by numbers
Your job is to write a program which tells the proper nets of a die from the improper ones automatically.
Input
The input consists of multiple sheets of 5x5 mesh.
N
---
Mesh0
Mesh1
...
MeshN-1
N is the number of sheets of mesh. Each Meshi gives a sheet of mesh on which a net of a die is expressed. Meshi is in the following format.
F00 | F01 | F02 | F03 | F04
---|---|---|---|---
F10 | F11 | F12 | F13 | F14
F20 | F21 | F22 | F23 | F24
F30 | F31 | F32 | F33 | F34
F40 | F41 | F42 | F43 | F44
Each Fij is an integer between 0 and 6. They are separated by a space character.
Output
For each Meshi, the truth value, true or false, should be output, each in a separate line. When the net of a die expressed on the Meshi is proper, output "true". Otherwise, output "false".
Example
Input
6
0 0 0 0 0
0 0 0 0 6
0 2 4 5 3
0 0 1 0 0
0 0 0 0 0
0 0 3 0 0
0 0 2 0 0
0 0 4 1 0
0 0 0 5 0
0 0 0 6 0
0 0 0 3 0
0 0 2 5 0
0 4 1 0 0
0 0 6 0 0
0 0 0 0 0
0 6 2 0 0
0 0 4 0 0
0 1 5 0 0
0 0 3 0 0
0 0 0 0 0
0 0 0 0 6
0 2 4 5 3
0 0 1 0 0
0 0 0 0 0
0 0 0 1 0
0 0 0 0 6
0 2 4 5 3
0 0 0 0 0
0 0 0 0 0
0 0 0 1 0
Output
true
true
false
false
false
false
|
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define FOR(i,a,n) for(ll i=a;i<(ll)(n);i++)
struct Dice {
int b,f,l,r,u,d;
void RollN()
{
// --y;
int buff = d;
d = f;
f = u;
u = b;
b = buff;
}
void RollS()
{
// ++y;
int buff = d;
d = b;
b = u;
u = f;
f = buff;
}
void RollL() // ----->
{
int buff = f;
f = l;
l = b;
b = r;
r = buff;
}
void RollR() // <------
{
int buff = f;
f = r;
r = b;
b = l;
l = buff;
}
void RollE() // .o -> o.
{
// --x;
int buff = d;
d = l;
l = u;
u = r;
r = buff;
}
void RollW() // o. -> .o
{
// ++x;
int buff = d;
d = r;
r = u;
u = l;
l = buff;
}
};
//頑張った
void dfs(int x, int y, int f[5][5], Dice &dice, char c, vector<vector<bool>> visited){
if(x >= 5 || x < 0 || y >= 5 || y < 0 || visited[y][x]){
return;
}
visited[y][x] = true;
if(f[y][x] == 0){
return;
}
if(c == 'r') dice.RollL();
if(c == 'l') dice.RollR();
if(c == 'u') dice.RollS();
if(c == 'd') dice.RollN();
dice.b = f[y][x];
dfs(x+1, y, f, dice, 'r', visited);
dfs(x-1, y, f, dice, 'l', visited);
dfs(x, y+1, f, dice, 'd', visited);
dfs(x, y-1, f, dice, 'u', visited);
if(c == 'r') dice.RollR();
if(c == 'l') dice.RollL();
if(c == 'u') dice.RollN();
if(c == 'd') dice.RollS();
}
int main(){
int n; cin>>n;
while(n--){
int f[5][5];
vector<int> nums(7, 0);
int x, y;
for(int i=0; i<5; i++){
for(int j=0; j<5; j++){
cin>>f[i][j];
nums[f[i][j]]++;
if(f[i][j] != 0) x=j,y=i;
}
}
//1-6の出現回数が1ならok
bool flag = false;
for(int i=1; i<7; i++){
if(nums[i] != 1) flag = true;
}
if(flag){
cout << "false" << endl;
continue;
}
Dice dice = {0, 0, 0, 0, 0, 0};
vector<vector<bool>> visited(5, vector<bool>(5, false));
dfs(x, y, f, dice, 'b', visited);
cout << ((dice.b + dice.f == 7 && dice.l+dice.r == 7 && dice.u+dice.d == 7) ? "true" : "false") << endl;
}
}
|
There is a mysterious planet called Yaen, whose space is 2-dimensional. There are many beautiful stones on the planet, and the Yaen people love to collect them. They bring the stones back home and make nice mobile arts of them to decorate their 2-dimensional living rooms.
In their 2-dimensional world, a mobile is defined recursively as follows:
* a stone hung by a string, or
* a rod of length 1 with two sub-mobiles at both ends; the rod is hung by a string at the center of gravity of sub-mobiles. When the weights of the sub-mobiles are n and m, and their distances from the center of gravity are a and b respectively, the equation n × a = m × b holds.
<image>
For example, if you got three stones with weights 1, 1, and 2, here are some possible mobiles and their widths:
<image>
Given the weights of stones and the width of the room, your task is to design the widest possible mobile satisfying both of the following conditions.
* It uses all the stones.
* Its width is less than the width of the room.
You should ignore the widths of stones.
In some cases two sub-mobiles hung from both ends of a rod might overlap (see the figure on the below). Such mobiles are acceptable. The width of the example is (1/3) + 1 + (1/4).
<image>
Input
The first line of the input gives the number of datasets. Then the specified number of datasets follow. A dataset has the following format.
r
s
w1
.
.
.
ws
r is a decimal fraction representing the width of the room, which satisfies 0 < r < 10. s is the number of the stones. You may assume 1 ≤ s ≤ 6. wi is the weight of the i-th stone, which is an integer. You may assume 1 ≤ wi ≤ 1000.
You can assume that no mobiles whose widths are between r - 0.00001 and r + 0.00001 can be made of given stones.
Output
For each dataset in the input, one line containing a decimal fraction should be output. The decimal fraction should give the width of the widest possible mobile as defined above. An output line should not contain extra characters such as spaces.
In case there is no mobile which satisfies the requirement, answer -1 instead.
The answer should not have an error greater than 0.00000001. You may output any number of digits after the decimal point, provided that the above accuracy condition is satisfied.
Example
Input
5
1.3
3
1
2
1
1.4
3
1
2
1
2.0
3
1
2
1
1.59
4
2
1
1
3
1.7143
4
1
2
3
5
Output
-1
1.3333333333333335
1.6666666666666667
1.5833333333333335
1.7142857142857142
|
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
#include <time.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
enum Type{
Stone,
Mobile,
};
struct Info{
Type type;
int index_left,index_right;
double weight,left,right,most_left_loc,most_right_loc;
};
Info info[12];
int num_stone,eq_index;
int table[7][720][6],table_index[7],eq_num[7];
double room_width;
char equation[7][100000][12];
priority_queue<double> Q;
void strcpy(char* to,char* str){
for(int i=0;str[i] != '\0';i++){
to[i] = str[i];
to[i+1] = '\0';
}
}
void makeEquation(int array[6],int array_index,char buf[12],int buf_index,int value,int rest_mult,int length){
if(rest_mult == 0){
buf[buf_index] = '\0';
strcpy(equation[length][eq_num[length]++],buf);
return;
}
if(array_index < length){
char next_buf[12];
for(int i = 0; i < buf_index; i++)next_buf[i] = buf[i];
next_buf[buf_index] = array[array_index]+'0';
makeEquation(array,array_index+1,next_buf,buf_index+1,value+1,rest_mult,length);
}
if(value >= 2){
char next_buf[12];
for(int i = 0; i < buf_index; i++)next_buf[i] = buf[i];
next_buf[buf_index] = '*';
makeEquation(array,array_index,next_buf,buf_index+1,value-1,rest_mult-1,length);
}
}
void calc_mobile(int tmp_index,int buf_index,Info tmp_info[12],int info_index,stack<int> S){
if(equation[num_stone][tmp_index][buf_index] == '\0'){
Q.push(tmp_info[info_index-1].most_left_loc+tmp_info[info_index-1].most_right_loc);
return;
}
int left,right;
double left_weight,right_weight;
char tmp_ch;
stack<int> WORK,NEXT;
while(!S.empty()){
WORK.push(S.top());
S.pop();
}
while(!WORK.empty()){
NEXT.push(WORK.top());
WORK.pop();
}
tmp_ch = equation[num_stone][tmp_index][buf_index];
if(tmp_ch >= '0' && tmp_ch <= '5'){
NEXT.push(tmp_ch-'0');
calc_mobile(tmp_index,buf_index+1,tmp_info,info_index,NEXT);
}else{ //tmp_ch == '*'
left = NEXT.top();
NEXT.pop();
right = NEXT.top();
NEXT.pop();
left_weight = tmp_info[left].weight;
right_weight = tmp_info[right].weight;
tmp_info[info_index].left = (right_weight)/(left_weight+right_weight);
tmp_info[info_index].right = 1.0-tmp_info[info_index].left;
tmp_info[info_index].type = Mobile;
tmp_info[info_index].index_left = left;
tmp_info[info_index].index_right = right;
tmp_info[info_index].weight = left_weight+right_weight;
tmp_info[info_index].most_left_loc = max(tmp_info[info_index].left+tmp_info[left].most_left_loc,tmp_info[right].most_left_loc-tmp_info[info_index].right);
tmp_info[info_index].most_right_loc = max(tmp_info[info_index].right+tmp_info[right].most_right_loc,tmp_info[left].most_right_loc-tmp_info[info_index].left);
NEXT.push(info_index);
calc_mobile(tmp_index,buf_index+1,tmp_info,info_index+1,NEXT);
}
}
void calc(int tmp_index){
Info tmp_info[12];
for(int i = 0; i < num_stone; i++)tmp_info[i] = info[i];
for(int i = num_stone; i < 12; i++){
tmp_info[i].index_left = -1;
tmp_info[i].index_right = -1;
tmp_info[i].most_left_loc = 0.0;
tmp_info[i].most_right_loc = 0.0;
}
stack<int> S;
calc_mobile(tmp_index,0,tmp_info,num_stone,S);
}
void func(){
while(!Q.empty())Q.pop();
scanf("%lf",&room_width);
scanf("%d",&num_stone);
for(int i = 0; i < num_stone; i++){
scanf("%lf",&info[i].weight);
info[i].type = Stone;
info[i].index_left = -1;
info[i].index_right = -1;
}
if(num_stone == 1){
printf("0.00000000\n");
return;
}
eq_index = eq_num[num_stone];
for(int i = 0; i < eq_index; i++){
calc(i);
}
while(!Q.empty()){
if(Q.top() < room_width){
printf("%.16lf\n",Q.top());
return;
}
Q.pop();
}
printf("-1\n");
}
void recursive(int array[6],int array_index,int length){
if(array_index == length){
for(int i = 0; i < length; i++){
table[length][table_index[length]][i] = array[i];
}
table_index[length]++;
return;
}
bool check[length];
for(int i = 0; i < length; i++)check[i] = false;
for(int i = 0; i < array_index; i++){
check[array[i]] = true;
}
for(int i = 0; i < length; i++){
if(check[i] == false){
int next_array[6];
for(int k = 0; k < array_index; k++)next_array[k] = array[k];
next_array[array_index] = i;
recursive(next_array,array_index+1,length);
}
}
}
void makeTable(){
for(int length = 2; length <= 6; length++){
table_index[length] = 0;
int first_array[6];
recursive(first_array,0,length);
}
}
int main(){
makeTable();
for(int length = 2; length <= 6; length++){
char first_buf[12];
eq_num[length] = 0;
for(int i = 0; i < table_index[length]; i++){
makeEquation(table[length][i],0,first_buf,0,0,length-1,length);
}
}
int case_num;
scanf("%d",&case_num);
for(int i = 0; i < case_num; i++)func();
return 0;
}
|
Eulerian Flight Tour
You have an airline route map of a certain region. All the airports in the region and all the non-stop routes between them are on the map. Here, a non-stop route is a flight route that provides non-stop flights in both ways.
Named after the great mathematician Leonhard Euler, an Eulerian tour is an itinerary visiting all the airports in the region taking a single flight of every non-stop route available in the region. To be precise, it is a list of airports, satisfying all of the following.
* The list begins and ends with the same airport.
* There are non-stop routes between pairs of airports adjacent in the list.
* All the airports in the region appear at least once in the list. Note that it is allowed to have some airports appearing multiple times.
* For all the airport pairs with non-stop routes in between, there should be one and only one adjacent appearance of two airports of the pair in the list in either order.
It may not always be possible to find an Eulerian tour only with the non-stop routes listed in the map. Adding more routes, however, may enable Eulerian tours. Your task is to find a set of additional routes that enables Eulerian tours.
Input
The input consists of a single test case.
$n$ $m$
$a_1$ $b_1$
...
$a_m$ $b_m$
$n$ ($3 \leq n \leq 100$) is the number of airports. The airports are numbered from 1 to $n$. $m$ ($0 \leq m \leq \frac{n(n-1)}{2}$) is the number of pairs of airports that have non-stop routes. Among the $m$ lines following it, integers $a_i$ and $b_i$ on the $i$-th line of them ($1 \leq i \leq m$) are airport numbers between which a non-stop route is operated. You can assume $1 \leq a_i < b_i \leq n$, and for any $i \ne j$, either $a_i \ne a_j$ or $b_i \ne b_j$ holds.
Output
Output a set of additional non-stop routes that enables Eulerian tours. If two or more different sets will do, any one of them is acceptable. The output should be in the following format.
$k$
$c_1$ $d_1$
...
$c_k$ $d_k$
$k$ is the number of non-stop routes to add, possibly zero. Each of the following $k$ lines should have a pair of integers, separated by a space. Integers $c_i$ and $d_i$ in the $i$-th line ($c_i < d_i$) are airport numbers specifying that a non-stop route is to be added between them. These pairs, ($c_i, d_i$) for $1 \leq i \leq k$, should be distinct and should not appear in the input.
If adding new non-stop routes can never enable Eulerian tours, output -1 in a line.
Sample Input 1
4 2
1 2
3 4
Sample Output 1
2
1 4
2 3
Sample Input 2
6 9
1 4
1 5
1 6
2 4
2 5
2 6
3 4
3 5
3 6
Sample Output 2
-1
Sample Input 3
6 7
1 2
1 3
1 4
2 3
4 5
4 6
5 6
Sample Output 3
3
1 5
2 4
2 5
Sample Input 4
4 3
2 3
2 4
3 4
Sample Output 4
-1
Sample Input 5
5 5
1 3
1 4
2 4
2 5
3 5
Sample Output 5
0
Example
Input
4 2
1 2
3 4
Output
2
1 4
2 3
|
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = (ll)1000000007 * 1000000007;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef long double ld;
typedef complex<ld> Point;
const ld eps = 1e-11;
const ld pi = acos(-1.0);
typedef pair<ll, ll> LP;
typedef pair<ld, ld> LDP;
typedef unsigned long long ul;
int n, m;
bool used[100][100];
struct edge {
int a, b;
};
vector<edge> ans;
void out() {
cout << ans.size() << endl;
rep(i, ans.size()) {
if (ans[i].a > ans[i].b)swap(ans[i].a, ans[i].b);
cout << ans[i].a+1 << " " << ans[i].b+1 << endl;
}
}
vector<edge> v, cv;
int num[100];
bool chked[100];
vector<int> rG[100];
vector<int> G[100];
bool ban[100][100];
void dfs(int fr,int id) {
chked[id] = true;
rep(j, G[id].size()) {
dfs(id,G[id][j]);
}
if (num[id] % 2 == 0) {
if (fr != id) {
num[fr]--; num[id]--;
ans.push_back({ min(fr, id), max(fr, id) });
ban[min(fr, id)][max(fr,id)] = true;
}
}
}
void make_tree(int root) {
chked[root] = true;
rep(j, rG[root].size()) {
int to = rG[root][j];
if (chked[to])continue;
G[root].push_back(to);
make_tree(to);
//cout << root << " " << to << endl;
}
}
int par[100];
int rank1[100];
void init() {
for (int i = 0; i < n; i++) {
par[i] = i;
rank1[i] = 0;
}
}
int find(int x) {
if (par[x] == x) {
return x;
}
else {
return par[x] = find(par[x]);
}
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)return;
if (rank1[x] < rank1[y]) {
par[x] = y;
}
else {
par[y] = x;
if (rank1[x] == rank1[y])rank1[x]++;
}
}
bool same(int x, int y) {
return find(x) == find(y);
}
vector<int> atu[100];
void renketuni() {
int z = 0;
rep(i, ans.size()) {
unite(ans[i].a, ans[i].b);
}
bool rest[100] = {};
rep(i, n) {
if (rest[i])continue;
rep(j, n) {
if (same(i, j)) {
atu[z].push_back(j); rest[j] = true;
}
}
z++;
}
rep(i, z) {
Rep(j, i + 1, z) {
rep(k, 2) {
rep(l, 2) {
ans.push_back({ atu[i][k],atu[j][l] });
}
}
}
}
}
int main() {
cin >> n >> m; init();
rep(i, m) {
int a, b; cin >> a >> b; a--; b--; if (a > b)swap(a, b);
v.push_back({ a,b });
unite(a, b);
used[a][b] = true;
}
rep(i, n) {
Rep(j, i + 1, n) {
if (!used[i][j]) {
cv.push_back({ i,j });
}
}
}
if (n % 2) {
rep(i, n) {
Rep(j, i + 1, n) {
if (!used[i][j])ans.push_back({ i,j });
}
}
out();
}
else {
rep(j, cv.size()) {
rG[cv[j].a].push_back(cv[j].b);
rG[cv[j].b].push_back(cv[j].a);
num[cv[j].b]++;
num[cv[j].a]++;
}
//rep(i, n)cout << num[i] << endl;
rep(i, n) {
if (rG[i].size() == 0) {
cout << -1 << endl; return 0;
}
else if (rG[i].size() == n-1) {
rep(j, n) {
Rep(k, j + 1, n) {
if (i == j || i == k)continue;
if (!used[j][k]) {
ans.push_back({ j,k });
}
}
}
if (ans.size() == 0)cout << -1 << endl;
else {
int x = ans[0].a, y = ans[0].b;
ans.erase(ans.begin());
ans.push_back({ min(i,x),max(i,x) });
ans.push_back({ min(i,y),max(i,y) });
out();
}
return 0;
}
}
rep(i, n) {
if (chked[i])continue;
make_tree(i);
dfs(i, i);
//rep(j, n)cout << num[j] << endl;
if(num[i]%2==0){
cout << -1 << endl;
return 0;
}
}
/*rep(i, n) {
Rep(j, i + 1, n) {
if (ban[i][j] || used[i][j])continue;
ans.push_back({ i,j });
}
}*/
renketuni();
out();
}
return 0;
}
|
Making Lunch Boxes
Taro has been hooked on making lunch boxes recently. Taro has obtained a new lunch box recipe book today, and wants to try as many of the recipes listed in the book as possible.
Enough of the ingredients for all the recipes are at hand, but they all are in vacuum packs of two. If only one of them is used leaving the other, the leftover will be rotten easily, but making two of the same recipe is not interesting. Thus he decided to make a set of lunch boxes, each with different recipe, that wouldn't leave any unused ingredients.
Note that the book may include recipes for different lunch boxes made of the same set of ingredients.
How many lunch box recipes can Taro try today at most following his dogma?
Input
The input consists of at most 50 datasets, each in the following format.
n m
b1,1...b1,m
...
bn,1...bn,m
The first line contains n, which is the number of recipes listed in the book, and m, which is the number of ingredients. Both n and m are positive integers and satisfy 1 ≤ n ≤ 500, 1 ≤ m ≤ 500 and 1 ≤ n × m ≤ 500. The following n lines contain the information for each recipe with the string of length m consisting of 0 or 1. bi,j implies whether the i-th recipe needs the j-th ingredient. 1 means the ingredient is needed for the recipe and 0 means not. Each line contains at least one 1.
The end of the input is indicated by a line containing two zeros.
Output
For each dataset, output the maximum number of recipes Taro can try.
Sample Input
4 3
110
101
011
110
7 1
1
1
1
1
1
1
1
4 5
10000
01000
00100
00010
6 6
111111
011000
100000
000010
100001
100100
0 0
Output for the Sample Input
3
6
0
6
Example
Input
4 3
110
101
011
110
7 1
1
1
1
1
1
1
1
4 5
10000
01000
00100
00010
6 6
111111
011000
100000
000010
100001
100100
0 0
Output
3
6
0
6
|
#include <bits/stdc++.h>
using Int = int64_t;
const Int inf = 1LL << 53;
int main() {
for(;;) {
Int n, m;
std::cin >> n >> m;
if( n == 0 && m == 0 ) {
break;
}
auto xss = std::vector<std::string>(n);
for(Int i = 0; i < n; ++i) {
std::string ss;
std::cin >> ss;
xss[i] = ss;
}
if( n <= 20 ) {
Int res = 0;
for(Int i = 0; i < (1<<n); ++i) {
std::string ss(m, '0');
Int num = 0;
for(Int k = 0; k < n; ++k) {
if( (i & (1 << k)) != 0 ) {
num += 1;
for(Int j = 0; j < m; ++j) {
ss[j] = ss[j] == xss[k][j] ? '0' : '1';
}
}
}
bool valid = true;
for(Int j = 0; j < m; ++j) {
if( ss[j] != '0' ) {
valid = false;
}
}
if( valid ) {
res = std::max(res, num);
}
}
std::cout << res << std::endl;
}
else {
auto ys = std::vector<Int>(n);
for(Int i = 0; i < n; ++i) {
Int t = 0;
for(Int k = 0; k < m; ++k) {
if( xss[i][k] == '1' ) {
t |= 1 << k;
}
}
ys[i] = t;
}
std::vector<Int> dp(1<<m, -inf);
std::vector<Int> dp2(1<<m, -inf);
dp[0] = 0;
for(Int i = 0; i < n; ++i) {
for(Int k = 0; k < 1<<m; ++k) {
dp2[k] = std::max(dp[k], dp[k^ys[i]]+1);
}
std::swap(dp, dp2);
}
std::cout << dp[0] << std::endl;
}
}
}
|
A company “ACM Foods” is preparing for opening its chain shop in a certain area, but another company “ICPC Pizza” is also planning to set up its branch shop in the same area. In general, two competitive shops gain less incomes if they are located so close to each other. Thus, if both “ACM Foods” and “ICPC Pizza” went on opening, they would be damaged financially. So, they had a discussion on this matter and made the following agreement: only one of them can branch its shop in the area. It is determined by Rock-Paper-Scissors (RPS) which to branch the shop.
ACM Foods is facing financial difficulties and strongly desires to open their new shop in that area. The executives have decided to make every effort for finding out a very strong RPS player. They believes that players who win consecutive victories must be strong players. In order to find such a player for sure, they have decided their simple strategy.
In this strategy, many players play games of RPS repeatedly, but the games are only played between players with the same number of consecutive wins. At the beginning, all the players have no wins, so any pair of players can play a game. The games can be played by an arbitrary number of pairs simultaneously. Let us call a set of simultaneous games as a turn. After the first turn, some players will have one win, and the other players will remain with no wins. In the second turn, some games will be played among players with one win, and some other games among players with no wins. For the former games, the winners will have two consecutive wins, and the losers will lose their first wins and have no consecutive wins. For the latter games, the winners will have one win, and the losers will remain with no wins. Therefore, after the second turn, the players will be divided into three groups: players with two consecutive wins, players with one win, and players with no wins. Again, in the third turn, games will be played among players with two wins, among with one win, and among with no wins. The following turns will be conducted so forth. After a sufficient number of turns, there should be a player with the desired number of consecutive wins.
The strategy looks crazy? Oh well, maybe they are confused because of their financial difficulties.
Of course, this strategy requires an enormous amount of plays. The executives asked you, as an employee of ACM Foods, to estimate how long the strategy takes. Your task is to write a program to count the minimum number of turns required to find a player with M consecutive wins among N players.
Input
The input consists of multiple test cases. Each test case consists of two integers N (2 ≤ N ≤ 20) and M (1 ≤ M < N) in one line.
The input is terminated by the line containing two zeroes.
Output
For each test case, your program must output the case number followed by one integer which indicates the minimum number of turns required to find a person with M consecutive wins.
Example
Input
2 1
10 5
15 10
0 0
Output
Case 1: 1
Case 2: 11
Case 3: 210
|
#include<cstdio>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
int main(){
for(int cas=1,n,m;scanf("%d%d",&n,&m),n;cas++){
int t=0;
int win[21]={n};
while(win[m]==0){
int next[21]={};
rep(i,m){
next[i+1]+=win[i]/2;
next[ 0 ]+=win[i]/2;
next[ i ]+=win[i]%2;
}
rep(i,m+1) win[i]=next[i];
t++;
}
printf("Case %d: %d\n",cas,t);
}
return 0;
}
|
Problem F: Farey Sequence
slip likes to look at the numbers. Just looking at the remaining time while downloading the file is enough to kill the time. Such a slip was taught an interesting sequence by a friend. The definition of the sequence is as follows.
The general term is expressed as Fn. Fn is an arrangement of all reduced fractions (irreducible fractions) from 0 to 1 with a denominator of n or less, in ascending order. However, the integers 0 and 1 are treated as fractions 0/1 and 1/1, respectively.
So F3 is
F3 = (0/1, 1/3, 1/2, 2/3, 1/1)
It is expressed as.
If F5
F5 = (0/1, 1/5, 1/4, 1/3, 2/5, 1/2, 3/5, 2/3, 3/4, 4/5, 1/1)
It is expressed as.
slip quickly fell in love with this sequence. However, even looking at these sequences, I couldn't quite grasp the characteristics. In order to grasp the characteristics, I first tried to find out how many terms there were in each term, but I didn't understand the rules for how to increase them, so I gave up trying to understand them on my own.
Therefore, I decided to ask you, who thinks you are a friend, how many terms there are in the specified terms. Your job is to find the number of terms in a given term.
Input
The input is given in the following format.
t
n1
...
ni
...
nt
t (1 ≤ t ≤ 10000) is the number of test cases. ni (1 ≤ ni ≤ 1000000) is the number of the given term.
Output
Display the number of terms on one line for each test case.
Sample Input
2
3
Five
Output for Sample Input
Five
11
Example
Input
2
3
5
Output
5
11
|
// 6/2
// 2-6-4. 素数のこすう
// エラトステネスの篩
#include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1e9;
// Sieve of Eratosthenes
// https://youtu.be/UTVg7wzMWQc?t=2774
struct Sieve {
int n;
vector<int> f, primes;
Sieve(int n=1):n(n), f(n+1) {
f[0] = f[1] = -1;
for (ll i = 2; i <= n; ++i) {
if (f[i]) continue;
primes.push_back(i);
f[i] = i;
for (ll j = i*i; j <= n; j += i) {
if (!f[j]) f[j] = i;
}
}
}
bool isPrime(int x) { return f[x] == x;}
vector<int> factorList(int x) {
vector<int> res;
while (x != 1) {
res.push_back(f[x]);
x /= f[x];
}
return res;
}
vector<P> factor(int x) {
vector<int> fl = factorList(x);
if (fl.size() == 0) return {};
vector<P> res(1, P(fl[0], 0));
for (int p : fl) {
if (res.back().first == p) {
res.back().second++;
} else {
res.emplace_back(p, 1);
}
}
return res;
}
};
int main() {
// vector<vector<bool>> is_unique(1e6 + 1, vector<bool>(1e6 + 1, true)); // is_unique[i][j] = j / iがユニークかどうか
// for (int i = 1; i < 1e6; i++) {
// for (int j = 1; j < )
// }
// Sieve sieve(1e6);
// vector<int> f(1e6 + 1); // f[i] = 分母がiの時の項目数
// f[0] = 0;
// f[1] = 2; // 0/1, 1/1
// for(int i = 2; i <= 1e6; i++) {
// vector<P> fact = sieve.factor(i);
// ll yakusu = 1;
// for (auto f : fact) {
// yakusu *= f.second + 1;
// }
// f[i] = i - yakusu;
// }
// vector<int> unique(1e6 + 1); // unique[i] = 分母がiで約分できない数。ただし0は覗く。
// rep(i, 1e6 + 1) unique[i] = i;
// for (int i = 1; i <= 1e6; i++) {
// for (int j = i * 2; j <= 1e6; j += i) {
// unique[j]--;
// }
// }
// unique[1] += 1; // 1の時は0/1があるので特殊。
// vector<int> ans(1e6 + 1);
// ans[0] = 0;
// for(int i = 1; i <= 1e6; i++) {
// printf("unique[%d] = %d\n", i, unique[i]);
// ans[i] = ans[i - 1] + unique[i];
// };
Sieve sieve(1e6);
vector<ll> F(1e6 + 1);
F[0] = 0;
F[1] = 2;
for (int i = 2; i <= 1e6; i++) {
vector<P> primes = sieve.factor(i);
F[i] = i;
for (auto p : primes) {
F[i] *= (1.0 - 1.0 / (double)p.first);
}
}
// rep(i, 10) {
// printf("F[%d] = %d\n", i, F[i]);
// }
vector<ll> ans(1e6 + 1);
ans[0] = 0;
for (int i = 1; i <= 1e6; i++) {
ans[i] = ans[i - 1] + F[i];
}
int t;
cin >> t;
vector<int> n(t);
rep(i, t) cin >> n[i];
rep(i, t) cout << ans[n[i]] << endl;
}
|
A permutation of N numbers from 1 to N A1, A2, ……, AN is given. You can perform the operation reverse (i, j) to reverse the order of the numbers in the interval [i, j] (1 ≤ i ≤ j ≤ N) for this permutation. For example, if reverse (2, 4) is applied to [1, 2, 3, 4, 5], it becomes [1, 4, 3, 2, 5]. Calculate how many operations you need to do at a minimum to get the permutation sorted in ascending order.
Constraints
* N is an integer
* 2 ≤ N ≤ 10
Input
The input is given in the following format.
> N
> A1 A2 …… AN
>
Output
Print the solution to the problem on one line.
Examples
Input
5
1 4 3 5 2
Output
2
Input
5
3 1 5 2 4
Output
4
Input
3
1 2 3
Output
0
Input
10
3 1 5 2 7 4 9 6 10 8
Output
9
|
#include <cstdio>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;
typedef long long LL;
int n;
LL encode(const vector<char> &v){
LL a = 0;
for(int i = 0; i < n; ++i){
a |= (LL)v[i] << (i << 2);
}
return a;
}
vector<char> decode(LL x){
vector<char> v(n);
for(int i = 0; i < n; ++i){
v[i] = (x >> (i << 2)) & 15;
}
return v;
}
int main(){
scanf("%d", &n);
vector<char> s(n), goal(n);
int x;
for(int i = 0; i < n; ++i){
scanf("%d", &x);
s[i] = x;
goal[i] = i + 1;
}
if( s == goal ){
puts("0");
return 0;
}
vector<LL> v1, v2;
v1.push_back( encode(s) );
v2.push_back( encode(goal) );
set<LL> old;
old.insert( v1[0] );
old.insert( v2[0] );
int a;
for(int a = 1; ; ++a){
vector<LL> tmp;
for(int i = 0; i < v1.size(); ++i){
s = decode( v1[i] );
for(int j = 0; j < n - 1; ++j)
for(int k = j + 2; k <= n; ++k){
vector<char> t = s;
reverse(t.begin() + j, t.begin() + k);
LL u = encode(t);
if( binary_search(v2.begin(), v2.end(), u) ){
printf("%d\n", a);
return 0;
}
if( old.find(u) == old.end() ){
old.insert(u);
tmp.push_back(u);
}
}
}
sort(tmp.begin(), tmp.end());
v1.swap(tmp);
v1.swap(v2);
}
}
|
After many years of research, Ikta has acquired the ability to predict the future! The time and money he spent on this research was enormous, but it's finally time to be rewarded. To get the money back, Ikta decided to start investing in stocks.
Ikta does not currently own any shares, but owns x yen. He has invested in n stocks, and has succeeded in predicting the stock price for d days from today. As a result, it was surprisingly found that there was no intraday stock price fluctuation for d days from today. In other words, we know the stock price pi, j yen of the stock j (1 ≤ j ≤ n) on the i (1 ≤ i ≤ d) day when today is the first day. Ikta is free to buy and sell stocks each day. That is, the following operations (purchase / sale) can be performed at any time in any order and any number of times. However, the amount of money held and the number of units held of shares before and after each operation must be non-negative integers.
* Purchase: On day i, select one stock type j (1 ≤ j ≤ n) and pay pi, j yen in possession to obtain 1 unit of stock j.
* Sale: On day i, select one stock type j (1 ≤ j ≤ n) and pay 1 unit of stock j to get pi, j yen.
(While he was absorbed in his research, the securities trading system made great progress and there were no transaction fees.)
Ikta had studied information science at university, but had forgotten everything he had learned at university before he could devote himself to future prediction research. Instead of him, write a program that maximizes your money on the final day.
Input
The input is given in the following format.
n d x
p1,1 ... p1, n
...
pd, 1 ... pd, n
* n: Number of stock types
* d: days
* x: Money on the first day
* pi, j: Stock price of stock j on day i (today is the first day)
Constraints
Each variable being input is an integer that satisfies the following constraints.
* 1 ≤ n ≤ 10
* 1 ≤ d ≤ 10
* 1 ≤ x, pi, j ≤ 105
* It is guaranteed that the amount of money you have on the last day will be 105 or less.
Output
Output the last day's money in one line when you invest optimally.
Examples
Input
2 2 5
3 2
5 4
Output
9
Input
1 2 5
6
10000
Output
5
Input
2 3 5
4 5
6 3
8 5
Output
11
Input
3 3 10
10 9 6
8 7 3
7 5 1
Output
10
|
#include <iostream>
using namespace std;
int n,d,p[10][10],ans;
void saiki(int sum,int x,int day,int I){
int f=1;
for(int i=I;i<n;i++)
if(p[day][i]/p[day-1][i]&&x/p[day-1][i]) {
f=0;
saiki(sum+p[day][i],x-p[day-1][i],day,i);
}
if(f)ans=max(ans,sum+x);
}
int main(){
cin>>n>>d>>ans;
for(int i=0;i<d;i++)
for(int j=0;j<n;j++)cin>>p[i][j];
for(int i=0;i<d-1;i++)saiki(0,ans,i+1,0);
cout<<ans<<endl;
return 0;
}
|
Problem statement
It was a month ago. Nikunishi, an elementary school student, did not do his summer vacation homework. Therefore, the independent study decided to investigate the strength of the eggs at home.
In this study, we define the strength of an egg as H when it does not crack when dropped from height H and cracks when dropped from height H + 1. Here, H is a non-negative integer and cannot be dropped from a height other than a non-negative integer. Nikunishi conducts an experiment in which one egg is dropped. The result of the experiment is either cracked or not cracked. Also, the strength of all eggs is the same. In other words, the results of the experiment are the same regardless of which egg is used.
Nikunishi-kun prepared a staircase consisting of steps with an integer height from 1 to N, and E eggs of unknown strength. We already know that it does not crack at height 0 and cracks at height N + 1. Meat Nishi-kun drops the egg from the same height as each step toward the ground, and checks whether the egg cracked or not each time. At this time, the broken egg cannot be used again, but if it does not break, it can be reused. This experiment can be continued as long as the eggs remain. It is assumed that the strength of the egg is obtained when the above-defined H is obtained by repeating the experiment several times.
There are only a few days left until the end of summer vacation. You cannot make it in time unless you finish the experiment with the minimum number of times. Therefore, you, the brother of Nishikun, decided to write a program to find the maximum number of experiments required when the optimum method was taken so that the number of drops was reduced in order to know the strength of the egg.
input
T
N_1 E_1
...
N_T E_T
One file contains multiple test cases. The integer T is given on the first line. The i-th test case E_i, N_i is given on the 1 + i line
Constraint
* An integer
* 1 ≤ T ≤ 1000
* 1 ≤ N_i ≤ 10 ^ {18}
* 1 ≤ E_i ≤ 50
* Does not include inputs with more than 50 outputs
output
Output the answer to the i-th test case on line i. It spans T lines in total.
sample
Sample input 1
3
5 1
5 2
1 2
Sample output 1
Five
3
1
* First case
* Since there is only one egg, there is no choice but to drop it in order from the first stage.
* Second case
* First, drop from the second stage
* If dropped from the 2nd stage and cracked, drop from the 1st stage
* If dropped from the 2nd step and did not crack, drop from the 4th step
* If dropped from the first stage and cracked, the experiment ends
* If dropped from the first stage and does not crack, the experiment ends
* If dropped from the 4th step and cracked, drop from the 3rd step
* If dropped from the 4th step and did not crack, drop from the 5th step
* If dropped from the 3rd stage and cracked, the experiment ends
* If dropped from the 3rd stage and does not crack, the experiment ends
* Experiment ends when dropped from the 5th stage and cracked
* If dropped from the 5th stage and does not crack, the experiment ends
* Third case
* Drop from the first stage and finish the experiment
Example
Input
3
5 1
5 2
1 2
Output
5
3
1
|
#include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <limits>
#include <climits>
#include <cfloat>
#include <functional>
using namespace std;
const long long INF = LLONG_MAX / 2;
int main()
{
int t;
cin >> t;
while(--t >= 0){
long long n;
int e;
cin >> n >> e;
vector<vector<long long> > dp(51, vector<long long>(e+1, 0));
for(int i=1; i<=50; ++i){
for(int j=1; j<=e; ++j){
dp[i][j] = dp[i-1][j] + dp[i-1][j-1] + 1;
dp[i][j] = min(dp[i][j], INF);
}
}
int ans = 0;
while(dp[ans][e] < n)
++ ans;
cout << ans << endl;
}
return 0;
}
|
D: Shiritori Compression
problem
Ebi-chan and Kana-chan did a shiritori. Ebi-chan is looking at the memo of the word that came out in Shiritori.
Ebi-chan wants to remove redundant continuous subsequences from this word sequence w_1, w_2, ..., w_N until they no longer exist. The redundant continuous subsequence that Ebi-chan thinks is defined as follows.
* The continuous subsequence w_i, ..., w_ {j-1} is redundant when i, j satisfying the following is present.
* For the subscripts i, j with i <j, the first letters of the words w_i and w_j are equal.
At this time, Ebi-chan removes words with subscript i or more and j-1 or less.
For example, consider the following word string:
* apple → editor → random → me → edge
It is compressed as follows:
* apple → edge
Since the first letter of editor and edge matches with e, the words from editor to just before edge (me) are stripped.
Please note that Ebi-chan's criteria do not consider the same trailing character to be redundant. For example, in the compressed word string above, the last letter of apple and edge is both e, but this does not remove the word.
The following examples are also possible.
* orange → eel → luck
* banana → at → tomb → bus → sound → does → some
* peach → hero → owl → loop → proof → fish → he
Each of these can be compressed as follows: Note that in each case, the last word is saved.
* orange → eel → luck
* Already compressed.
* bus → some
* You can compress banana to bus and sound to some.
* peach → he
* You can also compress proof → fish → he, but note that the number of words after compression is different.
Ebi-chan's memos are given, so please output the minimum value L of the length (number of words) of the word string obtained by compressing them.
You can assume that "the same word appears multiple times" or "the first letter of a word does not match the last letter of the previous word" does not occur.
Input format
N
w_1
...
w_N
The number of words N is given on the first line, and the i-th word is given on the 1 + i line.
Constraint
* 1 \ leq N \ leq 10 ^ 5
* 1 \ leq $ \ sum_ {i = 1} ^ N $ | w_i | \ leq 10 ^ 6
* Each letter of w_i is lowercase
Output format
Print L on one line. No other extra characters should be included.
Input example 1
7
banana
at
tomb
bus
sound
does does
some
Output example 1
2
This is the example given above.
Input example 2
7
peach
hero
owl
loop
proof
fish
he
Output example 2
2
Another example given above.
Example
Input
7
banana
at
tomb
bus
sound
does
some
Output
2
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb push_back
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
typedef vector<int>vint;
typedef pair<int,int>pint;
typedef vector<pint>vpint;
template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}
int N;
string S[222222];
int dp[222222];
signed main(){
cin>>N;
rep(i,N)cin>>S[i];
int dp2[26];
rep(i,26)dp2[i]=INT_MAX;
dp2[S[0][0]-'a']=0;
rep(i,N){
dp[i]=dp2[S[i][0]-'a']+1;
chmin(dp2[S[i].back()-'a'],dp[i]);
}
cout<<dp[N-1]<<endl;
return 0;
}
|
Problem
There are $ 2 $ teams, Team UKU and Team Ushi. Initially, Team UKU has $ N $ people and Team Uku has $ M $ people. Team UKU and Team Ushi decided to play a game called "U & U". "U & U" has a common score for $ 2 $ teams, and the goal is to work together to minimize the common score. In "U & U", everyone's physical strength is $ 2 $ at first, and the common score is $ 0 $, and the procedure is as follows.
1. Each person in Team UKU makes exactly $ 1 $ attacks on someone in Team UKU for $ 1 $. The attacked person loses $ 1 $ in health and leaves the team when he or she reaches $ 0 $. At this time, when the number of team members reaches $ 0 $, the game ends. If the game is not over when everyone on Team UKU has just completed $ 1 $ attacks, $ 1 $ will be added to the common score and proceed to $ 2 $.
2. Similarly, team members make $ 1 $ each and just $ 1 $ attacks on someone in Team UKU. The attacked person loses $ 1 $ in health and leaves the team when he or she reaches $ 0 $. At this time, when the number of team UKUs reaches $ 0 $, the game ends. If the game isn't over when everyone on the team has just finished $ 1 $ attacks, $ 1 $ will be added to the common score and back to $ 1 $.
Given the number of team UKUs and the number of teams, find the minimum possible common score at the end of the "U & U" game.
Constraints
The input satisfies the following conditions.
* $ 1 \ le N, M \ le 10 ^ {18} $
* $ N $ and $ M $ are integers
Input
The input is given in the following format.
$ N $ $ M $
An integer $ N $ representing the number of team UKUs and an integer $ M $ representing the number of team members are given, separated by blanks.
Output
Print the lowest score on the $ 1 $ line.
Examples
Input
20 10
Output
0
Input
10 20
Output
1
Input
64783 68943
Output
4
Input
1000000000000000000 1000000000000000000
Output
2
|
#include <iostream>
using namespace std;
int main(){
long long N, M;
cin >> N >> M;
long long N_ = N, M_ = M;
// if(N > 2*M || M > 2*N){
//cout << 0 << endl;
//return 0;
//}
int ans = 0;
long long n = 2*N, m = 2*M;
while(n > 0 && m > 0){
m -= N;
if(m <= 0) break;
++ans;
M = min(m,M);
n -= M;
if(n <= 0) break;
++ans;
N = (n+1)/2;
}
int ans2 = 0;
N = N_;
M = M_;
n = 2*N;
m = 2*M;
while(n > 0 && m > 0){
m -= N;
if(m <= 0) break;
++ans2;
M = (m+1)/2;
n -= M;
if(n <= 0) break;
++ans2;
N = min(n,N);
}
cout << min(ans,ans2) << endl;
return 0;
}
|
A graph G = (V, E) is a data structure where V is a finite set of vertices and E is a binary relation on V represented by a set of edges. Fig. 1 illustrates an example of a graph (or graphs).
<image>
Fig. 1
A free tree is a connnected, acyclic, undirected graph. A rooted tree is a free tree in which one of the vertices is distinguished from the others. A vertex of a rooted tree is called "node."
Your task is to write a program which reports the following information for each node u of a given rooted tree T:
* node ID of u
* parent of u
* depth of u
* node type (root, internal node or leaf)
* a list of chidlren of u
If the last edge on the path from the root r of a tree T to a node x is (p, x), then p is the parent of x, and x is a child of p. The root is the only node in T with no parent.
A node with no children is an external node or leaf. A nonleaf node is an internal node
The number of children of a node x in a rooted tree T is called the degree of x.
The length of the path from the root r to a node x is the depth of x in T.
Here, the given tree consists of n nodes and evey node has a unique ID from 0 to n-1.
Fig. 2 shows an example of rooted trees where ID of each node is indicated by a number in a circle (node). The example corresponds to the first sample input.
<image>
Fig. 2
Note
You can use a left-child, right-sibling representation to implement a tree which has the following data:
* the parent of u
* the leftmost child of u
* the immediate right sibling of u
Constraints
* 1 ≤ n ≤ 100000
Input
The first line of the input includes an integer n, the number of nodes of the tree.
In the next n lines, the information of each node u is given in the following format:
id k c1 c2 ... ck
where id is the node ID of u, k is the degree of u, c1 ... ck are node IDs of 1st, ... kth child of u. If the node does not have a child, the k is 0.
Output
Print the information of each node in the following format ordered by IDs:
node id: parent = p, depth = d, type, [c1...ck]
p is ID of its parent. If the node does not have a parent, print -1.
d is depth of the node.
type is a type of nodes represented by a string (root, internal node or leaf). If the root can be considered as a leaf or an internal node, print root.
c1...ck is the list of children as a ordered tree.
Please follow the format presented in a sample output below.
Examples
Input
13
0 3 1 4 10
1 2 2 3
2 0
3 0
4 3 5 6 7
5 0
6 0
7 2 8 9
8 0
9 0
10 2 11 12
11 0
12 0
Output
node 0: parent = -1, depth = 0, root, [1, 4, 10]
node 1: parent = 0, depth = 1, internal node, [2, 3]
node 2: parent = 1, depth = 2, leaf, []
node 3: parent = 1, depth = 2, leaf, []
node 4: parent = 0, depth = 1, internal node, [5, 6, 7]
node 5: parent = 4, depth = 2, leaf, []
node 6: parent = 4, depth = 2, leaf, []
node 7: parent = 4, depth = 2, internal node, [8, 9]
node 8: parent = 7, depth = 3, leaf, []
node 9: parent = 7, depth = 3, leaf, []
node 10: parent = 0, depth = 1, internal node, [11, 12]
node 11: parent = 10, depth = 2, leaf, []
node 12: parent = 10, depth = 2, leaf, []
Input
4
1 3 3 2 0
0 0
3 0
2 0
Output
node 0: parent = 1, depth = 1, leaf, []
node 1: parent = -1, depth = 0, root, [3, 2, 0]
node 2: parent = 1, depth = 1, leaf, []
node 3: parent = 1, depth = 1, leaf, []
|
import sys
n = int(input())
nodes = [[-1, None, None] for _ in range(n)]
depths = [None for _ in range(n)]
for _ in range(n):
nid, k, *children = list(map(int, sys.stdin.readline().split()))
if k > 0:
nodes[nid][1] = children[0]
children.append(None)
for i in range(k):
cid = children[i]
nodes[cid][0] = nid
nodes[cid][2] = children[i+1]
def get_depth(nid):
if depths[nid] is not None:
return depths[nid]
elif nodes[nid][0] == -1:
depths[nid] = 0
return 0
else:
depths[nid] = get_depth(nodes[nid][0]) + 1
return depths[nid]
def get_children(nid):
children = []
cid = nodes[nid][1]
while cid is not None:
children.append(cid)
cid = nodes[cid][2]
return children
for nid in range(n):
pid = nodes[nid][0]
children = get_children(nid)
depth = get_depth(nid)
n_type = 'root' if pid == -1 else 'leaf' if len(children) == 0 else 'internal node'
print('node {}: parent = {}, depth = {}, {}, {}'.format(nid, pid, depth, n_type, children))
|
A state with $n$ flags of ON or OFF can be represented by a sequence of bits where $0, 1, ..., n-1$ th flag corresponds to 1 (ON) or 0 (OFF). The state can be managed by the corresponding decimal integer, because the sequence of bits is a binary representation where each bit is 0 or 1.
On the other hand, a mask is a special bit sequence which can be used to set specified bits of a given bit sequence to ON/OFF. It can also be used to extract/exclude a bit sequence based on a specified pattern.
Given a sequence of bits with 64 flags which represent a state, perform the following operations using a set of pre-defined masks. Note that each flag of the bits is initialized by OFF.
* test(i): Print 1 if $i$-th flag is ON, otherwise 0
* set(m): Set flags specified by mask $m$ to ON
* clear(m): Set flags specified by mask $m$ to OFF
* flip(m): Inverse flags specified by mask $m$
* all(m): Print 1 if all flags specified by mask $m$ are ON, otherwise 0
* any(m): Print 1 if at least one flag specified by mask $m$ is ON, otherwise 0
* none(m): Print 1 if all flags specified by mask $m$ are OFF, otherwise 0
* count(m): Print the number of flags specifed by mask $m$ with ON
* val(m): Print the decimal value of the state specified by mask $m$
Constraints
* $1 \leq n \leq 10$
* $1 \leq k \leq 64$
* $1 \leq q \leq 200,000$
* $0 \leq i < 64$
* $0 \leq m < n$
Input
The input is given in the following format.
$n$
$mask_0$
$mask_1$
:
$mask_{n-1}$
$q$
$query_1$
$query_2$
:
$query_q$
$n$ represents the number of masks. $mask_i$ represents state of $i$-th mask and is given in the following format:
$k$ $b_0$ $b_1$ ... $b_k$
$k$ is the number of ON in the bits. The following $k$ integers $b_j$ show that $b_j$-th bit is ON.
$query_i$ represents $i$-th query and is given in the following format:
0 $i$
or
1 $m$
or
2 $m$
or
3 $m$
or
4 $m$
or
5 $m$
or
6 $m$
or
7 $m$
or
8 $m$
The first digit 0, 1,...,8 represents the operation test(i), set(m), clear(m), flip(m), all(m), any(m), none(m), count(m) or val(m) respectively.
Output
Print the result in a line for each test, all, any, none, count and val operation.
Example
Input
3
3 0 1 3
1 3
3 0 1 2
8
1 0
2 1
3 1
4 2
5 2
6 2
7 2
8 2
Output
0
1
0
2
3
|
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
//INSERT ABOVE HERE
signed main(){
using BS = bitset<64>;
int n;
cin>>n;
vector<BS> ms(n);
for(int i=0;i<n;i++){
int k;
cin>>k;
for(int j=0;j<k;j++){
int x;
cin>>x;
ms[i].set(x);
}
}
BS b(0);
int q;
cin>>q;
for(int i=0;i<q;i++){
int t,x;
cin>>t>>x;
if(t==0) cout<<b[x]<<endl;
if(t==1) b|= ms[x];
if(t==2) b&=~ms[x];
if(t==3) b^= ms[x];
if(t==4) cout<<((b&ms[x])==ms[x])<<endl;
if(t==5) cout<<(b&ms[x]).any()<<endl;
if(t==6) cout<<(b&ms[x]).none()<<endl;
if(t==7) cout<<(b&ms[x]).count()<<endl;
if(t==8) cout<<(b&ms[x]).to_ullong()<<endl;
}
return 0;
}
|
Knights' tournaments were quite popular in the Middle Ages. A lot of boys were dreaming of becoming a knight, while a lot of girls were dreaming of marrying a knight on a white horse.
In this problem we consider one of these tournaments.
Let's us call a tournament binary, if it runs according to the scheme described below:
Exactly N knights take part in the tournament, N^K for some integer K > 0.
Each knight has a unique skill called strength, described as an integer from the interval [1, N].
Initially, all the knights are standing in a line, waiting for a battle. Since all their strengths are unique, each initial configuration can be described as a permutation of numbers from 1 to N.
There are exactly K rounds in the tournament, 2^K - i + 1 knights take part in the i'th round. The K'th round is called the final.
The i'th round runs in the following way: for each positive integer j ≤ 2^K - i happens a battle between a knight on the 2∙j'th position and a knight on the 2∙j+1'th position. The strongest of two continues his tournament, taking the j'th position on the next round, while the weakest of two is forced to leave.
The only knight, who has won K rounds, is the winner. The only knight, who has won K - 1 rounds, but lost the final, is the runner-up.
As you can see from the scheme, the winner is always the same, an initial configuration doesn't change anything. So, your task is to determine chances of each knight to appear in the final.
Formally, for each knight you need to count the number of initial configurations, which will lead him to the final. Since the number can be extremly huge, you are asked to do all the calculations under modulo 10^9 + 9.
Input
The first line contains the only integer K, denoting the number of rounds of the tournament.
Output
Output should consist of 2^K lines. The i'th line should contain the number of initial configurations, which lead the participant with strength equals to i to the final.
Constraints
1 ≤ K < 20
Examples
Input:
1
Output:
2
2
Input:
2
Output:
0
8
16
24
Explanation
In the first example we have N
(1, 2) -> (2)
(2, 1) -> (2)
In the second example we have N
(1, 2, 3, 4) -> (2, 4) -> (4)
(3, 2, 4, 1) -> (3, 4) -> (4)
(4, 1, 3, 2) -> (4, 3) -> (4)
|
import sys
def inverseMod(a, b):
MOD = 1000000009
if a == 1:
return b
div = MOD / a + 1
return inverseMod((a * div) % MOD, (b * div) % MOD)
def solve():
K, MOD = int(raw_input()), 1000000009
if K == 1:
print '2'
print '2'
else:
half = 1<<(K-1)
for _ in xrange(half-1):
print '0'
i, cnt = 1, 2
while i <= half:
cnt = (cnt * i) % MOD
cnt = (cnt * i) % MOD
i += 1
i = half
while i <= 2*half:
print cnt
cnt = (cnt * i) % MOD
cnt = (cnt * inverseMod(i-half+1, 1)) % MOD
i += 1
if __name__ == '__main__':
solve()
|
Little Chief loves math. Most of all, he loves equations. He can solve any equation in the whole world. Recently he found one interesting and easy equation
x1^d+x2^d+x3^d ≡ m (mod N)
Where x1, x2 and x3 are non negative integer numbers.
But, as always, this was easy enough for him and he solved it in just a few seconds. Now he wants you to do the same. Of course he understands that nobody is as good as he is, so he wants only the number of solutions of such equation which satisfies 0 ≤ x1, x2, x3 ≤ upper for given upper, d,m and N. As the answer might be very large, he asks you to find the answer modulo 1000000007.
Input
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follow. Each test case consists of 4 integers: upper, d, m, N.
Output
For each test case, output a single line containing number of solutions for the corresponding equation, modulo 1000000007. You may assume that 0^0 is equal to 1.
Constraints
1 ≤ T ≤ 10
1 ≤ upper ≤ 1,000,000,000
0 ≤ d ≤ 1,000,000,000
1 ≤ N ≤ 40
0 ≤ m < N
Example
Input:
2
2 2 3 5
1 2013 3 31
Output:
4
1
Explanation
The first equation has 4 solutions:
(0,2,2)
(2,2,0)
(2,0,2)
(1,1,1)
The second has only one:
(1,1,1)
|
def fn():
mod = 1000000007
u,d,m,n = map(int,raw_input().split())
a = []
for i in range(3):
t = []
for j in range(n):
t.append(0)
a.append(t)
for i in range(n):
t1 = pow(i,d,n)
t2 = (u-i)/n + 1
t2 %= mod
a[0][t1]+=t2
a[0][t1]%=mod
for i in range(n):
for j in range(n):
a[1][(i+j)%n]+= (a[0][i] * a[0][j])
a[1][(i+j)%n]%= mod
for i in range(n):
for j in range(n):
a[2][(i+j)%n]+= (a[0][i]* a[1][j])
a[2][(i+j)%n]%= mod
print a[2][m] % mod
t = int(raw_input())
for i in range(t):
fn()
|
Nobody knows, but N frogs live in Chef's garden.
Now they are siting on the X-axis and want to speak to each other. One frog can send a message to another one if the distance between them is less or equal to K.
Chef knows all P pairs of frogs, which want to send messages. Help him to define can they or not!
Note : More than 1 frog can be on the same point on the X-axis.
Input
The first line contains three integers N, K and P.
The second line contains N space-separated integers A1, A2, ..., AN denoting the x-coordinates of frogs".
Each of the next P lines contains two integers A and B denoting the numbers of frogs according to the input.
Output
For each pair print "Yes" without a brackets if frogs can speak and "No" if they cannot.
Constraints
1 ≤ N, P ≤ 10^5
0 ≤ Ai, K ≤ 10^9
1 ≤ A, B ≤ N
Example
Input:
5 3 3
0 3 8 5 12
1 2
1 3
2 5
Output:
Yes
Yes
No
Explanation
For pair (1, 2) frog 1 can directly speak to the frog 2 as the distance between them is 3 - 0 = 3 <= K .
For pair (1, 3) frog 1 can send a message to frog 2, frog 2 can send it to frog 4 and it can send it to frog 3.
For pair (2, 5) frogs can't send a message under current constraints.
|
def f(x):
return x[1]
n, k, p= map(int, raw_input().split())
a = map(int, raw_input().split())
l = [] #index, position, max_dist
for i in range(n):
l.append([i, a[i], 0])
l = sorted(l, key = f, reverse = True)
#print l
l[0][2] = l[0][1] + k
for i in range(1,n):
if (l[i-1][1] - l[i][1] <= k):
l[i][2] = l[i-1][2]
else:
l[i][2] = l[i][1] + k
#print l
l = sorted(l)
#print l
for _ in range(p):
x,y = map(int, raw_input().split())
if (l[x-1][2] == l[y-1][2]):
print "Yes"
else:
print "No"
|
Mike is given an undirected graph G of N vertices and M edges. A non-negative integer Xi is assigned to the i'th vertex of G, for 1 ≤ i ≤ N.
Mike was asked to assign labels to each edge of the graph so that the following condition is satisfied:
Let's suppose that the j'th edge of G connects vertices Uj and Vj. Then, a non-negative integer Yj equals to XUj xor XVj.
This challenge was too easy for Mike and he solved it quickly.
The next day, Mike started to worry that he had solved the problem too quickly and had made a lot of mistakes, so he decided to double-check his answers. To his horror, Mike discovered that all the values of Xi had been lost!
Mike is a very meticulous person and he doesn't like making mistakes, so he decided to create his own values of Xi that still produce the same values of Yj.
Your task is to determine whether it is possible to do so. If it is, you should output the K'th lexicographically valid sequence (X1, X2, ..., XN) that satisfies the above conditions, knowing the structure of G and all the values Yj.
Note
Maybe some of you aren't familiar with some terms in the statement. Here are some articles that could help you understand the problem correctly:
XOR operation: http://en.wikipedia.org/wiki/Exclusive_or
Also, the stack memory size is quite limited on CodeChef, so a deep recursion may lead to the Runtime Error verdict.
Input
The first line of the input contains the integers N, M and K.
The next M lines describe the edges of G; the j'th line contains three integers Uj, Vj and Yj.
It's guaranteed that G doesn't contain multiple edges and loops.
Output
If there is no valid labelling, or less than K valid labellings, the only line of the output should contain -1. Otherwise, the only line of the output should contain N non-negative integers, denoting the K'th lexicographically valid sequence (X1, X2, ..., XN).
It's guaranteed that in the correct sequence all of the values of Xi won't exceed the 32-bit signed integer limit.
Constraints
1 ≤ N ≤ 200,000(2 × 10^5);
0 ≤ M ≤ 300,000(3 × 10^5);
1 ≤ K ≤ 1,000,000,000(10^9);
1 ≤ Uj ≠ Vj ≤ N;
0 ≤ Yj < 2^31.
Example
Input:
5 4 2
1 2 5
1 3 9
2 4 0
2 5 1
Output:
1 4 8 4 5
Explanation
The first lexicographically valid sequence is equal to (0, 5, 9, 5, 4);
The second lexicographically valid sequence is equal to (1, 4, 8, 4, 5) - that's the one that should be printed out as the answer.
|
import sys
x = lambda : [int(n) for n in sys.stdin.readline().rstrip().split()]
def bfs(i, mode):
stack = [i+1]
while len(stack)!=0:
current = stack.pop()
if graph.has_key(current):
for node in graph[current]:
val = graph[current][node]^answer[current-1]
if visit[node-1] == mode:
visit[node-1] = not visit[node-1]
answer[node-1] = val
stack.append(node)
elif val != answer[node-1]:
return 0
return 1
(n,m,k) = x()
k-=1
answer = [0]*n
visit = [False]*n
graph = {}
while m:
(a,b,w) = x()
if not graph.has_key(a):
graph[a] = {}
if not graph.has_key(b):
graph[b] = {}
graph[a][b] = w
graph[b][a] = w
m-=1
exists = True
lastGraph = 0
for i in range(n):
if not visit[i]:
visit[i] = not visit[i]
lastGraph = i
if not bfs(i, False):
exists = False
break
if not exists:
print -1
else:
answer[lastGraph] ^= k
bfs(lastGraph, True)
print ' '.join(str(n) for n in answer)
|
DevuLand is a very strange place. There are n villages in it. Some of the villages are occupied by dinosaurs while the remaining ones by villagers.
You are given the information of DevuLand
by an array D of size n. If D[i] is non-negative, it means that there are D[i] villagers in that village.
Otherwise, it means that are -D[i]
dinosaurs in that village.
It is also guaranteed that total number of villagers in DevuLand is equal to total number of dinosaurs.
Once dinosaurs got very hungry and started eating villagers. Frightened villagers gathered immediately and met their Sarpanch Deviji. Deviji, being a very daring and negotiable person, met to the head
of dinosaurs. Soon both parties called a truce. It was decided that the villagers will provide laddus to
the dinosaurs. So everyday, each villager will take exactly one laddu to one of the dinosaurs in such a way that no dinosaur remains hungry (note that this is possible because number of villagers is the same as the number of dinosaurs).
Actually, carrying laddus is a quite a tough job. Villagers have to use a bullock cart for that. It takes one unit of grass a bullock to
carry a cart with 1 laddu for 1 kilometre. Laddus used to be very heavy in DevuLand, so a bullock cart can not carry more than one laddu.
It is also given distance between village indexed i and j is |j - i| (the absolute value) kilometres.
Now villagers sat down and found a strategy to feed laddus to dinosaurs so that they need to buy the least amount of grass from the nearby market.
They are not very good in
calculations, please find out what is the minimum number of units of grass they need to buy.
Input
First line of the input contains an integer T denoting number of test cases.
For each test case, there are two lines.
First line contains a single integer denoting n: number of villages.
Second line contains n space separated integers denoting the array D.
Output
For each test case, print a single line containing the integer corresponding to answer of the problem.
Constraints
1 ≤ T ≤ 10^5
1 ≤ n ≤ 10^5
-10^4 ≤ D[i] ≤ 10^4
Sum of n over all the test cases will be ≤ 10^6
It is guaranteed that sum of D[i] is zero for a single test case which ensures that there are equal number of villagers and dinosaurs.
Example
Input:
3
2
5 -5
2
-5 5
3
1 2 -3
Output:
5
5
4
Explanation
Example case 1. Each villager in village 1, need to walk 1 km to reach to the dinosaur in 2nd village.
Example case 2. Each villager in village 2, need to walk 1 km to reach to the dinosaur 1st village.
Example case 3. Each villager in village 1, need to walk 2 km to reach to the dinosaur in 3rd village whereas Each villager in village 2,
need to walk 1 km to reach to the dinosaur in 3rd village.
|
# Devajit Asem
# PRLADDU
t = int(raw_input())
def display(a):
for i in a:
print i,
print
for i in range(t):
n = int(raw_input())
D = map(int,raw_input().split())
c=0
k=0
for i in xrange(n):
c+=D[i]
k+=abs(c)
print k
|
At the end of a busy day, The Chef and his assistants play a game together. The game is not just for fun but also used to decide who will have to clean the kitchen. The Chef is a Game Master, so his concern is how to manage the game but not how to win the game like his assistants do.
The game requires players to find the only ball under one of the N cups after their positions are changed in a special way. At the beginning of the game, The Chef places N cups in a row and put a ball under the C-th cup from the left (the cups are numbered from 1 to N). All players can see the initial position of the ball. Then Chef performs Q flip operations. Each flip operation is defined by two integers L and R such that 1 ≤ L ≤ R ≤ N and consists in reversing the segment [L, R] of cups. Namely, Chef swaps L-th and R-th cups, (L+1)-th and (R−1)-th cups, and so on. After performing all the operations Chef asks his assistants to choose a cup that they think the ball is under it. Who can guess the position of the ball will win the game, and of course, the others will have to clean the kitchen.
The Chef doesn't want to check all the N cups at the end of the game. He notes down the value of C and the pairs (L, R) and asked you, the mastered programmer, to determine the cup that contains the ball.
Input
The first line of the input contains a single integer T, denoting the number of test cases. The description of T test cases follows. The first line of each test case contains three space-separated integers N, C and Q, denoting the total number of cups, the initial position of the ball and the number of flip operations Chef will perform. Each of the following Q lines contains two space-separated integers L and R, denoting the ends of the segment of the current flip operation.
Output
For each test case output on a separate line the final position of the ball.
Constraints
1 ≤ T ≤ 10
1 ≤ N ≤ 100000 (10^5)
1 ≤ C ≤ N
1 ≤ Q ≤ 10000 (10^4)
1 ≤ L ≤ R ≤ N
Example
Input:
1
5 2 3
1 4
3 5
1 5
Output:
1
Explanation
The row of cups at the beginning of the game and after each flip is shown below. Here '-' means an empty cup and 'B' is the cup that hides the ball, the segment of flip is marked bold.
-B---
--B--
----B
B----
|
n=input()
for x in range(n):
b=raw_input()
c=b.split()
for y in range(len(c)):
c[y]=int(c[y])
pos=c[1]
for y in range(c[2]):
d=raw_input()
e,f=d.split()
e=int(e)
f=int(f)
if(e<=pos and f>=pos):
pos=e+f-pos
print pos
|
Natasha is going to fly on a rocket to Mars and return to Earth. Also, on the way to Mars, she will land on n - 2 intermediate planets. Formally: we number all the planets from 1 to n. 1 is Earth, n is Mars. Natasha will make exactly n flights: 1 → 2 → … n → 1.
Flight from x to y consists of two phases: take-off from planet x and landing to planet y. This way, the overall itinerary of the trip will be: the 1-st planet → take-off from the 1-st planet → landing to the 2-nd planet → 2-nd planet → take-off from the 2-nd planet → … → landing to the n-th planet → the n-th planet → take-off from the n-th planet → landing to the 1-st planet → the 1-st planet.
The mass of the rocket together with all the useful cargo (but without fuel) is m tons. However, Natasha does not know how much fuel to load into the rocket. Unfortunately, fuel can only be loaded on Earth, so if the rocket runs out of fuel on some other planet, Natasha will not be able to return home. Fuel is needed to take-off from each planet and to land to each planet. It is known that 1 ton of fuel can lift off a_i tons of rocket from the i-th planet or to land b_i tons of rocket onto the i-th planet.
For example, if the weight of rocket is 9 tons, weight of fuel is 3 tons and take-off coefficient is 8 (a_i = 8), then 1.5 tons of fuel will be burnt (since 1.5 ⋅ 8 = 9 + 3). The new weight of fuel after take-off will be 1.5 tons.
Please note, that it is allowed to burn non-integral amount of fuel during take-off or landing, and the amount of initial fuel can be non-integral as well.
Help Natasha to calculate the minimum mass of fuel to load into the rocket. Note, that the rocket must spend fuel to carry both useful cargo and the fuel itself. However, it doesn't need to carry the fuel which has already been burnt. Assume, that the rocket takes off and lands instantly.
Input
The first line contains a single integer n (2 ≤ n ≤ 1000) — number of planets.
The second line contains the only integer m (1 ≤ m ≤ 1000) — weight of the payload.
The third line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000), where a_i is the number of tons, which can be lifted off by one ton of fuel.
The fourth line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000), where b_i is the number of tons, which can be landed by one ton of fuel.
It is guaranteed, that if Natasha can make a flight, then it takes no more than 10^9 tons of fuel.
Output
If Natasha can fly to Mars through (n - 2) planets and return to Earth, print the minimum mass of fuel (in tons) that Natasha should take. Otherwise, print a single number -1.
It is guaranteed, that if Natasha can make a flight, then it takes no more than 10^9 tons of fuel.
The answer will be considered correct if its absolute or relative error doesn't exceed 10^{-6}. Formally, let your answer be p, and the jury's answer be q. Your answer is considered correct if \frac{|p - q|}{max{(1, |q|)}} ≤ 10^{-6}.
Examples
Input
2
12
11 8
7 5
Output
10.0000000000
Input
3
1
1 4 1
2 5 3
Output
-1
Input
6
2
4 6 3 3 5 6
2 6 3 6 5 3
Output
85.4800000000
Note
Let's consider the first example.
Initially, the mass of a rocket with fuel is 22 tons.
* At take-off from Earth one ton of fuel can lift off 11 tons of cargo, so to lift off 22 tons you need to burn 2 tons of fuel. Remaining weight of the rocket with fuel is 20 tons.
* During landing on Mars, one ton of fuel can land 5 tons of cargo, so for landing 20 tons you will need to burn 4 tons of fuel. There will be 16 tons of the rocket with fuel remaining.
* While taking off from Mars, one ton of fuel can raise 8 tons of cargo, so to lift off 16 tons you will need to burn 2 tons of fuel. There will be 14 tons of rocket with fuel after that.
* During landing on Earth, one ton of fuel can land 7 tons of cargo, so for landing 14 tons you will need to burn 2 tons of fuel. Remaining weight is 12 tons, that is, a rocket without any fuel.
In the second case, the rocket will not be able even to take off from Earth.
|
#include <bits/stdc++.h>
using namespace std;
int ddx[] = {1, 0};
int ddy[] = {0, 1};
int n, m, peso;
vector<long long int> aa, bb;
vector<double> vec;
double ans = DBL_MAX;
bool can(double atual) {
double a = peso + atual;
bool at = false;
for (int i = 0; i < int(vec.size()); i++) {
a = (a - (a / vec[i]));
}
if (a < peso) return false;
ans = min(ans, atual);
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> peso;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
aa.push_back(a);
}
for (int i = 0; i < n; i++) {
int a;
cin >> a;
bb.push_back(a);
}
bool at = false;
int a = 0, b = 1;
while (1) {
if (!at)
vec.push_back(aa[a++]), at = true;
else if (at)
vec.push_back(bb[b++]), at = false;
if (a == int(aa.size())) {
vec.push_back(bb[0]);
break;
}
}
double com = 0, fim = DBL_MAX;
int it = 0;
while (com < fim) {
double mid = (com + fim) / 2;
if (can(mid))
fim = mid;
else
com = mid;
int aaa = com, bbb = fim;
it++;
if (it == 10000) break;
}
if (ans == DBL_MAX)
printf("-1");
else
printf("%.8lf\n", ans);
return 0;
}
|
Vasya has two arrays A and B of lengths n and m, respectively.
He can perform the following operation arbitrary number of times (possibly zero): he takes some consecutive subsegment of the array and replaces it with a single element, equal to the sum of all elements on this subsegment. For example, from the array [1, 10, 100, 1000, 10000] Vasya can obtain array [1, 1110, 10000], and from array [1, 2, 3] Vasya can obtain array [6].
Two arrays A and B are considered equal if and only if they have the same length and for each valid i A_i = B_i.
Vasya wants to perform some of these operations on array A, some on array B, in such a way that arrays A and B become equal. Moreover, the lengths of the resulting arrays should be maximal possible.
Help Vasya to determine the maximum length of the arrays that he can achieve or output that it is impossible to make arrays A and B equal.
Input
The first line contains a single integer n~(1 ≤ n ≤ 3 ⋅ 10^5) — the length of the first array.
The second line contains n integers a_1, a_2, ⋅⋅⋅, a_n~(1 ≤ a_i ≤ 10^9) — elements of the array A.
The third line contains a single integer m~(1 ≤ m ≤ 3 ⋅ 10^5) — the length of the second array.
The fourth line contains m integers b_1, b_2, ⋅⋅⋅, b_m~(1 ≤ b_i ≤ 10^9) - elements of the array B.
Output
Print a single integer — the maximum length of the resulting arrays after some operations were performed on arrays A and B in such a way that they became equal.
If there is no way to make array equal, print "-1".
Examples
Input
5
11 2 3 5 7
4
11 7 3 7
Output
3
Input
2
1 2
1
100
Output
-1
Input
3
1 2 3
3
1 2 3
Output
3
|
/*
*
* @author Mukesh Singh
*
*/
import java.io.*;
import java.util.*;
import java.text.DecimalFormat;
@SuppressWarnings("unchecked")
public class Main {
//solve test cases
void solve() throws Exception {
//int T = in.nextInt();
//for(int tid = 1; tid <= T; ++tid)
solveT();
}
void solveT() throws Exception{
int n = in.nextInt();
long []A=new long[n];
for(int i=0;i<n;i++){
A[i]=in.nextLong();
}
int m = in.nextInt();
long []B=new long[m];
for(int i=0;i<m;i++){
B[i]=in.nextLong();
}
long a=0,b=0;
int i=0,j=0,p=1,q=1;
int count=0;
while(i<n && j<m){
if(p==1)
a+=A[i];
if(q==1)
b+=B[j];
p=0;
q=0;
if(a==b){
count++;
i++;
j++;
a=0;
b=0;
p=1;
q=1;
}else if(a<b){
i++;
p=1;
}else {
j++;
q=1;
}
}
if(i<n|| j<m)
System.out.println("-1");
else
System.out.println(count);
}
//@ main function
public static void main(String[] args) throws Exception {
new Main();
}
InputReader in;
PrintStream out ;
DecimalFormat df ;
Main() {
try {
File defaultInput = new File("file.in");
if (defaultInput.exists())
in = new InputReader("file.in");
else
in = new InputReader();
defaultInput = new File("file.out");
if (defaultInput.exists())
out = new PrintStream(new FileOutputStream("file.out"));
else
out = new PrintStream(System.out);
df = new DecimalFormat("######0.00");
solve();
out.close();
}
catch (Exception e) {
e.printStackTrace();
System.exit(261);
}
}
class InputReader {
BufferedReader reader;
StringTokenizer tokenizer;
InputReader() {
reader = new BufferedReader(new InputStreamReader(System.in));
}
InputReader(String fileName) throws FileNotFoundException {
reader = new BufferedReader(new FileReader(new File(fileName)));
}
String readLine() throws IOException {
return reader.readLine();
}
String nextToken() throws IOException {
while (tokenizer == null || !tokenizer.hasMoreTokens())
tokenizer = new StringTokenizer(readLine());
return tokenizer.nextToken();
}
boolean hasMoreTokens() throws IOException {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
String s = readLine();
if (s == null)
return false;
tokenizer = new StringTokenizer(s);
}
return true;
}
int nextInt() throws NumberFormatException, IOException {
return Integer.parseInt(nextToken());
}
long nextLong() throws NumberFormatException, IOException {
return Long.parseLong(nextToken());
}
double nextDouble() throws NumberFormatException, IOException {
return Double.parseDouble(nextToken());
}
}
}
|
Let's call the following process a transformation of a sequence of length n.
If the sequence is empty, the process ends. Otherwise, append the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) (GCD) of all the elements of the sequence to the result and remove one arbitrary element from the sequence. Thus, when the process ends, we have a sequence of n integers: the greatest common divisors of all the elements in the sequence before each deletion.
You are given an integer sequence 1, 2, ..., n. Find the lexicographically maximum result of its transformation.
A sequence a_1, a_2, …, a_n is lexicographically larger than a sequence b_1, b_2, …, b_n, if there is an index i such that a_j = b_j for all j < i, and a_i > b_i.
Input
The first and only line of input contains one integer n (1≤ n≤ 10^6).
Output
Output n integers — the lexicographically maximum result of the transformation.
Examples
Input
3
Output
1 1 3
Input
2
Output
1 2
Input
1
Output
1
Note
In the first sample the answer may be achieved this way:
* Append GCD(1, 2, 3) = 1, remove 2.
* Append GCD(1, 3) = 1, remove 1.
* Append GCD(3) = 3, remove 3.
We get the sequence [1, 1, 3] as the result.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, cnt = 0;
scanf("%d", &n);
if (n == 3)
printf("1 1 3");
else {
int x = n;
for (i = 1; x > 3; i <<= 1) {
int y = x - x / 2;
x /= 2;
for (j = 1; j <= y; ++j) printf("%d ", i), cnt++;
}
if (x == 3) printf("%d %d %d", i, i, i * 3);
if (x == 2) printf("%d %d", i, i * 2);
if (x == 1) printf("%d", i);
}
}
|
Sonya had a birthday recently. She was presented with the matrix of size n× m and consist of lowercase Latin letters. We assume that the rows are numbered by integers from 1 to n from bottom to top, and the columns are numbered from 1 to m from left to right.
Let's call a submatrix (i_1, j_1, i_2, j_2) (1≤ i_1≤ i_2≤ n; 1≤ j_1≤ j_2≤ m) elements a_{ij} of this matrix, such that i_1≤ i≤ i_2 and j_1≤ j≤ j_2. Sonya states that a submatrix is beautiful if we can independently reorder the characters in each row (not in column) so that all rows and columns of this submatrix form palidroms.
Let's recall that a string is called palindrome if it reads the same from left to right and from right to left. For example, strings abacaba, bcaacb, a are palindromes while strings abca, acbba, ab are not.
Help Sonya to find the number of beautiful submatrixes. Submatrixes are different if there is an element that belongs to only one submatrix.
Input
The first line contains two integers n and m (1≤ n, m≤ 250) — the matrix dimensions.
Each of the next n lines contains m lowercase Latin letters.
Output
Print one integer — the number of beautiful submatrixes.
Examples
Input
1 3
aba
Output
4
Input
2 3
aca
aac
Output
11
Input
3 5
accac
aaaba
cccaa
Output
43
Note
In the first example, the following submatrixes are beautiful: ((1, 1), (1, 1)); ((1, 2), (1, 2)); ((1, 3), (1, 3)); ((1, 1), (1, 3)).
In the second example, all submatrixes that consist of one element and the following are beautiful: ((1, 1), (2, 1)); ((1, 1), (1, 3)); ((2, 1), (2, 3)); ((1, 1), (2, 3)); ((2, 1), (2, 2)).
Some of the beautiful submatrixes are: ((1, 1), (1, 5)); ((1, 2), (3, 4)); ((1, 1), (3, 5)).
The submatrix ((1, 1), (3, 5)) is beautiful since it can be reordered as:
accca
aabaa
accca
In such a matrix every row and every column form palindromes.
|
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + ch - 48;
ch = getchar();
}
return x * f;
}
template <typename T>
inline bool Max(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool Min(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
const int N = 254;
const unsigned long long mod = 1e13 + 7;
int n, m;
int cnt[27], g[N][N][N];
long long ans;
char s[N];
unsigned long long v[N][N], f[N][N][N], pre[N], suf[N], val[N], sg[N], bin[N];
int idx(char c) { return c - 'a'; }
unsigned long long Rand() {
static unsigned long long seed = 703;
return seed = seed * 48271 % mod;
}
unsigned long long v1(int l, int r) {
if (l > r) return 0;
return pre[r] - pre[l - 1] * bin[r - l + 1];
}
unsigned long long v2(int l, int r) {
if (l > r) return 0;
return suf[l] - suf[r + 1] * bin[r - l + 1];
}
int main() {
n = gi(), m = gi();
for (int i = 0; i <= 25; ++i) val[i] = Rand();
bin[0] = 1;
for (int i = 1; i <= 250; ++i) bin[i] = bin[i - 1] * 233;
for (int i = 1; i <= n; ++i) {
scanf("%s", s + 1);
for (int j = 1; j <= m; ++j) v[i][j] = idx(s[j]);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
memset(cnt, 0, sizeof cnt);
int c1 = 0;
unsigned long long hv = 0;
for (int k = j; k <= m; ++k) {
if (++cnt[v[i][k]] & 1)
++c1;
else
--c1;
hv = hv ^ ((cnt[v[i][k]] - 1) * val[v[i][k]]) ^
(cnt[v[i][k]] * val[v[i][k]]);
f[i][j][k] = hv;
if (k - j + 1 & 1) {
if (c1 == 1) g[i][j][k] = 1;
} else if (c1 == 0)
g[i][j][k] = 1;
}
}
for (int j = 1; j <= m; ++j)
for (int k = j; k <= m; ++k) {
for (int i = 1; i <= n; ++i)
sg[i] = sg[i - 1] + g[i][j][k], pre[i] = pre[i - 1] * 233 + f[i][j][k];
for (int i = n; i; --i) suf[i] = suf[i + 1] * 233 + f[i][j][k];
for (int i = 1; i <= n; ++i)
if (g[i][j][k]) {
int l = 0, r = min(i - 1, n - i);
while (l < r) {
int mid = l + r + 1 >> 1;
if (v1(i - mid, i - 1) == v2(i + 1, i + mid) &&
sg[i - 1] - sg[i - mid - 1] == mid &&
sg[i + mid] - sg[i] == mid)
l = mid;
else
r = mid - 1;
}
ans += l + 1;
if (i == n || f[i][j][k] != f[i + 1][j][k] || !g[i + 1][j][k])
continue;
l = 0, r = min(i - 1, n - i - 1);
while (l < r) {
int mid = l + r + 1 >> 1;
if (v1(i - mid, i - 1) == v2(i + 2, i + mid + 1) &&
sg[i - 1] - sg[i - mid - 1] == mid &&
sg[i + mid + 1] - sg[i + 1] == mid)
l = mid;
else
r = mid - 1;
}
ans += l + 1;
}
}
printf("%I64d\n", ans);
return 0;
}
|
This problem differs from one which was on the online contest.
The sequence a1, a2, ..., an is called increasing, if ai < ai + 1 for i < n.
The sequence s1, s2, ..., sk is called the subsequence of the sequence a1, a2, ..., an, if there exist such a set of indexes 1 ≤ i1 < i2 < ... < ik ≤ n that aij = sj. In other words, the sequence s can be derived from the sequence a by crossing out some elements.
You are given two sequences of integer numbers. You are to find their longest common increasing subsequence, i.e. an increasing sequence of maximum length that is the subsequence of both sequences.
Input
The first line contains an integer n (1 ≤ n ≤ 500) — the length of the first sequence. The second line contains n space-separated integers from the range [0, 109] — elements of the first sequence. The third line contains an integer m (1 ≤ m ≤ 500) — the length of the second sequence. The fourth line contains m space-separated integers from the range [0, 109] — elements of the second sequence.
Output
In the first line output k — the length of the longest common increasing subsequence. In the second line output the subsequence itself. Separate the elements with a space. If there are several solutions, output any.
Examples
Input
7
2 3 1 6 5 4 6
4
1 3 5 6
Output
3
3 5 6
Input
5
1 2 0 2 1
3
1 0 1
Output
2
0 1
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d", &n);
int a[n + 10];
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
scanf("%d", &m);
int b[m + 10];
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
int local, ans = 0, indx;
int Max[m + 10];
memset(Max, 0, sizeof Max);
vector<int> path[505];
for (int i = 1; i <= n; i++) {
local = 0;
for (int j = 1; j <= m; j++) {
if (a[i] == b[j]) {
Max[j] = max(Max[j], local + 1);
if (local + 1 > ans) {
indx = j;
ans = local + 1;
}
path[Max[j]].push_back(j);
} else if (a[i] > b[j])
local = max(Max[j], local);
}
}
cout << ans << endl;
int val = 1000000001;
vector<int> Ans;
int in = 50001;
while (ans) {
for (int i = 0; i < path[ans].size(); i++) {
if (val > b[path[ans][i]] && in > path[ans][i]) {
Ans.push_back(b[path[ans][i]]);
val = b[path[ans][i]];
in = path[ans][i];
ans--;
break;
}
}
}
reverse(Ans.begin(), Ans.end());
for (int i = 0; i < Ans.size(); i++) cout << Ans[i] << " ";
cout << endl;
return 0;
}
|
Vasya likes taking part in Codeforces contests. When a round is over, Vasya follows all submissions in the system testing tab.
There are n solutions, the i-th of them should be tested on a_i tests, testing one solution on one test takes 1 second. The solutions are judged in the order from 1 to n. There are k testing processes which test solutions simultaneously. Each of them can test at most one solution at a time.
At any time moment t when some testing process is not judging any solution, it takes the first solution from the queue and tests it on each test in increasing order of the test ids. Let this solution have id i, then it is being tested on the first test from time moment t till time moment t + 1, then on the second test till time moment t + 2 and so on. This solution is fully tested at time moment t + a_i, and after that the testing process immediately starts testing another solution.
Consider some time moment, let there be exactly m fully tested solutions by this moment. There is a caption "System testing: d%" on the page with solutions, where d is calculated as
$$$d = round\left(100⋅m/n\right),$$$
where round(x) = ⌊{x + 0.5}⌋ is a function which maps every real to the nearest integer.
Vasya calls a submission interesting if there is a time moment (possibly, non-integer) when the solution is being tested on some test q, and the caption says "System testing: q%". Find the number of interesting solutions.
Please note that in case when multiple processes attempt to take the first submission from the queue at the same moment (for instance, at the initial moment), the order they take the solutions does not matter.
Input
The first line contains two positive integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 100) standing for the number of submissions and the number of testing processes respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 150), where a_i is equal to the number of tests the i-th submission is to be run on.
Output
Output the only integer — the number of interesting submissions.
Examples
Input
2 2
49 100
Output
1
Input
4 2
32 100 33 1
Output
2
Input
14 5
48 19 6 9 50 20 3 42 38 43 36 21 44 6
Output
5
Note
Consider the first example. At time moment 0 both solutions start testing. At time moment 49 the first solution is fully tested, so at time moment 49.5 the second solution is being tested on the test 50, and the caption says "System testing: 50%" (because there is one fully tested solution out of two). So, the second solution is interesting.
Consider the second example. At time moment 0 the first and the second solutions start testing. At time moment 32 the first solution is fully tested, the third solution starts testing, the caption says "System testing: 25%". At time moment 32 + 24.5 = 56.5 the third solutions is being tested on test 25, the caption is still the same, thus this solution is interesting. After that the third solution is fully tested at time moment 32 + 33 = 65, the fourth solution is fully tested at time moment 65 + 1 = 66. The captions becomes "System testing: 75%", and at time moment 74.5 the second solution is being tested on test 75. So, this solution is also interesting. Overall, there are two interesting solutions.
|
#include <bits/stdc++.h>
using namespace std;
int arr[1010];
bool interest[1010];
int main() {
int n, i, j, k, x, y, ans, curr, temp, m, rose = 0;
scanf("%d %d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
}
double systest = 0.00;
int cek = round(systest);
pair<int, int> p[m + 5];
for (i = 1; i <= m; i++) {
p[i] = make_pair(i, 0);
}
int next = m + 1;
int done = 0;
while (1) {
temp = 0;
for (i = 1; i <= m; i++) {
if (p[i].first > n) {
temp++;
continue;
}
if (p[i].second == arr[p[i].first]) {
p[i].first = next;
p[i].second = 0;
done++;
systest = (100 * (double)done / (double)n);
cek = round(systest);
next++;
}
p[i].second++;
}
for (i = 1; i <= m; i++) {
if (p[i].first > n) continue;
if (p[i].second == cek) interest[p[i].first] = 1;
}
if (temp == m) break;
}
for (i = 1; i <= n; i++) {
rose += (interest[i] == 1);
}
printf("%d\n", rose);
return 0;
}
|
There are n stones arranged on an axis. Initially the i-th stone is located at the coordinate s_i. There may be more than one stone in a single place.
You can perform zero or more operations of the following type:
* take two stones with indices i and j so that s_i ≤ s_j, choose an integer d (0 ≤ 2 ⋅ d ≤ s_j - s_i), and replace the coordinate s_i with (s_i + d) and replace coordinate s_j with (s_j - d). In other words, draw stones closer to each other.
You want to move the stones so that they are located at positions t_1, t_2, …, t_n. The order of the stones is not important — you just want for the multiset of the stones resulting positions to be the same as the multiset of t_1, t_2, …, t_n.
Detect whether it is possible to move the stones this way, and if yes, construct a way to do so. You don't need to minimize the number of moves.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) – the number of stones.
The second line contains integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 10^9) — the initial positions of the stones.
The second line contains integers t_1, t_2, …, t_n (1 ≤ t_i ≤ 10^9) — the target positions of the stones.
Output
If it is impossible to move the stones this way, print "NO".
Otherwise, on the first line print "YES", on the second line print the number of operations m (0 ≤ m ≤ 5 ⋅ n) required. You don't have to minimize the number of operations.
Then print m lines, each containing integers i, j, d (1 ≤ i, j ≤ n, s_i ≤ s_j, 0 ≤ 2 ⋅ d ≤ s_j - s_i), defining the operations.
One can show that if an answer exists, there is an answer requiring no more than 5 ⋅ n operations.
Examples
Input
5
2 2 7 4 9
5 4 5 5 5
Output
YES
4
4 3 1
2 3 1
2 5 2
1 5 2
Input
3
1 5 10
3 5 7
Output
NO
Note
Consider the first example.
* After the first move the locations of stones is [2, 2, 6, 5, 9].
* After the second move the locations of stones is [2, 3, 5, 5, 9].
* After the third move the locations of stones is [2, 5, 5, 5, 7].
* After the last move the locations of stones is [4, 5, 5, 5, 5].
|
#include <bits/stdc++.h>
using namespace std;
int m, n, k;
long long t[300001];
pair<long long, int> s[300001];
vector<pair<int, long long> > st;
vector<pair<pair<int, int>, long long> > ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s[i].first;
s[i].second = i;
}
for (int i = 1; i <= n; i++) cin >> t[i];
sort(t + 1, t + n + 1);
sort(s + 1, s + n + 1);
long long sum = 0;
for (int i = 1; i <= n; i++)
if (t[i] != s[i].first) {
if (t[i] > s[i].first) {
st.push_back({s[i].second, t[i] - s[i].first});
sum += t[i] - s[i].first;
} else {
if (s[i].first - t[i] > sum) {
cout << "NO";
return 0;
}
while (!st.empty()) {
long long mn = min(st.back().second, s[i].first - t[i]);
ans.push_back({{st.back().first, s[i].second}, mn});
st.back().second -= mn;
s[i].first -= mn;
sum -= mn;
if (st.back().second == 0)
st.pop_back();
else
break;
}
}
}
if (!st.empty()) {
cout << "NO";
return 0;
}
cout << "YES\n";
cout << ans.size() << '\n';
for (auto x : ans) {
cout << x.first.first << ' ' << x.first.second << ' ' << x.second << '\n';
}
return 0;
}
|
Once upon a time there were several little pigs and several wolves on a two-dimensional grid of size n × m. Each cell in this grid was either empty, containing one little pig, or containing one wolf.
A little pig and a wolf are adjacent if the cells that they are located at share a side. The little pigs are afraid of wolves, so there will be at most one wolf adjacent to each little pig. But each wolf may be adjacent to any number of little pigs.
They have been living peacefully for several years. But today the wolves got hungry. One by one, each wolf will choose one of the little pigs adjacent to it (if any), and eats the poor little pig. This process is not repeated. That is, each wolf will get to eat at most one little pig. Once a little pig gets eaten, it disappears and cannot be eaten by any other wolf.
What is the maximum number of little pigs that may be eaten by the wolves?
Input
The first line contains integers n and m (1 ≤ n, m ≤ 10) which denotes the number of rows and columns in our two-dimensional grid, respectively. Then follow n lines containing m characters each — that is the grid description. "." means that this cell is empty. "P" means that this cell contains a little pig. "W" means that this cell contains a wolf.
It is guaranteed that there will be at most one wolf adjacent to any little pig.
Output
Print a single number — the maximal number of little pigs that may be eaten by the wolves.
Examples
Input
2 3
PPW
W.P
Output
2
Input
3 3
P.W
.P.
W.P
Output
0
Note
In the first example, one possible scenario in which two little pigs get eaten by the wolves is as follows.
<image>
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class PigWolf implements Runnable {
int n;
int m;
private void solve() throws IOException {
n = nextInt();
m = nextInt();
char[][] a = new char[15][15];
for (int i = 0; i <= n - 1; i++){
String input = nextToken();
for (int j = 0; j <= m - 1; j++){
a[i][j] = input.charAt(j);
// writer.println(a[i][j]);
}
}
int res = 0;
final int[] dx = {0, 0, -1, 1};
final int[] dy = {1, -1, 0, 0};
for (int i = 0; i <= n - 1; i++)
for (int j = 0; j <= m - 1; j++)
if (a[i][j] == 'W'){
for (int t = 0; t <= 3; t++){
int x = i + dx[t];
int y = j + dy[t];
if (Inboard(x, y) && a[x][y] == 'P'){
res++;
break;
}
}
}
writer.println(res);
}
boolean Inboard(int x, int y){
return (0 <= x && x <= n - 1 && 0 <= y && y <= m - 1);
}
public static void main(String[] args) {
new PigWolf().run();
}
BufferedReader reader;
StringTokenizer tokenizer;
PrintWriter writer;
public void run() {
try {
reader = new BufferedReader(new InputStreamReader(System.in));
tokenizer = null;
writer = new PrintWriter(System.out);
solve();
reader.close();
writer.close();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
String nextToken() throws IOException {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
}
|
Note that this is the second problem of the two similar problems. You can hack this problem if you solve it. But you can hack the previous problem only if you solve both problems.
You are given a tree with n nodes. In the beginning, 0 is written on all edges. In one operation, you can choose any 2 distinct leaves u, v and any integer number x and add x to values written on all edges on the simple path between u and v. Note that in previous subtask x was allowed to be any real, here it has to be integer.
For example, on the picture below you can see the result of applying two operations to the graph: adding 2 on the path from 7 to 6, and then adding -1 on the path from 4 to 5.
<image>
You are given some configuration of nonnegative integer pairwise different even numbers, written on the edges. For a given configuration determine if it is possible to achieve it with these operations, and, if it is possible, output the sequence of operations that leads to the given configuration. Constraints on the operations are listed in the output format section.
Leave is a node of a tree of degree 1. Simple path is a path that doesn't contain any node twice.
Input
The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of nodes in a tree.
Each of the next n-1 lines contains three integers u, v, val (1 ≤ u, v ≤ n, u ≠ v, 0 ≤ val ≤ 10 000), meaning that there is an edge between nodes u and v with val written on it. It is guaranteed that these edges form a tree. It is guaranteed that all val numbers are pairwise different and even.
Output
If there aren't any sequences of operations which lead to the given configuration, output "NO".
If it exists, output "YES" in the first line. In the second line output m — number of operations you are going to apply (0 ≤ m ≤ 10^5). Note that you don't have to minimize the number of the operations!
In the next m lines output the operations in the following format:
u, v, x (1 ≤ u, v ≤ n, u not = v, x — integer, -10^9 ≤ x ≤ 10^9), where u, v — leaves, x — number we are adding.
It is guaranteed that if there exists a sequence of operations producing given configuration, then there exists a sequence of operations producing given configuration, satisfying all the conditions above.
Examples
Input
5
1 2 2
2 3 4
3 4 10
3 5 18
Output
NO
Input
6
1 2 6
1 3 8
1 4 12
2 5 2
2 6 4
Output
YES
4
3 6 1
4 6 3
3 4 7
4 5 2
Note
The configuration from the first sample is drawn below, and it is impossible to achieve.
<image>
The sequence of operations from the second sample is illustrated below.
<image>
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const long double PI = 3.14159265358979323846;
const long double eps = 1e-5;
const int INF = numeric_limits<int>::max();
const long long LINF = numeric_limits<long long>::max();
const long long mod = 1000 * 1000 * 1000 + 7;
vector<vector<pair<long long, long long> > > g;
vector<int> leave;
void dfs(int pos, int pr = -1) {
int to = -1;
for (int i = 0; i < g[pos].size(); ++i) {
if (g[pos][i].first == pr) continue;
to = g[pos][i].first;
break;
}
if (to == -1) {
leave[pos] = pos;
return;
}
int tot = to;
for (int i = 0; i < g[pos].size(); ++i) {
if (g[pos][i].first == pr) continue;
to = g[pos][i].first;
dfs(to, pos);
}
leave[pos] = leave[tot];
}
vector<pair<int, int> > res1;
vector<long long> res2;
void dfs2(int pos, long long add, int leaf, int pr = -1) {
vector<int> l;
vector<long long> c;
for (int i = 0; i < g[pos].size(); ++i) {
int to = g[pos][i].first;
if (to == pr) continue;
l.push_back(to);
c.push_back(g[pos][i].second);
}
if (c.empty()) return;
c[0] -= add;
if (c.size() == 2) {
long long x = (c[0] - c[1]) / 2;
res1.push_back(pair<int, int>(leave[l[0]], leaf));
res2.push_back(x);
res1.push_back(pair<int, int>(leave[l[1]], leaf));
res2.push_back(-x);
long long y = c[0] - x;
res1.push_back(pair<int, int>(leave[l[0]], leave[l[1]]));
res2.push_back(y);
} else {
long long c0 = c[0];
for (int i = 3; i < l.size(); ++i) {
res1.push_back(pair<int, int>(leave[l[0]], leave[l[i]]));
res2.push_back(c[i]);
c0 -= c[i];
}
long long d0 = (c0 + c[1] - c[2]) / 2;
res1.push_back(pair<int, int>(leave[l[0]], leave[l[1]]));
res2.push_back(d0);
long long d1 = (c0 + c[2] - c[1]) / 2;
res1.push_back(pair<int, int>(leave[l[0]], leave[l[2]]));
res2.push_back(d1);
long long d2 = (c[1] + c[2] - c0) / 2;
res1.push_back(pair<int, int>(leave[l[1]], leave[l[2]]));
res2.push_back(d2);
}
dfs2(l[0], c[0] + add, leave[l[1]], pos);
for (int i = 1; i < l.size(); ++i) {
dfs2(l[i], c[i], leave[l[0]], pos);
}
}
void solve() {
int n;
cin >> n;
vector<int> d(n, 0);
g.resize(n);
long long a, b, c;
for (int i = 0; i < n - 1; ++i) {
cin >> a >> b >> c;
--a, --b;
++d[a];
++d[b];
g[a].push_back(pair<int, int>(b, c));
g[b].push_back(pair<int, int>(a, c));
}
for (int i = 0; i < n; ++i) {
if (d[i] == 2) {
cout << "NO\n";
return;
}
}
if (n == 2) {
cout << "YES\n";
cout << 1 << endl;
cout << 1 << " " << 2 << " " << g[0][0].second << endl;
return;
}
int st = 0;
while (d[st] == 1) ++st;
leave.resize(n);
dfs(st, -1);
dfs2(st, 0, -1, -1);
cout << "YES\n";
cout << res1.size() << endl;
for (int i = 0; i < res1.size(); ++i) {
cout << res1[i].first + 1 << " " << res1[i].second + 1 << " " << res2[i]
<< "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
solve();
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.