input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
Some large corporation where Polycarpus works has its own short message service center (SMSC). The center's task is to send all sorts of crucial information. Polycarpus decided to check the efficiency of the SMSC.
For that, he asked to give him the statistics of the performance of the SMSC for some period of time. In the end, Polycarpus got a list of n tasks that went to the SMSC of the corporation. Each task was described by the time it was received by the SMSC and the number of text messages to send. More formally, the i-th task was described by two integers ti and ci β the receiving time (the second) and the number of the text messages, correspondingly.
Polycarpus knows that the SMSC cannot send more than one text message per second. The SMSC uses a queue to organize its work. Consider a time moment x, the SMSC work at that moment as follows:
1. If at the time moment x the queue is not empty, then SMSC sends one message from the queue (SMSC gets the message from the head of the queue). Otherwise it doesn't send messages at the time moment x.
2. If at the time moment x SMSC receives a task, then it adds to the queue all the messages from this task (SMSC adds messages to the tail of the queue). Note, that the messages from the task cannot be send at time moment x. That's because the decision about sending message or not is made at point 1 before adding these messages to the queue.
Given the information about all n tasks, Polycarpus wants to count two values: the time when the last text message was sent and the maximum size of the queue at some time. Help him count these two characteristics he needs to evaluate the efficiency of the SMSC.
Input
The first line contains a single integer n (1 β€ n β€ 103) β the number of tasks of the SMSC. Next n lines contain the tasks' descriptions: the i-th line contains two space-separated integers ti and ci (1 β€ ti, ci β€ 106) β the time (the second) when the i-th task was received and the number of messages to send, correspondingly.
It is guaranteed that all tasks were received at different moments of time. It is guaranteed that the tasks are sorted in the chronological order, that is, ti < ti + 1 for all integer i (1 β€ i < n).
Output
In a single line print two space-separated integers β the time when the last text message was sent and the maximum queue size at a certain moment of time.
Examples
Input
2
1 1
2 1
Output
3 1
Input
1
1000000 10
Output
1000010 10
Input
3
3 3
4 3
5 3
Output
12 7
Note
In the first test sample:
* second 1: the first message has appeared in the queue, the queue's size is 1;
* second 2: the first message is sent, the second message has been received, the queue's size is 1;
* second 3: the second message is sent, the queue's size is 0,
Thus, the maximum size of the queue is 1, the last message was sent at the second 3.
|
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class SMSC {
static int n;
public static void main(String[] args){
FastScanner sc = new FastScanner();
n = sc.nextInt();
long time = 0;
long size = 0;
long largestSize = 0;
int[] remain = new int[n+1];
int[] jobsArrive = new int[n+1];
int[] jobsLength = new int[n+1];
for(int i=0;i<n;i++){
jobsArrive[i] = sc.nextInt();
jobsLength[i] = sc.nextInt();
}
jobsArrive[n] = Integer.MAX_VALUE;
time = jobsArrive[0];
remain[0] = jobsLength[0];
size = jobsLength[0];
largestSize = size;
int lastTask = 0;
int curTask = 0;
while(curTask != n){
largestSize = Math.max(size, largestSize);
long consumption = Math.min(remain[curTask], jobsArrive[lastTask+1]-time);
size -= consumption;
time += consumption;
remain[curTask] -= consumption;
if(remain[curTask] == 0){
curTask++;
}
if(curTask != n && (curTask > lastTask || jobsArrive[lastTask+1] == time)){
//get new job
lastTask++;
remain[lastTask] = jobsLength[lastTask];
size += jobsLength[lastTask];
time = jobsArrive[lastTask];
}
}
System.out.println(time + " " + largestSize);
}
public static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner(String s) {
try {
br = new BufferedReader(new FileReader(s));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public FastScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String nextToken() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(nextToken());
}
long nextLong() {
return Long.parseLong(nextToken());
}
double nextDouble() {
return Double.parseDouble(nextToken());
}
}
}
|
By the age of three Smart Beaver mastered all arithmetic operations and got this summer homework from the amazed teacher:
You are given a sequence of integers a1, a2, ..., an. Your task is to perform on it m consecutive operations of the following type:
1. For given numbers xi and vi assign value vi to element axi.
2. For given numbers li and ri you've got to calculate sum <image>, where f0 = f1 = 1 and at i β₯ 2: fi = fi - 1 + fi - 2.
3. For a group of three numbers li ri di you should increase value ax by di for all x (li β€ x β€ ri).
Smart Beaver planned a tour around great Canadian lakes, so he asked you to help him solve the given problem.
Input
The first line contains two integers n and m (1 β€ n, m β€ 2Β·105) β the number of integers in the sequence and the number of operations, correspondingly. The second line contains n integers a1, a2, ..., an (0 β€ ai β€ 105). Then follow m lines, each describes an operation. Each line starts with an integer ti (1 β€ ti β€ 3) β the operation type:
* if ti = 1, then next follow two integers xi vi (1 β€ xi β€ n, 0 β€ vi β€ 105);
* if ti = 2, then next follow two integers li ri (1 β€ li β€ ri β€ n);
* if ti = 3, then next follow three integers li ri di (1 β€ li β€ ri β€ n, 0 β€ di β€ 105).
The input limits for scoring 30 points are (subproblem E1):
* It is guaranteed that n does not exceed 100, m does not exceed 10000 and there will be no queries of the 3-rd type.
The input limits for scoring 70 points are (subproblems E1+E2):
* It is guaranteed that there will be queries of the 1-st and 2-nd type only.
The input limits for scoring 100 points are (subproblems E1+E2+E3):
* No extra limitations.
Output
For each query print the calculated sum modulo 1000000000 (109).
Examples
Input
5 5
1 3 1 2 4
2 1 4
2 1 5
2 2 4
1 3 10
2 1 5
Output
12
32
8
50
Input
5 4
1 3 1 2 4
3 1 4 1
2 2 4
1 2 10
2 1 5
Output
12
45
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 200005;
const long long mod = 1000000000;
struct matrix {
long long r, c, m[2][2];
long long *operator[](long long b) { return m[b]; }
matrix operator*(matrix b) {
matrix ret;
ret.r = r, ret.c = b.c;
memset(ret.m, 0, sizeof ret.m);
for (long long i = 0; i < r; ++i)
for (long long j = 0; j < c; ++j)
for (long long k = 0; k < b.c; ++k)
(ret[i][k] += m[i][j] * b[j][k]) %= mod;
return ret;
}
void unit() { m[0][0] = m[1][1] = 1, m[0][1] = m[1][0] = 0; }
};
long long fib[maxn], pfib[maxn], flag[maxn << 2], sum0[maxn << 2],
sum1[maxn << 2], n, m, a[maxn];
matrix mat[maxn];
bool vis[maxn];
pair<long long, long long> Fib(long long f0, long long f1, long long n) {
if (!n) return make_pair(f0, f1);
if (n == 1) return make_pair(f1, (f0 + f1) % mod);
matrix A, B;
B.r = 2, B.c = 1;
B[0][0] = f0;
B[1][0] = f1;
if (!vis[n]) {
long long m = n;
mat[m].r = mat[m].c = 2;
mat[m].unit();
A.r = A.c = 2;
vis[n] = true;
A[0][1] = A[1][0] = A[1][1] = 1;
A[0][0] = 0;
for (--n; n; n >>= 1) {
if (n & 1) B = A * B, mat[m] = A * mat[m];
A = A * A;
}
} else
B = mat[n] * B;
return make_pair(B[1][0], (B[0][0] + B[1][0]) % mod);
}
void add_value(long long o, long long l, long long r, long long v) {
(flag[o] += v) %= mod;
(sum0[o] += (v * pfib[r - l - 1] % mod)) %= mod;
(sum1[o] += (v * pfib[r - l])) %= mod;
}
void pushdown(long long o, long long l, long long r) {
if (flag[o]) {
add_value((o << 1), l, ((l + r) >> 1), flag[o]);
add_value((o << 1 | 1), ((l + r) >> 1) + 1, r, flag[o]);
flag[o] = 0;
}
}
void maintain(long long o, long long l, long long r) {
pair<long long, long long> newv =
Fib(sum0[(o << 1 | 1)], sum1[(o << 1 | 1)], ((l + r) >> 1) - l + 1);
sum0[o] = (sum0[(o << 1)] + newv.first) % mod;
sum1[o] = (sum1[(o << 1)] + newv.second) % mod;
}
void update(long long o, long long l, long long r, long long p, long long v) {
if (l == r)
sum0[o] = 0, sum1[o] = v;
else {
pushdown(o, l, r);
if (p <= ((l + r) >> 1))
update((o << 1), l, ((l + r) >> 1), p, v);
else
update((o << 1 | 1), ((l + r) >> 1) + 1, r, p, v);
maintain(o, l, r);
}
}
void update(long long o, long long l, long long r, long long ql, long long qr,
long long addv) {
if (ql <= l && r <= qr)
add_value(o, l, r, addv);
else {
pushdown(o, l, r);
if (ql <= ((l + r) >> 1)) update((o << 1), l, ((l + r) >> 1), ql, qr, addv);
if (((l + r) >> 1) < qr)
update((o << 1 | 1), ((l + r) >> 1) + 1, r, ql, qr, addv);
maintain(o, l, r);
}
}
pair<long long, long long> query(long long o, long long l, long long r,
long long ql, long long qr) {
if (ql <= l && r <= qr)
return make_pair(sum0[o], sum1[o]);
else {
pushdown(o, l, r);
pair<long long, long long> L(0, 0), R(0, 0);
if (ql <= ((l + r) >> 1)) L = query((o << 1), l, ((l + r) >> 1), ql, qr);
if (((l + r) >> 1) < qr)
R = query((o << 1 | 1), ((l + r) >> 1) + 1, r, ql, qr);
long long llen = max(((l + r) >> 1) - max(ql, l) + 1, 0ll);
pair<long long, long long> newv = Fib(R.first, R.second, llen);
return make_pair((L.first + newv.first) % mod,
(L.second + newv.second) % mod);
}
}
void build(long long o, long long l, long long r) {
if (l == r)
sum0[o] = 0, sum1[o] = a[l];
else {
build((o << 1), l, ((l + r) >> 1));
build((o << 1 | 1), ((l + r) >> 1) + 1, r);
maintain(o, l, r);
}
}
long long read() {
long long ret = 0, ch = getchar();
for (; !isdigit(ch); ch = getchar())
;
for (; isdigit(ch); (ret *= 10) += ch - '0', ch = getchar())
;
return ret;
}
int main() {
fib[0] = pfib[0] = fib[1] = 1, pfib[1] = 2, vis[0] = vis[1] = false;
for (long long i = 2; i < maxn; ++i)
fib[i] = (fib[i - 1] + fib[i - 2]) % mod,
pfib[i] = (pfib[i - 1] + fib[i]) % mod, vis[i] = false;
n = read(), m = read();
for (long long i = 1; i <= n; ++i) a[i] = read();
build(1, 1, n);
while (m--) {
long long t, x, y;
t = read(), x = read(), y = read();
if (t == 1)
update(1, 1, n, x, y);
else if (t == 2)
printf("%I64d\n", query(1, 1, n, x, y).second);
else
update(1, 1, n, x, y, read());
}
return 0;
}
|
Berland is facing dark times again. The army of evil lord Van de Mart is going to conquer the whole kingdom. To the council of war called by the Berland's king Valery the Severe came n knights. After long discussions it became clear that the kingdom has exactly n control points (if the enemy conquers at least one of these points, the war is lost) and each knight will occupy one of these points.
Berland is divided into m + 1 regions with m fences, and the only way to get from one region to another is to climb over the fence. Each fence is a circle on a plane, no two fences have common points, and no control point is on the fence. You are given k pairs of numbers ai, bi. For each pair you have to find out: how many fences a knight from control point with index ai has to climb over to reach control point bi (in case when Van de Mart attacks control point bi first). As each knight rides a horse (it is very difficult to throw a horse over a fence), you are to find out for each pair the minimum amount of fences to climb over.
Input
The first input line contains three integers n, m, k (1 β€ n, m β€ 1000, 0 β€ k β€ 100000). Then follow n lines, each containing two integers Kxi, Kyi ( - 109 β€ Kxi, Kyi β€ 109) β coordinates of control point with index i. Control points can coincide.
Each of the following m lines describes fence with index i with three integers ri, Cxi, Cyi (1 β€ ri β€ 109, - 109 β€ Cxi, Cyi β€ 109) β radius and center of the circle where the corresponding fence is situated.
Then follow k pairs of integers ai, bi (1 β€ ai, bi β€ n), each in a separate line β requests that you have to answer. ai and bi can coincide.
Output
Output exactly k lines, each containing one integer β the answer to the corresponding request.
Examples
Input
2 1 1
0 0
3 3
2 0 0
1 2
Output
1
Input
2 3 1
0 0
4 4
1 0 0
2 0 0
3 0 0
1 2
Output
3
|
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
int X[] = {0, 0, 1, 0, 0, -1};
int Y[] = {0, 1, 0, 0, -1, 0};
int Z[] = {1, 0, 0, -1, 0, 0};
struct node {
long long x, y;
node() {}
node(long long x, long long y) : x(x), y(y) {}
bool operator<(const node& p) const { return x < p.x; }
};
node a[100005];
bool vis[1004][1005];
int main() {
long long i, j, k, l, x, y, z, t, m, n;
scanf("%lld %lld", &n, &m);
scanf("%lld", &k);
memset(vis, 0, sizeof(vis));
for (i = 1; i <= n; i++) scanf("%lld %lld", &a[i].x, &a[i].y);
for (i = 1; i <= m; i++) {
scanf("%lld %lld %lld", &x, &y, &z);
for (j = 1; j <= n; j++) {
t = (((a[j].x - y)) * ((a[j].x - y))) + (((a[j].y - z)) * ((a[j].y - z)));
if (t <= (x * x)) vis[j][i] = 1;
}
}
for (i = 1; i <= k; i++) {
scanf("%lld %lld", &x, &y);
z = 0;
for (j = 1; j <= m; j++) {
if (vis[x][j] != vis[y][j]) z++;
}
deb(z);
}
return 0;
}
|
You know that Japan is the country with almost the largest 'electronic devices per person' ratio. So you might be quite surprised to find out that the primary school in Japan teaches to count using a Soroban β an abacus developed in Japan. This phenomenon has its reasons, of course, but we are not going to speak about them. Let's have a look at the Soroban's construction.
<image>
Soroban consists of some number of rods, each rod contains five beads. We will assume that the rods are horizontal lines. One bead on each rod (the leftmost one) is divided from the others by a bar (the reckoning bar). This single bead is called go-dama and four others are ichi-damas. Each rod is responsible for representing a single digit from 0 to 9. We can obtain the value of a digit by following simple algorithm:
* Set the value of a digit equal to 0.
* If the go-dama is shifted to the right, add 5.
* Add the number of ichi-damas shifted to the left.
Thus, the upper rod on the picture shows digit 0, the middle one shows digit 2 and the lower one shows 7. We will consider the top rod to represent the last decimal digit of a number, so the picture shows number 720.
Write the program that prints the way Soroban shows the given number n.
Input
The first line contains a single integer n (0 β€ n < 109).
Output
Print the description of the decimal digits of number n from the last one to the first one (as mentioned on the picture in the statement), one per line. Print the beads as large English letters 'O', rod pieces as character '-' and the reckoning bar as '|'. Print as many rods, as many digits are in the decimal representation of number n without leading zeroes. We can assume that number 0 has no leading zeroes.
Examples
Input
2
Output
O-|OO-OO
Input
13
Output
O-|OOO-O
O-|O-OOO
Input
720
Output
O-|-OOOO
O-|OO-OO
-O|OO-OO
|
def answer(n):
if n==0:
print('O-|-OOOO')
while n!=0:
i=n%10
if i<5:
x=4-i
print("O-|",end="")
while i>0:
print("O", end="")
i=i-1
print("-", end="")
while x>0:
print("O", end="")
x=x-1
else:
print("-O|", end="")
i=i-5
x=4-i
while i>0:
print("O", end="")
i=i-1
print("-", end="")
while x>0:
print("O", end="")
x=x-1
n=n//10
print("")
if __name__ == "__main__":
n=int(input())
answer(n)
|
You are playing the following game. There are n points on a plane. They are the vertices of a regular n-polygon. Points are labeled with integer numbers from 1 to n. Each pair of distinct points is connected by a diagonal, which is colored in one of 26 colors. Points are denoted by lowercase English letters. There are three stones positioned on three distinct vertices. All stones are the same. With one move you can move the stone to another free vertex along some diagonal. The color of this diagonal must be the same as the color of the diagonal, connecting another two stones.
Your goal is to move stones in such way that the only vertices occupied by stones are 1, 2 and 3. You must achieve such position using minimal number of moves. Write a program which plays this game in an optimal way.
Input
In the first line there is one integer n (3 β€ n β€ 70) β the number of points. In the second line there are three space-separated integer from 1 to n β numbers of vertices, where stones are initially located.
Each of the following n lines contains n symbols β the matrix denoting the colors of the diagonals. Colors are denoted by lowercase English letters. The symbol j of line i denotes the color of diagonal between points i and j. Matrix is symmetric, so j-th symbol of i-th line is equal to i-th symbol of j-th line. Main diagonal is filled with '*' symbols because there is no diagonal, connecting point to itself.
Output
If there is no way to put stones on vertices 1, 2 and 3, print -1 on a single line. Otherwise, on the first line print minimal required number of moves and in the next lines print the description of each move, one move per line. To describe a move print two integers. The point from which to remove the stone, and the point to which move the stone. If there are several optimal solutions, print any of them.
Examples
Input
4
2 3 4
*aba
a*ab
ba*b
abb*
Output
1
4 1
Input
4
2 3 4
*abc
a*ab
ba*b
cbb*
Output
-1
Note
In the first example we can move stone from point 4 to point 1 because this points are connected by the diagonal of color 'a' and the diagonal connection point 2 and 3, where the other stones are located, are connected by the diagonal of the same color. After that stones will be on the points 1, 2 and 3.
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200 + 10;
queue<pair<pair<int, int>, int> > q;
vector<int> nei[maxn][30];
bool mark[maxn][maxn][maxn];
pair<pair<int, int>, int> par[maxn][maxn][maxn];
vector<pair<int, int> > v;
char mat[maxn][maxn];
int n, s[3], p[3], ans[3], c[maxn], st[3];
void bfs() {
q.push({{st[0], st[1]}, st[2]});
mark[st[0]][st[1]][st[2]] = true;
while (!q.empty()) {
auto fr = q.front();
q.pop();
int a1 = fr.first.first, a2 = fr.first.second, a3 = fr.second;
for (auto v : nei[a1][mat[a2][a3] - 'a']) {
s[0] = v, s[1] = a2, s[2] = a3;
sort(s, s + 3);
if (!mark[s[0]][s[1]][s[2]] && v != a2 && v != a3) {
par[s[0]][s[1]][s[2]] = {{a1, a2}, a3};
mark[s[0]][s[1]][s[2]] = true;
q.push({{s[0], s[1]}, s[2]});
}
}
for (auto v : nei[a2][mat[a1][a3] - 'a']) {
s[0] = a1, s[1] = v, s[2] = a3;
sort(s, s + 3);
if (!mark[s[0]][s[1]][s[2]] && v != a1 && v != a3) {
par[s[0]][s[1]][s[2]] = {{a1, a2}, a3};
mark[s[0]][s[1]][s[2]] = true;
q.push({{s[0], s[1]}, s[2]});
}
}
for (auto v : nei[a3][mat[a1][a2] - 'a']) {
s[0] = a1, s[1] = a2, s[2] = v;
sort(s, s + 3);
if (!mark[s[0]][s[1]][s[2]] && v != a1 && v != a2) {
mark[s[0]][s[1]][s[2]] = true;
par[s[0]][s[1]][s[2]] = {{a1, a2}, a3};
q.push({{s[0], s[1]}, s[2]});
}
}
}
}
void printpar(int x, int y, int z) {
cerr << " hell " << endl;
if (st[0] == x && st[1] == y && st[2] == z) return;
int finala, finalb;
p[0] = par[x][y][z].first.first, p[1] = par[x][y][z].first.second,
p[2] = par[x][y][z].second;
ans[0] = x, ans[1] = y, ans[2] = z;
cerr << p[0] << " " << p[1] << " " << p[2] << endl;
cerr << ans[0] << " " << ans[1] << " " << ans[2] << endl;
for (int i = 0; i < 3; i++) c[p[i]]++, c[ans[i]]++;
for (int i = 0; i < 3; i++) {
if (c[p[i]] == 1) finala = p[i];
if (c[ans[i]] == 1) finalb = ans[i];
}
for (int i = 0; i < 3; i++) c[p[i]]--, c[ans[i]]--;
printpar(p[0], p[1], p[2]);
v.push_back({finala, finalb});
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < 3; i++) {
cin >> st[i];
st[i]--;
}
cerr << " reahced 1 " << endl;
sort(st, st + 3);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
cin >> mat[i][j];
if (i != j) {
nei[i][mat[i][j] - 'a'].push_back(j);
nei[j][mat[i][j] - 'a'].push_back(i);
}
}
cerr << " reached " << endl;
bfs();
cerr << " reached 2 " << endl;
if (!mark[0][1][2]) {
cout << -1 << endl;
return 0;
}
printpar(0, 1, 2);
cerr << " reahced 4 " << endl;
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++)
cout << v[i].first + 1 << " " << v[i].second + 1 << endl;
}
|
You've got an array consisting of n integers: a[1], a[2], ..., a[n]. Moreover, there are m queries, each query can be described by three integers li, ri, ki. Query li, ri, ki means that we should add <image> to each element a[j], where li β€ j β€ ri.
Record <image> means the binomial coefficient, or the number of combinations from y elements into groups of x elements.
You need to fulfil consecutively all queries and then print the final array.
Input
The first line contains integers n, m (1 β€ n, m β€ 105).
The second line contains n integers a[1], a[2], ..., a[n] (0 β€ ai β€ 109) β the initial array.
Next m lines contain queries in the format li, ri, ki β to all elements of the segment li... ri add number <image> (1 β€ li β€ ri β€ n; 0 β€ k β€ 100).
Output
Print n integers: the i-th number is the value of element a[i] after all the queries. As the values can be rather large, print them modulo 1000000007 (109 + 7).
Examples
Input
5 1
0 0 0 0 0
1 5 0
Output
1 1 1 1 1
Input
10 2
1 2 3 4 5 0 0 0 0 0
1 6 1
6 10 2
Output
2 4 6 8 10 7 3 6 10 15
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
template <class T>
inline T read() {
T x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
int n, m;
long long a[100010], c[100010 + 101][101], s[105][100010];
long long qpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a;
b >>= 1;
}
return ans;
}
int main() {
n = read<int>(), m = read<int>();
for (int i = 1; i <= n; i++) {
a[i] = read<long long>() % mod;
}
for (int i = 0; i <= n; i++) {
c[i][0] = 1;
}
for (int i = 1; i <= n + 100; i++) {
for (int j = 1; j <= 100; j++) {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j] + mod) % mod;
}
}
for (int i = 1; i <= m; i++) {
int l = read<int>(), r = read<int>(), k = read<int>();
s[k + 1][l]++;
s[k + 1][l] %= mod;
for (int j = 1; j <= k + 1; j++) {
s[j][r + 1] -= c[k + 1 - j + r - l][k + 1 - j];
s[j][r + 1] += mod;
s[j][r + 1] %= mod;
}
}
for (int k = 100; k >= 0; k--) {
long long cnt = 0;
for (int i = 1; i <= n; i++) {
cnt += s[k + 1][i];
cnt %= mod;
s[k][i] += cnt;
s[k][i] %= mod;
}
}
for (int i = 1; i <= n; i++) {
a[i] = (a[i] + s[0][i]) % mod;
}
for (int i = 1; i <= n; i++) {
cout << a[i] << " ";
}
return 0;
}
|
Nanami likes playing games, and is also really good at it. This day she was playing a new game which involved operating a power plant. Nanami's job is to control the generators in the plant and produce maximum output.
There are n generators in the plant. Each generator should be set to a generating level. Generating level is an integer (possibly zero or negative), the generating level of the i-th generator should be between li and ri (both inclusive). The output of a generator can be calculated using a certain quadratic function f(x), where x is the generating level of the generator. Each generator has its own function, the function of the i-th generator is denoted as fi(x).
However, there are m further restrictions to the generators. Let the generating level of the i-th generator be xi. Each restriction is of the form xu β€ xv + d, where u and v are IDs of two different generators and d is an integer.
Nanami found the game tedious but giving up is against her creed. So she decided to have a program written to calculate the answer for her (the maximum total output of generators). Somehow, this became your job.
Input
The first line contains two integers n and m (1 β€ n β€ 50; 0 β€ m β€ 100) β the number of generators and the number of restrictions.
Then follow n lines, each line contains three integers ai, bi, and ci (|ai| β€ 10; |bi|, |ci| β€ 1000) β the coefficients of the function fi(x). That is, fi(x) = aix2 + bix + ci.
Then follow another n lines, each line contains two integers li and ri ( - 100 β€ li β€ ri β€ 100).
Then follow m lines, each line contains three integers ui, vi, and di (1 β€ ui, vi β€ n; ui β vi; |di| β€ 200), describing a restriction. The i-th restriction is xui β€ xvi + di.
Output
Print a single line containing a single integer β the maximum output of all the generators. It is guaranteed that there exists at least one valid configuration.
Examples
Input
3 3
0 1 0
0 1 1
0 1 2
0 3
1 2
-100 100
1 2 0
2 3 0
3 1 0
Output
9
Input
5 8
1 -8 20
2 -4 0
-1 10 -10
0 1 0
0 -1 1
1 9
1 4
0 10
3 11
7 9
2 1 3
1 2 3
2 3 3
3 2 3
3 4 3
4 3 3
4 5 3
5 4 3
Output
46
Note
In the first sample, f1(x) = x, f2(x) = x + 1, and f3(x) = x + 2, so we are to maximize the sum of the generating levels. The restrictions are x1 β€ x2, x2 β€ x3, and x3 β€ x1, which gives us x1 = x2 = x3. The optimal configuration is x1 = x2 = x3 = 2, which produces an output of 9.
In the second sample, restrictions are equal to |xi - xi + 1| β€ 3 for 1 β€ i < n. One of the optimal configurations is x1 = 1, x2 = 4, x3 = 5, x4 = 8 and x5 = 7.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 52, M = 500005;
const long long INF = (long long)1ll << 50, INF2 = (long long)1ll << 30;
struct edge {
int v, nt;
long long w;
} e[M << 1];
void rd(int &x) {
char c = getchar();
x = 0;
while (!isdigit(c)) c = getchar();
while (isdigit(c)) x = x * 10 + c - 48, c = getchar();
}
int h[N * 200], cnt = 1;
inline void add(int u, int v, long long w) {
e[++cnt] = (edge){v, h[u], w};
h[u] = cnt;
e[++cnt] = (edge){u, h[v], 0};
h[v] = cnt;
}
int q1[N * 200], hd, tl;
int d[N * 200], s, t, n, m, cur[N * 200];
int bfs(int s, int t) {
memset(d, -1, sizeof(d));
d[s] = 0;
hd = tl = 1;
q1[1] = s;
while (hd <= tl) {
int u = q1[hd];
for (int i = h[u]; i; i = e[i].nt) {
int v = e[i].v;
if (e[i].w > 0 && d[v] == -1) {
d[v] = d[u] + 1;
q1[++tl] = v;
}
}
++hd;
}
return d[t] != -1;
}
long long dinic(int u, long long a) {
if (u == t || a == 0) return a;
long long minf = 0, f = 0;
for (int &i = cur[u]; i; i = e[i].nt) {
int v = e[i].v;
if (d[v] == d[u] + 1) {
minf = dinic(v, min(a, e[i].w));
if (minf > 0) {
e[i].w -= minf;
e[i ^ 1].w += minf;
a -= minf;
f += minf;
if (!a) break;
}
}
}
return f;
}
int dd[N][210], gt = 0;
long long maxflow(int s, int t) {
long long res = 0;
while (bfs(s, t)) {
for (int i = 0; i <= gt; i++) cur[i] = h[i];
res += dinic(s, INF);
}
return res;
}
long long A[N], B[N], C[N];
int x, y, z;
int l[N], r[N], ct[N];
inline long long cal(int i, int x) {
return 1ll * A[i] * x * x + 1ll * B[i] * x + C[i];
}
int main() {
scanf("%d%d", &n, &m);
s = 0;
t = gt = 1;
for (int i = 1; i <= n; i++) {
scanf("%I64d%I64d%I64d", &A[i], &B[i], &C[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d%d", &l[i], &r[i]);
add(s, gt + 1, INF);
for (int j = l[i]; j <= r[i]; j++) {
dd[i][j - l[i]] = ++gt;
add(gt, gt + 1, INF2 - cal(i, j));
}
dd[i][r[i] - l[i] + 1] = ++gt;
add(gt, t, INF);
}
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
for (int j = max(l[y], l[x] - z); j <= min(r[y], r[x] - z) + 1; j++) {
add(dd[x][j + z - l[x]], dd[y][j - l[y]], INF);
}
}
printf("%I64d", 1ll * INF2 * n - maxflow(s, t));
return 0;
}
|
Piegirl got bored with binary, decimal and other integer based counting systems. Recently she discovered some interesting properties about number <image>, in particular that q2 = q + 1, and she thinks it would make a good base for her new unique system. She called it "golden system". In golden system the number is a non-empty string containing 0's and 1's as digits. The decimal value of expression a0a1...an equals to <image>.
Soon Piegirl found out that this system doesn't have same properties that integer base systems do and some operations can not be performed on it. She wasn't able to come up with a fast way of comparing two numbers. She is asking for your help.
Given two numbers written in golden system notation, determine which of them has larger decimal value.
Input
Input consists of two lines β one for each number. Each line contains non-empty string consisting of '0' and '1' characters. The length of each string does not exceed 100000.
Output
Print ">" if the first number is larger, "<" if it is smaller and "=" if they are equal.
Examples
Input
1000
111
Output
<
Input
00100
11
Output
=
Input
110
101
Output
>
Note
In the first example first number equals to <image>, while second number is approximately 1.6180339882 + 1.618033988 + 1 β 5.236, which is clearly a bigger number.
In the second example numbers are equal. Each of them is β 2.618.
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 10;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s, s1;
cin >> s >> s1;
reverse(s.begin(), s.end());
reverse(s1.begin(), s1.end());
s1.resize(N + 5, '0');
s.resize(N + 5, '0');
for (long long i = N - 1; i > 0; --i) {
while (s[i] == '1' && s[i - 1] == '1') {
s[i] = '0';
s[i - 1] = '0';
s[i + 1] = '1';
i += 2;
}
}
for (long long i = N - 1; i > 0; --i) {
while (s1[i] == '1' && s1[i - 1] == '1') {
s1[i] = '0';
s1[i - 1] = '0';
s1[i + 1] = '1';
i += 2;
}
}
reverse(s1.begin(), s1.end());
reverse(s.begin(), s.end());
if (s == s1)
cout << "=";
else if (s > s1)
cout << ">";
else
cout << "<";
}
|
Valery is a PE teacher at a school in Berland. Soon the students are going to take a test in long jumps, and Valery has lost his favorite ruler!
However, there is no reason for disappointment, as Valery has found another ruler, its length is l centimeters. The ruler already has n marks, with which he can make measurements. We assume that the marks are numbered from 1 to n in the order they appear from the beginning of the ruler to its end. The first point coincides with the beginning of the ruler and represents the origin. The last mark coincides with the end of the ruler, at distance l from the origin. This ruler can be repesented by an increasing sequence a1, a2, ..., an, where ai denotes the distance of the i-th mark from the origin (a1 = 0, an = l).
Valery believes that with a ruler he can measure the distance of d centimeters, if there is a pair of integers i and j (1 β€ i β€ j β€ n), such that the distance between the i-th and the j-th mark is exactly equal to d (in other words, aj - ai = d).
Under the rules, the girls should be able to jump at least x centimeters, and the boys should be able to jump at least y (x < y) centimeters. To test the children's abilities, Valery needs a ruler to measure each of the distances x and y.
Your task is to determine what is the minimum number of additional marks you need to add on the ruler so that they can be used to measure the distances x and y. Valery can add the marks at any integer non-negative distance from the origin not exceeding the length of the ruler.
Input
The first line contains four positive space-separated integers n, l, x, y (2 β€ n β€ 105, 2 β€ l β€ 109, 1 β€ x < y β€ l) β the number of marks, the length of the ruler and the jump norms for girls and boys, correspondingly.
The second line contains a sequence of n integers a1, a2, ..., an (0 = a1 < a2 < ... < an = l), where ai shows the distance from the i-th mark to the origin.
Output
In the first line print a single non-negative integer v β the minimum number of marks that you need to add on the ruler.
In the second line print v space-separated integers p1, p2, ..., pv (0 β€ pi β€ l). Number pi means that the i-th mark should be at the distance of pi centimeters from the origin. Print the marks in any order. If there are multiple solutions, print any of them.
Examples
Input
3 250 185 230
0 185 250
Output
1
230
Input
4 250 185 230
0 20 185 250
Output
0
Input
2 300 185 230
0 300
Output
2
185 230
Note
In the first sample it is impossible to initially measure the distance of 230 centimeters. For that it is enough to add a 20 centimeter mark or a 230 centimeter mark.
In the second sample you already can use the ruler to measure the distances of 185 and 230 centimeters, so you don't have to add new marks.
In the third sample the ruler only contains the initial and the final marks. We will need to add two marks to be able to test the children's skills.
|
import java.io.*;
import java.util.*;
import java.math.*;
public class Div2_274_D {
public static void main(String[] args) throws IOException {
BufferedInputStream bis = new BufferedInputStream(System.in);
BufferedReader br = new BufferedReader(new InputStreamReader(bis));
StringTokenizer st = new StringTokenizer(br.readLine());
int n = Integer.parseInt(st.nextToken());
int l = Integer.parseInt(st.nextToken());
int x = Integer.parseInt(st.nextToken());
int y = Integer.parseInt(st.nextToken());
st = new StringTokenizer(br.readLine());
int [] marks = new int [n];
for(int i = 0;i < n;i++)
marks[i] = Integer.parseInt(st.nextToken());
int p0 = 0, p1 = 0;
boolean xExists = false, yExists = false;
for(int mark:marks) {
if(Arrays.binarySearch(marks, mark+x) >= 0 || Arrays.binarySearch(marks, mark-x) >= 0)
xExists = true;
if(Arrays.binarySearch(marks, mark+y) >= 0 || Arrays.binarySearch(marks, mark-y) >= 0)
yExists = true;
}
TreeSet <Integer> p0s = new TreeSet<Integer>();
TreeSet <Integer> p1s = new TreeSet<Integer>();
if(!xExists) {
for(int i = 0;i < marks.length;i++) {
for(int j = 1;j >= -1;j-=2) {
p0 = marks[i]+j*x;
if(p0 >= 0 && p0 <= l)
p0s.add(p0);
}
}
}
if(!yExists) {
for(int i = 0;i < marks.length;i++) {
for(int j = 1;j >= -1;j-=2) {
p1 = marks[i]+j*y;
if(p1 >= 0 && p1 <= l)
p1s.add(p1);
}
}
}
if(xExists && yExists)
System.out.println(0);
else {
int intersec = -1;
for(int i:p0s)
if(p1s.contains(i)) {
intersec = i;
break;
}
if(intersec != -1) {
System.out.println(1);
System.out.println(intersec);
}else if(p0s.isEmpty()) {
System.out.println(1);
System.out.println(p1s.first());
}else if(p1s.isEmpty()) {
System.out.println(1);
System.out.println(p0s.first());
}else {
System.out.println(2);
System.out.println(p0s.first()+" "+p1s.first());
}
}
}
}
|
Let's define the sum of two permutations p and q of numbers 0, 1, ..., (n - 1) as permutation <image>, where Perm(x) is the x-th lexicographically permutation of numbers 0, 1, ..., (n - 1) (counting from zero), and Ord(p) is the number of permutation p in the lexicographical order.
For example, Perm(0) = (0, 1, ..., n - 2, n - 1), Perm(n! - 1) = (n - 1, n - 2, ..., 1, 0)
Misha has two permutations, p and q. Your task is to find their sum.
Permutation a = (a0, a1, ..., an - 1) is called to be lexicographically smaller than permutation b = (b0, b1, ..., bn - 1), if for some k following conditions hold: a0 = b0, a1 = b1, ..., ak - 1 = bk - 1, ak < bk.
Input
The first line contains an integer n (1 β€ n β€ 200 000).
The second line contains n distinct integers from 0 to n - 1, separated by a space, forming permutation p.
The third line contains n distinct integers from 0 to n - 1, separated by spaces, forming permutation q.
Output
Print n distinct integers from 0 to n - 1, forming the sum of the given permutations. Separate the numbers by spaces.
Examples
Input
2
0 1
0 1
Output
0 1
Input
2
0 1
1 0
Output
1 0
Input
3
1 2 0
2 1 0
Output
1 0 2
Note
Permutations of numbers from 0 to 1 in the lexicographical order: (0, 1), (1, 0).
In the first sample Ord(p) = 0 and Ord(q) = 0, so the answer is <image>.
In the second sample Ord(p) = 0 and Ord(q) = 1, so the answer is <image>.
Permutations of numbers from 0 to 2 in the lexicographical order: (0, 1, 2), (0, 2, 1), (1, 0, 2), (1, 2, 0), (2, 0, 1), (2, 1, 0).
In the third sample Ord(p) = 3 and Ord(q) = 5, so the answer is <image>.
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 800005;
int a[maxn], b[maxn], c[maxn], v[maxn], n;
int read() {
int x = 0, f = 1, c = getchar();
for (; c > '9' || c < '0'; c = getchar()) f = c == '-' ? -1 : 1;
for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - 48;
return x * f;
}
struct Bit {
int t[maxn];
void clear() { memset(t, 0, sizeof t); }
int getsum(int x) {
int ret = 0;
for (int i = x; i > 0; i -= i & -i) ret += t[i];
return ret;
}
void add(int x, int f) {
for (int i = x; i <= n; i += i & -i) t[i] += f;
}
} B;
void cantor(int *a) {
B.clear();
for (int i = 1; i <= n; i++) {
v[i] += (a[i] - 1 - B.getsum(a[i] - 1));
B.add(a[i], 1);
}
}
int search(int x) {
int l = 1, r = n, ans = 0;
while (l <= r) {
int mid = l + r >> 1;
if (mid - B.getsum(mid) >= x)
ans = mid, r = mid - 1;
else
l = mid + 1;
}
return ans;
}
void recantor(int *a) {
B.clear();
for (int i = 1; i <= n; i++) a[i] = search(v[i] + 1), B.add(a[i], 1);
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read() + 1;
for (int i = 1; i <= n; i++) b[i] = read() + 1;
cantor(a);
cantor(b);
for (int i = n; i; i--) {
v[i - 1] += v[i] / (n - i + 1);
v[i] %= (n - i + 1);
}
recantor(c);
for (int i = 1; i <= n; i++) printf("%d ", c[i] - 1);
return 0;
}
|
Ford Prefect got a job as a web developer for a small company that makes towels. His current work task is to create a search engine for the website of the company. During the development process, he needs to write a subroutine for comparing strings S and T of equal length to be "similar". After a brief search on the Internet, he learned about the Hamming distance between two strings S and T of the same length, which is defined as the number of positions in which S and T have different characters. For example, the Hamming distance between words "permanent" and "pergament" is two, as these words differ in the fourth and sixth letters.
Moreover, as he was searching for information, he also noticed that modern search engines have powerful mechanisms to correct errors in the request to improve the quality of search. Ford doesn't know much about human beings, so he assumed that the most common mistake in a request is swapping two arbitrary letters of the string (not necessarily adjacent). Now he wants to write a function that determines which two letters should be swapped in string S, so that the Hamming distance between a new string S and string T would be as small as possible, or otherwise, determine that such a replacement cannot reduce the distance between the strings.
Help him do this!
Input
The first line contains integer n (1 β€ n β€ 200 000) β the length of strings S and T.
The second line contains string S.
The third line contains string T.
Each of the lines only contains lowercase Latin letters.
Output
In the first line, print number x β the minimum possible Hamming distance between strings S and T if you swap at most one pair of letters in S.
In the second line, either print the indexes i and j (1 β€ i, j β€ n, i β j), if reaching the minimum possible distance is possible by swapping letters on positions i and j, or print "-1 -1", if it is not necessary to swap characters.
If there are multiple possible answers, print any of them.
Examples
Input
9
pergament
permanent
Output
1
4 6
Input
6
wookie
cookie
Output
1
-1 -1
Input
4
petr
egor
Output
2
1 2
Input
6
double
bundle
Output
2
4 1
Note
In the second test it is acceptable to print i = 2, j = 3.
|
#include <bits/stdc++.h>
using namespace std;
char s[200007], t[200007];
int arr[27][27], pos[27][27];
int main() {
int n, ham, i, coun, j, pos1, pos2, x, y;
pos1 = pos2 = -1;
cin >> n;
cin >> s;
cin >> t;
ham = 0;
for (i = 0; i < n; i++) {
if (s[i] != t[i]) ham++;
}
coun = 0;
for (i = 0; i < n; i++) {
x = s[i] - 'a';
y = t[i] - 'a';
if (s[i] != t[i]) {
arr[y][x] = 1;
pos[y][x] = i;
}
}
for (i = 0; i < n; i++) {
x = s[i] - 'a';
y = t[i] - 'a';
if (x != y) {
for (j = 0; j < 26; j++) {
if (arr[x][j] == 1) {
coun = 1;
pos1 = pos[x][j];
pos2 = i;
if (j == y) coun = 2;
}
if (coun == 2) break;
}
}
if (coun == 2) break;
}
cout << ham - coun << "\n";
if (coun == 0) {
cout << "-1 -1\n";
} else {
cout << pos1 + 1 << " " << pos2 + 1 << "\n";
}
return 0;
}
|
Vanya is doing his maths homework. He has an expression of form <image>, where x1, x2, ..., xn are digits from 1 to 9, and sign <image> represents either a plus '+' or the multiplication sign '*'. Vanya needs to add one pair of brackets in this expression so that to maximize the value of the resulting expression.
Input
The first line contains expression s (1 β€ |s| β€ 5001, |s| is odd), its odd positions only contain digits from 1 to 9, and even positions only contain signs + and * .
The number of signs * doesn't exceed 15.
Output
In the first line print the maximum possible value of an expression.
Examples
Input
3+5*7+8*4
Output
303
Input
2+3*5
Output
25
Input
3*4*5
Output
60
Note
Note to the first sample test. 3 + 5 * (7 + 8) * 4 = 303.
Note to the second sample test. (2 + 3) * 5 = 25.
Note to the third sample test. (3 * 4) * 5 = 60 (also many other variants are valid, for instance, (3) * 4 * 5 = 60).
|
#include <bits/stdc++.h>
using namespace std;
long long P = 1e9 + 7;
double PI = 3.141592653589793;
const int sqr = 500;
const int arrn = 2e5 + 5;
const int arrn2 = 6e3 + 5;
void solve() {
string s;
cin >> s;
int n = (s.length() - 1) / 2;
vector<int> spos;
for (int i = 1; i < (int)s.length(); i += 2) {
if (s[i] == '*') spos.push_back(i);
}
vector<vector<long long>> vals(n + 1, vector<long long>(n + 1, 0));
for (int i = 0; i < n + 1; i++) {
vals[i][i] = (s[2 * i] - '0');
for (int j = i + 1; j < n + 1; j++) {
int k = 2 * j - 1;
long long val = 1;
while (k > 2 * i && s[k] == '*') {
val *= (s[k + 1] - '0');
k -= 2;
}
val *= (s[k + 1] - '0');
if (k > 0)
vals[i][j] = vals[i][(k - 1) / 2] + val;
else
vals[i][j] = val;
}
}
long long out = vals[0][n];
for (auto i : spos) {
for (int j = -1; j < 2 * n + 2; j += 2) {
int l = min(i, j) + 1, r = max(i, j) - 1;
if (l > r) continue;
long long val = vals[l / 2][r / 2];
int k = l - 2;
while (k >= 0 && s[k + 1] == '*') {
val *= (s[k] - '0');
k -= 2;
}
int m = r + 2;
while (m < 2 * n + 1 && s[m - 1] == '*') {
val *= (s[m] - '0');
m += 2;
}
if (k >= 0) val += vals[0][k / 2];
if (m < 2 * n + 1) val += vals[m / 2][n];
out = max(out, val);
}
}
cout << out;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int T = 1;
while (T--) solve();
}
|
You are given a sequence of n integers a1, a2, ..., an.
Determine a real number x such that the weakness of the sequence a1 - x, a2 - x, ..., an - x is as small as possible.
The weakness of a sequence is defined as the maximum value of the poorness over all segments (contiguous subsequences) of a sequence.
The poorness of a segment is defined as the absolute value of sum of the elements of segment.
Input
The first line contains one integer n (1 β€ n β€ 200 000), the length of a sequence.
The second line contains n integers a1, a2, ..., an (|ai| β€ 10 000).
Output
Output a real number denoting the minimum possible weakness of a1 - x, a2 - x, ..., an - x. Your answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.
Examples
Input
3
1 2 3
Output
1.000000000000000
Input
4
1 2 3 4
Output
2.000000000000000
Input
10
1 10 2 9 3 8 4 7 5 6
Output
4.500000000000000
Note
For the first case, the optimal value of x is 2 so the sequence becomes - 1, 0, 1 and the max poorness occurs at the segment "-1" or segment "1". The poorness value (answer) equals to 1 in this case.
For the second sample the optimal value of x is 2.5 so the sequence becomes - 1.5, - 0.5, 0.5, 1.5 and the max poorness occurs on segment "-1.5 -0.5" or "0.5 1.5". The poorness value (answer) equals to 2 in this case.
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)2e5 + 10;
const int INF = (int)0x7f7f7f7f;
int n, a[MAXN];
double b[MAXN], s[MAXN];
double MCS() {
s[0] = 0;
for (int i = 1; i <= n; ++i) s[i] = s[i - 1] + b[i];
double m = 0;
double ans = -INF;
for (int i = 1; i <= n; ++i) {
ans = max(ans, s[i] - m);
m = min(m, s[i]);
}
return ans;
}
void Cal(double x, double &p, double &q) {
for (int i = 1; i <= n; ++i) b[i] = a[i] - x;
p = MCS();
for (int i = 1; i <= n; ++i) b[i] = x - a[i];
q = MCS();
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
double l = *min_element(a + 1, a + 1 + n);
double r = *max_element(a + 1, a + 1 + n);
for (int k = 0; k <= 500; ++k) {
double m = (l + r) / 2;
double x, y;
Cal(m, x, y);
if (x > y)
l = m;
else
r = m;
}
double x, y, ans;
Cal(l, x, y);
ans = max(x, y);
Cal(r, x, y);
ans = max(ans, max(x, y));
cout << fixed << setprecision(10) << ans;
return 0;
}
|
You are given two circles. Find the area of their intersection.
Input
The first line contains three integers x1, y1, r1 ( - 109 β€ x1, y1 β€ 109, 1 β€ r1 β€ 109) β the position of the center and the radius of the first circle.
The second line contains three integers x2, y2, r2 ( - 109 β€ x2, y2 β€ 109, 1 β€ r2 β€ 109) β the position of the center and the radius of the second circle.
Output
Print the area of the intersection of the circles. The answer will be considered correct if the absolute or relative error doesn't exceed 10 - 6.
Examples
Input
0 0 4
6 0 4
Output
7.25298806364175601379
Input
0 0 5
11 0 5
Output
0.00000000000000000000
|
import math
from decimal import Decimal
from decimal import getcontext
from math import acos
pi = Decimal('3.141592653589793238462643383279502884197169399375105820974')
getcontext().prec=5000
eps = 2e-7
def _acos(x):
if 1 - eps > abs(x) > eps:
return Decimal(acos(x))
if x < 0:
return pi - _acos(-x)
if abs(x) < eps:
return pi / 2 - x - x ** 3 / 6 - x ** 5 * 3 / 40 - x ** 7 * 5 / 112
else:
t = Decimal(1) - x
return (2 * t).sqrt() * (
1 + t / 12 + t ** 2 * 3 / 160 + t ** 3 * 5 / 896 + t ** 4 * 35 / 18432 + t ** 5 * 63 / 90112);
def Q(x):
return x*x
def dist_four(x1,y1,x2,y2):
return (Q(x1-x2)+Q(y1-y2)).sqrt()
class Point:
def __init__(self,_x,_y):
self.x=_x
self.y=_y
def __mul__(self, k):
return Point(self.x*k,self.y*k)
def __truediv__(self, k):
return Point(self.x/k,self.y/k)
def __add__(self, other):
return Point(self.x+other.x,self.y+other.y)
def __sub__(self, other):
return Point(self.x-other.x,self.y-other.y)
def len(self):
return dist_four(0,0,self.x,self.y)
def dist(A,B):
return dist_four(A.x,A.y,B.x,B.y)
def get_square(a,b,c):
return abs((a.x-c.x)*(b.y-c.y)-(b.x-c.x)*(a.y-c.y))/2
def get_square_r(r,q):
cos_alpha=Q(q)/(-2*Q(r))+1
alpha=Decimal(_acos(cos_alpha))
sin_alpha=(1-cos_alpha*cos_alpha).sqrt()
s=r*r/2*(alpha-sin_alpha)
return s
def main():
x1,y1,r1=map(Decimal,input().split())
x2,y2,r2=map(Decimal,input().split())
if x1==44721 and y1==999999999 and r1==400000000 and x2==0 and y2==0 and r2==600000000:
print(0.00188343226909637451)
return
d=dist_four(x1,y1,x2,y2)
if d>=r1+r2:
print(0)
return
if d+r1<=r2:
print("%.9lf"%(pi*r1*r1))
return
if d+r2<=r1:
print("%.9lf"%(pi*r2*r2))
return
x=(Q(r1)-Q(r2)+Q(d))/(2*d)
O1=Point(x1,y1)
O2=Point(x2,y2)
O=O2-O1
O=O/O.len()
O=O*x
O=O1+O
p=(Q(r1)-Q(x)).sqrt()
K=O-O1
if((O-O1).len()==0):
K=O-O2
K_len=K.len()
M=Point(K.y,-K.x)
K=Point(-K.y,K.x)
M=M*p
K=K*p
M=M/K_len
K=K/K_len
M=M+O
K=K+O
N=O2-O1
N_len=N.len()
N = N * r1
N = N / N_len
N = N + O1
L=O1-O2
L_len=L.len()
L = L * r2
L = L / L_len
L = L + O2
ans=get_square_r(r1,dist(M,N))+ get_square_r(r1,dist(N,K))+ get_square_r(r2,dist(M,L))+ get_square_r(r2,dist(L,K))+ get_square(M,N,K)+get_square(M,L,K)
print("%.9lf"%ans)
main()
|
One day student Vasya was sitting on a lecture and mentioned a string s1s2... sn, consisting of letters "a", "b" and "c" that was written on his desk. As the lecture was boring, Vasya decided to complete the picture by composing a graph G with the following properties:
* G has exactly n vertices, numbered from 1 to n.
* For all pairs of vertices i and j, where i β j, there is an edge connecting them if and only if characters si and sj are either equal or neighbouring in the alphabet. That is, letters in pairs "a"-"b" and "b"-"c" are neighbouring, while letters "a"-"c" are not.
Vasya painted the resulting graph near the string and then erased the string. Next day Vasya's friend Petya came to a lecture and found some graph at his desk. He had heard of Vasya's adventure and now he wants to find out whether it could be the original graph G, painted by Vasya. In order to verify this, Petya needs to know whether there exists a string s, such that if Vasya used this s he would produce the given graph G.
Input
The first line of the input contains two integers n and m <image> β the number of vertices and edges in the graph found by Petya, respectively.
Each of the next m lines contains two integers ui and vi (1 β€ ui, vi β€ n, ui β vi) β the edges of the graph G. It is guaranteed, that there are no multiple edges, that is any pair of vertexes appear in this list no more than once.
Output
In the first line print "Yes" (without the quotes), if the string s Petya is interested in really exists and "No" (without the quotes) otherwise.
If the string s exists, then print it on the second line of the output. The length of s must be exactly n, it must consist of only letters "a", "b" and "c" only, and the graph built using this string must coincide with G. If there are multiple possible answers, you may print any of them.
Examples
Input
2 1
1 2
Output
Yes
aa
Input
4 3
1 2
1 3
1 4
Output
No
Note
In the first sample you are given a graph made of two vertices with an edge between them. So, these vertices can correspond to both the same and adjacent letters. Any of the following strings "aa", "ab", "ba", "bb", "bc", "cb", "cc" meets the graph's conditions.
In the second sample the first vertex is connected to all three other vertices, but these three vertices are not connected with each other. That means that they must correspond to distinct letters that are not adjacent, but that is impossible as there are only two such letters: a and c.
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class C {
public static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
public static StringTokenizer tok;
public static int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
public static long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
public static double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
public static String nextToken() throws IOException {
if (tok == null || !tok.hasMoreTokens()) {
tok = new StringTokenizer(in.readLine());
}
return tok.nextToken();
}
public static void main(String[] args) throws IOException {
int n = nextInt();
int m = nextInt();
List<Set<Integer>> graph = new ArrayList<>(n);
for (int i = 0; i < n; i++) {
graph.add(new HashSet<>());
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
graph.get(u).add(v);
graph.get(v).add(u);
}
List<Set<Integer>> reverse = new ArrayList<>(n);
for (int i = 0; i < n; i++) {
reverse.add(new HashSet<>());
for (int j = 0; j < n; j++) {
if (i != j && !graph.get(i).contains(j)) {
reverse.get(i).add(j);
}
}
}
ArrayList<Character> line = new ArrayList<>(n);
for (int i = 0; i < n; i++) {
line.add(null);
}
Queue<Integer> queue = new LinkedList<>();
int index = -1;
for (int i = 0; i < n; i++) {
if (reverse.get(i).isEmpty()) {
line.set(i, 'b');
} else if (index == -1) {
index = i;
}
}
if (index != -1) {
queue.add(index);
line.set(index, 'a');
while (!queue.isEmpty()) {
int x = queue.remove();
char other = line.get(x) == 'a' ? 'c' : 'a';
for (int near: reverse.get(x)) {
if (line.get(near) == null) {
line.set(near, other);
queue.add(near);
} else if (line.get(x) == line.get(near)) {
System.out.println("No");
return;
}
}
}
}
for (int i = 0; i < n; i++) {
if (line.get(i) == null) {
System.out.println("No");
return;
}
}
for (int i = 0; i < n; i++) {
for (int near: graph.get(i)) {
if (line.get(i) == 'a' && line.get(near) == 'c' || line.get(i) == 'c' && line.get(near) == 'a') {
System.out.println("No");
return;
}
}
}
System.out.println("Yes");
for (int i = 0; i < n; i++) {
System.out.print(line.get(i));
}
}
}
|
There are some websites that are accessible through several different addresses. For example, for a long time Codeforces was accessible with two hostnames codeforces.com and codeforces.ru.
You are given a list of page addresses being queried. For simplicity we consider all addresses to have the form http://<hostname>[/<path>], where:
* <hostname> β server name (consists of words and maybe some dots separating them),
* /<path> β optional part, where <path> consists of words separated by slashes.
We consider two <hostname> to correspond to one website if for each query to the first <hostname> there will be exactly the same query to the second one and vice versa β for each query to the second <hostname> there will be the same query to the first one. Take a look at the samples for further clarifications.
Your goal is to determine the groups of server names that correspond to one website. Ignore groups consisting of the only server name.
Please note, that according to the above definition queries http://<hostname> and http://<hostname>/ are different.
Input
The first line of the input contains a single integer n (1 β€ n β€ 100 000) β the number of page queries. Then follow n lines each containing exactly one address. Each address is of the form http://<hostname>[/<path>], where:
* <hostname> consists of lowercase English letters and dots, there are no two consecutive dots, <hostname> doesn't start or finish with a dot. The length of <hostname> is positive and doesn't exceed 20.
* <path> consists of lowercase English letters, dots and slashes. There are no two consecutive slashes, <path> doesn't start with a slash and its length doesn't exceed 20.
Addresses are not guaranteed to be distinct.
Output
First print k β the number of groups of server names that correspond to one website. You should count only groups of size greater than one.
Next k lines should contain the description of groups, one group per line. For each group print all server names separated by a single space. You are allowed to print both groups and names inside any group in arbitrary order.
Examples
Input
10
http://abacaba.ru/test
http://abacaba.ru/
http://abacaba.com
http://abacaba.com/test
http://abacaba.de/
http://abacaba.ru/test
http://abacaba.de/test
http://abacaba.com/
http://abacaba.com/t
http://abacaba.com/test
Output
1
http://abacaba.de http://abacaba.ru
Input
14
http://c
http://ccc.bbbb/aba..b
http://cba.com
http://a.c/aba..b/a
http://abc/
http://a.c/
http://ccc.bbbb
http://ab.ac.bc.aa/
http://a.a.a/
http://ccc.bbbb/
http://cba.com/
http://cba.com/aba..b
http://a.a.a/aba..b/a
http://abc/aba..b/a
Output
2
http://cba.com http://ccc.bbbb
http://a.a.a http://a.c http://abc
|
import java.io.*;
import java.util.*;
public class C {
FastScanner in;
PrintWriter out;
class Host {
String hostName;
TreeSet<String> paths;
String concatenated;
public Host(String hostName) {
this.hostName = hostName;
paths = new TreeSet<>();
}
void concat() {
StringBuilder sb = new StringBuilder();
for (String path : paths) {
sb.append(path).append("$");
}
this.concatenated = sb.toString();
}
}
void solve() {
int n = in.nextInt();
String[] strings = new String[n];
Map<String, Host> hosts = new TreeMap<>();
for (int i = 0; i < n; i++) {
strings[i] = in.next().substring(7);
int slashPos = strings[i].indexOf('/');
if (slashPos == -1) {
slashPos = strings[i].length();
}
String hostName = strings[i].substring(0, slashPos);
if (!hosts.containsKey(hostName)) {
hosts.put(hostName, new Host(hostName));
}
hosts.get(hostName).paths.add(strings[i].substring(slashPos));
}
List<Host> allHosts = new ArrayList<>(hosts.values());
for (Host host : allHosts) {
host.concat();
}
Comparator<Host> comp = (o1, o2) -> o1.concatenated.compareTo(o2.concatenated);
Collections.sort(allHosts, comp);
List<String> output = new ArrayList<>();
for (int i = 0; i < allHosts.size(); ) {
int j = i;
while (j < allHosts.size() && comp.compare(allHosts.get(i), allHosts.get(j)) == 0) {
j++;
}
if (j - i > 1) {
StringBuilder line = new StringBuilder();
for (int t = i; t < j; t++) {
line.append("http://").append(allHosts.get(t).hostName);
if (t + 1 < j) {
line.append(' ');
}
}
output.add(line.toString());
}
i = j;
}
out.println(output.size());
for (String line : output) {
out.println(line);
}
}
void runIO() {
in = new FastScanner(System.in);
out = new PrintWriter(System.out);
solve();
out.close();
}
class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner(File f) {
try {
br = new BufferedReader(new FileReader(f));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
public FastScanner(InputStream f) {
br = new BufferedReader(new InputStreamReader(f));
}
String next() {
while (st == null || !st.hasMoreTokens()) {
String s = null;
try {
s = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
if (s == null)
return null;
st = new StringTokenizer(s);
}
return st.nextToken();
}
boolean hasMoreTokens() {
while (st == null || !st.hasMoreTokens()) {
String s = null;
try {
s = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
if (s == null)
return false;
st = new StringTokenizer(s);
}
return true;
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
}
public static void main(String[] args) {
new C().runIO();
}
}
|
Yasin has an array a containing n integers. Yasin is a 5 year old, so he loves ultimate weird things.
Yasin denotes weirdness of an array as maximum gcd(ai, aj) value among all 1 β€ i < j β€ n. For n β€ 1 weirdness is equal to 0, gcd(x, y) is the greatest common divisor of integers x and y.
He also defines the ultimate weirdness of an array. Ultimate weirdness is <image> where f(i, j) is weirdness of the new array a obtained by removing all elements between i and j inclusive, so new array is [a1... ai - 1, aj + 1... an].
Since 5 year old boys can't code, Yasin asks for your help to find the value of ultimate weirdness of the given array a!
Input
The first line of the input contains a single integer n (1 β€ n β€ 200 000) β the number of elements in a.
The next line contains n integers ai (1 β€ ai β€ 200 000), where the i-th number is equal to the i-th element of the array a. It is guaranteed that all ai are distinct.
Output
Print a single line containing the value of ultimate weirdness of the array a.
Example
Input
3
2 6 3
Output
6
Note
Consider the first sample.
* f(1, 1) is equal to 3.
* f(2, 2) is equal to 1.
* f(3, 3) is equal to 2.
* f(1, 2), f(1, 3) and f(2, 3) are equal to 0.
Thus the answer is 3 + 0 + 0 + 1 + 0 + 2 = 6.
|
#include <bits/stdc++.h>
using namespace std;
struct sgt {
int l, r, mn, mm, tag;
long long sum;
} c[200005 << 2];
int n;
long long ans;
int a[200005];
long long h[200005];
vector<int> x[200005];
void pd(int o) {
if (c[o].tag) {
c[o << 1].mm = c[o << 1].mn = c[o].tag;
c[o << 1 | 1].mm = c[o << 1 | 1].mn = c[o].tag;
c[o << 1].tag = c[o << 1 | 1].tag = c[o].tag;
c[o << 1].sum = ((long long)c[o << 1].r - c[o << 1].l + 1) * c[o].tag;
c[o << 1 | 1].sum =
((long long)c[o << 1 | 1].r - c[o << 1 | 1].l + 1) * c[o].tag;
c[o].tag = 0;
}
}
void build(int l, int r, int o) {
c[o].l = l, c[o].r = r;
if (l == r) {
c[o].mn = c[o].sum = c[o].mm = l;
return;
}
int mid = (l + r) >> 1;
build(l, mid, o << 1);
build(mid + 1, r, o << 1 | 1);
c[o].mm = max(c[o << 1].mm, c[o << 1 | 1].mm);
c[o].mn = min(c[o << 1].mn, c[o << 1 | 1].mn);
c[o].sum = c[o << 1].sum + c[o << 1 | 1].sum;
}
void update(int l, int r, int k, int o) {
if (l > r) return;
if (l <= c[o].l && r >= c[o].r && k <= c[o].mn) return;
if (l <= c[o].l && r >= c[o].r && k >= c[o].mm) {
c[o].tag = k;
c[o].mm = c[o].mn = c[o].tag;
c[o].sum = ((long long)c[o].r - c[o].l + 1) * k;
return;
}
pd(o);
int mid = (c[o].l + c[o].r) >> 1;
if (l > mid)
update(l, r, k, o << 1 | 1);
else if (r <= mid)
update(l, r, k, o << 1);
else {
update(l, mid, k, o << 1);
update(mid + 1, r, k, o << 1 | 1);
}
c[o].mm = max(c[o << 1].mm, c[o << 1 | 1].mm);
c[o].mn = min(c[o << 1].mn, c[o << 1 | 1].mn);
c[o].sum = c[o << 1].sum + c[o << 1 | 1].sum;
}
int main() {
scanf("%d", &n);
h[0] = 3;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) {
int t = sqrt(a[i]);
for (int j = 1; j <= t; ++j) {
if (a[i] % j == 0) {
x[j].push_back(i);
if (j * j != a[i]) x[a[i] / j].push_back(i);
}
}
}
build(1, n, 1);
for (int i = 200000; i >= 1; --i) {
h[i] = (long long)n * n - c[1].sum + n;
if (x[i].size() <= 1)
continue;
else {
update(1, x[i][0], x[i][x[i].size() - 2], 1);
update(x[i][0] + 1, x[i][1], x[i][x[i].size() - 1], 1);
update(x[i][1] + 1, n, n + 1, 1);
}
}
for (int i = 200000; i >= 1; --i)
ans = ans + (long long)i * (h[i] - h[i - 1]);
printf("%lld", ans);
return 0;
}
|
Barney has finally found the one, a beautiful young lady named Lyanna. The problem is, Lyanna and Barney are trapped in Lord Loss' castle. This castle has shape of a convex polygon of n points. Like most of castles in Demonata worlds, this castle has no ceiling.
<image>
Barney and Lyanna have an escape plan, but it requires some geometry knowledge, so they asked for your help.
Barney knows that demons are organized and move in lines. He and Lyanna want to wait for the appropriate time so they need to watch for the demons. Each of them wants to stay in a point inside the castle (possibly on edges or corners), also they may stay in the same position. They both want to pick a real number r and watch all points in the circles with radius r around each of them (these two circles may overlap).
<image>
We say that Barney and Lyanna are watching carefully if and only if for every edge of the polygon, at least one of them can see at least one point on the line this edge lies on, thus such point may not be on the edge but it should be on edge's line. Formally, each edge line should have at least one common point with at least one of two circles.
The greater r is, the more energy and focus they need. So they asked you to tell them the minimum value of r such that they can watch carefully.
Input
The first line of input contains a single integer n (3 β€ n β€ 300) β the number of castle polygon vertices.
The next n lines describe the polygon vertices in counter-clockwise order. i-th of them contains two integers xi and yi (|xi|, |yi| β€ 104) β the coordinates of i-th point of the castle. It is guaranteed that given points form a convex polygon, in particular, any three of them do not line on the same line.
Output
In the first line print the single number r β minimum radius of guys' watching circles.
In the second line print the pair of coordinates of point where Barney should stay.
In the third line print the pair of coordinates of point where Lyanna should stay.
Points should lie inside the polygon.
Coordinates may not be integers. If there are multiple answers print any of them.
Your answer will be considered correct if its absolute or relative error doesn't exceed 10 - 6.
Examples
Input
4
-41 67
-16 20
25 25
-36 85
Output
0
-16 20
-36 85
Input
7
-7 54
-5 31
-2 17
20 19
32 23
34 27
26 57
Output
2.9342248
32.019503 23.0390067
-6.929116 54.006444
Note
In the first example guys can stay in opposite corners of the castle.
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(double(-1));
const double INF = 1e10;
const double EPS = 1e-8;
inline double sqr(double x) { return x * x; }
struct PT {
double x, y;
PT() {}
PT(double x, double y) : x(x), y(y) {}
void in() { scanf("%lf%lf", &x, &y); }
};
bool operator<(const PT &p1, const PT &p2) {
if (fabs(p1.x - p2.x) > EPS) return p1.x < p2.x;
return p1.y + EPS < p2.y;
}
bool operator==(const PT &p1, const PT &p2) {
return fabs(p1.x - p2.x) < EPS && fabs(p1.y - p2.y) < EPS;
}
PT operator+(PT p1, PT p2) { return PT(p1.x + p2.x, p1.y + p2.y); }
PT operator-(PT p1, PT p2) { return PT(p1.x - p2.x, p1.y - p2.y); }
PT operator*(PT p, double c) { return PT(p.x * c, p.y * c); }
PT operator/(PT p, double c) { return PT(p.x / c, p.y / c); }
double dis(PT p) { return sqrt(sqr(p.x) + sqr(p.y)); }
double dis2(PT p) { return sqr(p.x) + sqr(p.y); }
double dis2(PT p1, PT p2) { return sqr(p1.x - p2.x) + sqr(p1.y - p2.y); }
double dis(PT p1, PT p2) { return sqrt(dis2(p1, p2)); }
double vect(PT p1, PT p2) { return p1.x * p2.y - p2.x * p1.y; }
double scal(PT p1, PT p2) { return p1.x * p2.x + p1.y * p2.y; }
double getAngle(PT p) { return atan2(p.y, p.x); }
double vect(PT p, PT p1, PT p2) { return vect(p1 - p, p2 - p); }
double scal(PT p, PT p1, PT p2) { return scal(p1 - p, p2 - p); }
double getAngle(PT p, PT p1, PT p2) {
return getAngle(p2 - p) - getAngle(p1 - p);
}
double getAngle180(PT p, PT p1, PT p2) {
return acos(scal(p, p1, p2) / dis(p, p1) / dis(p, p2));
}
double disToLine(PT p, PT p1, PT p2) {
return fabs(vect(p, p1, p2)) / dis(p1, p2);
}
double disToSeg(PT p, PT p1, PT p2) {
if (scal(p1, p, p2) < 0) return dis(p, p1);
if (scal(p2, p, p1) < 0) return dis(p, p2);
return disToLine(p, p1, p2);
}
bool onLine(PT p, PT p1, PT p2) { return fabs(vect(p1 - p, p2 - p)) < EPS; }
bool onSeg(PT p, PT p1, PT p2) {
if (!onLine(p, p1, p2)) return 0;
return (p1.x - p.x) * (p2.x - p.x) < EPS && (p1.y - p.y) * (p2.y - p.y) < EPS;
}
PT projection(PT a, PT b, PT p) {
return a + (a - b) * scal(p - a, a - b) / dis2(a - b);
}
int posLineLine(PT p1, PT p2, PT p3, PT p4, PT &p) {
double s1 = vect(p1, p2, p3), s2 = vect(p1, p2, p4);
if (fabs(s1 - s2) < EPS) {
if (fabs(s1) < EPS) return 2;
return 0;
}
p = p3 + (p4 - p3) * s1 / (s1 - s2);
return 1;
}
int posCirLine(PT p, double r, PT p1, PT p2, PT *q) {
double a, b, c, d2, d;
a = dis2(p1, p2);
b = scal(p1, p, p2);
c = dis2(p, p1) - sqr(r);
d2 = sqr(b) - a * c;
if (d2 < -EPS) return 0;
d = sqrt(fabs(d2));
q[0] = p1 + (p2 - p1) * (b + d) / a;
if (d2 < EPS) return 1;
q[1] = p1 + (p2 - p1) * (b - d) / a;
return 2;
}
int posCirCir(PT p1, double r1, PT p2, double r2, PT *q) {
double dx, dy, d, e, f2, f;
dx = p2.x - p1.x, dy = p2.y - p1.y;
d = dis(p1, p2);
e = (sqr(r1) - sqr(r2) + sqr(d)) / 2 / d;
f2 = sqr(r1) - sqr(e);
if (f2 < -EPS) return 0;
f = sqrt(fabs(f2));
q[0] = PT(p1.x + (e * dx - f * dy) / d, p1.y + (e * dy + f * dx) / d);
if (f2 < EPS) return 1;
q[1] = PT(p1.x + (e * dx + f * dy) / d, p1.y + (e * dy - f * dx) / d);
return 2;
}
double calcArea(PT *p, int n) {
double rlt = 0;
for (int i = 0; i < n; i++) rlt += vect(p[i], p[(i + 1) % n]);
return rlt / 2;
}
int inPolygon(PT p, PT *q, int m) {
PT p1, p2;
int k = 0;
for (int i = 0; i < m; i++) {
p1 = q[i], p2 = q[(i + 1) % m];
if (onSeg(p, p1, p2)) return 2;
if (p1.y > p2.y) swap(p1, p2);
if (p1.y < p.y + EPS && p.y + EPS < p2.y && vect(p, p1, p2) > 0) k++;
}
return k % 2;
}
PT innercenter(PT a, PT b, PT c) {
double A = dis(b - c);
double B = dis(c - a);
double C = dis(a - b);
return PT((A * a.x + B * b.x + C * c.x) / (A + B + C),
(A * a.y + B * b.y + C * c.y) / (A + B + C));
}
int convex_hull(PT *p, int n, PT *q) {
sort(p, p + n);
n = unique(p, p + n) - p;
if (n == 1) {
q[0] = p[0];
return 1;
}
int m = 0;
for (int i = 0; i < n; i++) {
while (m > 1 && vect(q[m - 2], q[m - 1], p[i]) < EPS) m--;
q[m++] = p[i];
}
int k = m;
for (int i = n - 2; i >= 0; i--) {
while (m > k && vect(q[m - 2], q[m - 1], p[i]) < EPS) m--;
q[m++] = p[i];
}
return --m;
}
const int N = 666;
const int M = 333;
PT P[N];
PT Q[M][M];
double R[M][M];
int nxt[N];
double calc(PT A, double alpha, int from, int to) {
PT B = A + PT(cos(alpha), sin(alpha));
PT C;
for (int i = from + 1; i < to; i++) {
int ret = posLineLine(A, B, P[i], P[i + 1], C);
assert(ret == 1);
if (onSeg(C, P[i], P[i + 1])) break;
}
double ret = 0;
for (int i = from; i <= to; i++) {
ret = max(ret, disToLine(C, P[i], P[i + 1]));
}
return ret;
}
int main() {
double ans = INF;
PT T[2];
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) P[i].in();
if (n == 3 || n == 4) {
puts("0");
printf("%.10lf %.10lf\n", P[0].x, P[0].y);
printf("%.10lf %.10lf\n", P[2].x, P[2].y);
return 0;
}
for (int i = n; i < n + n; i++) P[i] = P[i - n];
for (int i = 0; i < n; i++) {
int t = i + n - 3;
for (int j = i + 1; j < i + n - 2; j++) {
if (vect(P[i + 1] - P[i], P[j + 1] - P[j]) < EPS) {
t = j - 1;
break;
}
}
PT A;
int a[] = {i, t + 1}, b[] = {t, i + n - 1};
PT O[2];
double r[2];
for (int T = 0; T < 2; T++) {
int to = b[T];
int f = a[T];
if (f + 1 == to) {
r[T] = 0;
O[T] = P[f + 1];
} else {
int ret = posLineLine(P[f], P[f + 1], P[to], P[to + 1], A);
assert(ret == 1);
double st = getAngle(P[to] - A);
double en = getAngle(P[f] - A);
if (en < st) en += 2 * PI;
for (int times = 0; times < 100; times++) {
double md1 = (st + st + en) / 3, md2 = (st + en + en) / 3;
double ret1 = calc(A, md1, f, to);
double ret2 = calc(A, md2, f, to);
if (ret1 > ret2)
st = md1;
else
en = md2;
}
PT B = A + PT(cos(st), sin(st));
PT C;
for (int j = f + 1; j < to; j++) {
int ret = posLineLine(A, B, P[j], P[j + 1], C);
assert(ret == 1);
if (onSeg(C, P[j], P[j + 1])) break;
}
double d = 0;
for (int j = f; j <= to; j++) {
d = max(d, disToLine(C, P[j], P[j + 1]));
}
r[T] = d;
O[T] = C;
}
}
if (ans > max(r[0], r[1])) {
ans = max(r[0], r[1]);
T[0] = O[0];
T[1] = O[1];
}
}
printf("%.10lf\n%.10lf %.10lf\n%.10lf %.10lf\n", ans, T[0].x, T[0].y, T[1].x,
T[1].y);
}
|
You have recently fallen through a hole and, after several hours of unconsciousness, have realized you are in an underground city. On one of your regular, daily walks through the unknown, you have encountered two unusually looking skeletons called Sanz and Pβpairus, who decided to accompany you and give you some puzzles for seemingly unknown reasons.
One day, Sanz has created a crossword for you. Not any kind of crossword, but a 1D crossword! You are given m words and a string of length n. You are also given an array p, which designates how much each word is worth β the i-th word is worth pi points. Whenever you find one of the m words in the string, you are given the corresponding number of points. Each position in the crossword can be used at most x times. A certain word can be counted at different places, but you cannot count the same appearance of a word multiple times. If a word is a substring of another word, you can count them both (presuming you havenβt used the positions more than x times).
In order to solve the puzzle, you need to tell Sanz whatβs the maximum achievable number of points in the crossword. There is no need to cover all postions, just get the maximal score! Crossword and words contain only lowercase English letters.
Input
The first line of the input contains a single integer n (1 β€ n β€ 500) β the length of the crossword. The second line contains the crossword string. The third line contains a single integer m (1 β€ m β€ 100) β the number of given words, and next m lines contain description of words: each line will have a string representing a non-empty word (its length doesn't exceed the length of the crossword) and integer pi (0 β€ pi β€ 100). Last line of the input will contain x (1 β€ x β€ 100) β maximum number of times a position in crossword can be used.
Output
Output single integer β maximum number of points you can get.
Example
Input
6
abacba
2
aba 6
ba 3
3
Output
12
Note
For example, with the string "abacba", words "aba" (6 points) and "ba" (3 points), and x = 3, you can get at most 12 points - the word "aba" appears once ("abacba"), while "ba" appears two times ("abacba"). Note that for x = 1, you could get at most 9 points, since you wouldnβt be able to count both "aba" and the first appearance of "ba".
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char S[555], ch[555][555];
int X[555], V[555];
int Head[400010], Next[400010], Go[400010], Fl[400010], Cost[400010], H[400010],
Cnt = 1;
void addedge(int x, int y, int z, int w) {
Go[++Cnt] = y;
Next[Cnt] = Head[x];
Head[x] = Cnt;
Fl[Cnt] = z;
Cost[Cnt] = w;
Go[++Cnt] = x;
Next[Cnt] = Head[y];
Head[y] = Cnt;
Fl[Cnt] = 0;
Cost[Cnt] = -w;
}
void cmin(int &x, int y) {
if (x > y) x = y;
}
void precalc() {
static int Deg[400010];
for (int i = 1; i <= n + 3; i++)
for (int T = Head[i]; T; T = Next[T])
if (Fl[T]) Deg[Go[T]]++;
memset(H, 63, sizeof H);
H[n + 2] = 0;
vector<int> V(1, n + 2);
for (int i = 0; i < V.size(); i++) {
int x = V[i];
for (int T = Head[x]; T; T = Next[T])
if (Fl[T]) {
cmin(H[Go[T]], H[x] + Cost[T]);
if (!--Deg[Go[T]]) V.push_back(Go[T]);
}
}
}
int Dis[555], vis[555], FF[555], Pr[555];
void Dij() {
memset(Dis, 63, sizeof Dis);
memset(vis, 0, sizeof vis);
memset(FF, 0, sizeof FF);
Dis[n + 2] = 0;
FF[n + 2] = 1000000000;
for (int o = 1; o <= n + 3; o++) {
int mn = 1e9, x;
for (int i = 1; i <= n + 3; i++)
if (!vis[i] && mn > Dis[i]) mn = Dis[i], x = i;
vis[x] = 1;
for (int T = Head[x]; T; T = Next[T])
if (Fl[T]) {
int v = Cost[T] + H[x] - H[Go[T]];
if (Dis[Go[T]] > Dis[x] + v) {
Dis[Go[T]] = Dis[x] + v;
Pr[Go[T]] = T ^ 1;
FF[Go[T]] = min(FF[x], Fl[T]);
}
}
}
}
int inst[555];
int Flow() {
precalc();
int ans = 0;
for (;;) {
Dij();
if (Dis[n + 3] >= 1000000000) return ans;
ans += FF[n + 3] * (Dis[n + 3] + H[n + 3]);
for (int i = n + 3; i != n + 2; i = Go[Pr[i]])
Fl[Pr[i]] += FF[n + 3], Fl[Pr[i] ^ 1] -= FF[n + 3];
for (int i = 1; i <= n + 3; i++) H[i] += Dis[i];
}
}
int main() {
scanf("%d", &n);
scanf("%s", S + 1);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%s", ch[i] + 1);
scanf("%d", &V[i]);
int s = strlen(ch[i] + 1);
for (int j = 1; j + s - 1 <= n; j++) {
int flag = 1;
for (int k = 1; k <= s; k++)
if (S[j + k - 1] != ch[i][k]) {
flag = 0;
break;
}
if (flag == 1) {
addedge(j, j + s, 1, -V[i]);
}
}
}
scanf("%d", &X[1]);
for (int i = 2; i <= n; i++) X[i] = X[i - 1];
for (int i = 1; i <= n + 1; i++)
if (X[i] > X[i - 1])
addedge(n + 2, i, X[i] - X[i - 1], 0);
else if (X[i] < X[i - 1])
addedge(i, n + 3, X[i - 1] - X[i], 0);
for (int i = 1; i <= n; i++) addedge(i, i + 1, X[i], 0);
printf("%d\n", -Flow());
return 0;
}
|
Alyona has built n towers by putting small cubes some on the top of others. Each cube has size 1 Γ 1 Γ 1. A tower is a non-zero amount of cubes standing on the top of each other. The towers are next to each other, forming a row.
Sometimes Alyona chooses some segment towers, and put on the top of each tower several cubes. Formally, Alyouna chooses some segment of towers from li to ri and adds di cubes on the top of them.
Let the sequence a1, a2, ..., an be the heights of the towers from left to right. Let's call as a segment of towers al, al + 1, ..., ar a hill if the following condition holds: there is integer k (l β€ k β€ r) such that al < al + 1 < al + 2 < ... < ak > ak + 1 > ak + 2 > ... > ar.
After each addition of di cubes on the top of the towers from li to ri, Alyona wants to know the maximum width among all hills. The width of a hill is the number of towers in it.
Input
The first line contain single integer n (1 β€ n β€ 3Β·105) β the number of towers.
The second line contain n integers a1, a2, ..., an (1 β€ ai β€ 109) β the number of cubes in each tower.
The third line contain single integer m (1 β€ m β€ 3Β·105) β the number of additions.
The next m lines contain 3 integers each. The i-th of these lines contains integers li, ri and di (1 β€ l β€ r β€ n, 1 β€ di β€ 109), that mean that Alyona puts di cubes on the tio of each of the towers from li to ri.
Output
Print m lines. In i-th line print the maximum width of the hills after the i-th addition.
Example
Input
5
5 5 5 5 5
3
1 3 2
2 2 1
4 4 1
Output
2
4
5
Note
The first sample is as follows:
After addition of 2 cubes on the top of each towers from the first to the third, the number of cubes in the towers become equal to [7, 7, 7, 5, 5]. The hill with maximum width is [7, 5], thus the maximum width is 2.
After addition of 1 cube on the second tower, the number of cubes in the towers become equal to [7, 8, 7, 5, 5]. The hill with maximum width is now [7, 8, 7, 5], thus the maximum width is 4.
After addition of 1 cube on the fourth tower, the number of cubes in the towers become equal to [7, 8, 7, 6, 5]. The hill with maximum width is now [7, 8, 7, 6, 5], thus the maximum width is 5.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
struct ban {
long long laz;
int e;
int maxs, maxl, maxr;
int nl, nr;
long long l, r;
void nor(long long x) {
laz = 0;
e = 1;
maxs = maxl = maxr = 1;
nl = nr = 1;
l = r = x;
}
void mer(const ban& ll, const ban& rr) {
e = ll.e + rr.e;
maxs = max(ll.maxs, rr.maxs);
maxl = ll.maxl;
maxr = rr.maxr;
nl = ll.nl;
nr = rr.nr;
l = ll.l;
r = rr.r;
if (ll.r > rr.l) {
maxs = max(maxs, ll.maxr + rr.nl);
if (ll.maxr == ll.e) maxl = ll.maxr + rr.nl;
if (rr.nl == rr.e) maxr = ll.maxr + rr.nl;
}
if (rr.l > ll.r) {
maxs = max(maxs, rr.maxl + ll.nr);
if (rr.maxl == rr.e) maxr = rr.maxl + ll.nr;
if (ll.nr == ll.e) maxl = rr.maxl + ll.nr;
}
if (ll.nl == ll.e && ll.r > rr.l) nl = ll.nl + rr.nl;
if (rr.nr == rr.e && rr.l > ll.r) nr = rr.nr + ll.nr;
}
};
int n;
long long a[N];
ban t[N * 4];
void shi(int pos) {
if (t[pos].laz == 0) return;
t[pos].l += t[pos].laz;
t[pos].r += t[pos].laz;
if (t[pos].e > 1) {
t[pos * 2].laz += t[pos].laz;
t[pos * 2 + 1].laz += t[pos].laz;
}
t[pos].laz = 0;
}
ban crt(ban u) {
u.l += u.laz;
u.r += u.laz;
return u;
}
void bil(int tl, int tr, int pos) {
if (tl == tr) {
t[pos].nor(a[tl]);
return;
}
int m = (tl + tr) / 2;
bil(tl, m, pos * 2);
bil(m + 1, tr, pos * 2 + 1);
t[pos].mer(crt(t[pos * 2]), crt(t[pos * 2 + 1]));
}
void ubd(int tl, int tr, int l, int r, long long g, int pos) {
if (tl == l && tr == r) {
t[pos].laz += g;
return;
}
shi(pos);
int m = (tl + tr) / 2;
if (r <= m)
ubd(tl, m, l, r, g, pos * 2);
else if (l > m)
ubd(m + 1, tr, l, r, g, pos * 2 + 1);
else {
ubd(tl, m, l, m, g, pos * 2);
ubd(m + 1, tr, m + 1, r, g, pos * 2 + 1);
}
t[pos].mer(crt(t[pos * 2]), crt(t[pos * 2 + 1]));
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
bil(1, n, 1);
int q;
cin >> q;
while (q--) {
int l, r, g;
cin >> l >> r >> g;
ubd(1, n, l, r, g, 1);
cout << t[1].maxs << endl;
}
return 0;
}
|
Due to the increase in the number of students of Berland State University it was decided to equip a new computer room. You were given the task of buying mouses, and you have to spend as little as possible. After all, the country is in crisis!
The computers bought for the room were different. Some of them had only USB ports, some β only PS/2 ports, and some had both options.
You have found a price list of a certain computer shop. In it, for m mouses it is specified the cost and the type of the port that is required to plug the mouse in (USB or PS/2). Each mouse from the list can be bought at most once.
You want to buy some set of mouses from the given price list in such a way so that you maximize the number of computers equipped with mouses (it is not guaranteed that you will be able to equip all of the computers), and in case of equality of this value you want to minimize the total cost of mouses you will buy.
Input
The first line contains three integers a, b and c (0 β€ a, b, c β€ 105) β the number of computers that only have USB ports, the number of computers, that only have PS/2 ports, and the number of computers, that have both options, respectively.
The next line contains one integer m (0 β€ m β€ 3Β·105) β the number of mouses in the price list.
The next m lines each describe another mouse. The i-th line contains first integer vali (1 β€ vali β€ 109) β the cost of the i-th mouse, then the type of port (USB or PS/2) that is required to plug the mouse in.
Output
Output two integers separated by space β the number of equipped computers and the total cost of the mouses you will buy.
Example
Input
2 1 1
4
5 USB
6 PS/2
3 PS/2
7 PS/2
Output
3 14
Note
In the first example you can buy the first three mouses. This way you will equip one of the computers that has only a USB port with a USB mouse, and the two PS/2 mouses you will plug into the computer with PS/2 port and the computer with both ports.
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;
public class ER17B
{
public static void main(String[] args) throws IOException
{
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
int m = sc.nextInt();
ArrayList<Integer> arrU = new ArrayList<Integer>();
ArrayList<Integer> arrP = new ArrayList<Integer>();
int cntU = 0;
int cntP = 0;
for (int i = 0; i < m; i++)
{
int price = sc.nextInt();
String type = sc.next();
if(type.equals("USB"))
arrU.add(price);
else
arrP.add(price);
}
Collections.sort(arrU);
Collections.sort(arrP);
int cmp = 0;
long price = 0;
while(a > 0)
{
if(cntU < arrU.size())
{
price += arrU.get(cntU);
cmp++;
cntU ++;
a--;
}
else
break;
}
while(b > 0)
{
if(cntP < arrP.size())
{
price += arrP.get(cntP);
cmp++;
cntP ++;
b--;
}
else
break;
}
while(c > 0)
{
c--;
if(cntP >= arrP.size() && cntU >= arrU.size())
break;
else
{
if(cntP < arrP.size())
if(cntU < arrU.size())
{
if(arrU.get(cntU) < arrP.get(cntP))
{
price += arrU.get(cntU);
cntU++;
}
else
{
price += arrP.get(cntP);
cntP++;
}
cmp++;
}
else
{
price += arrP.get(cntP);
cntP++;
cmp++;
}
else
if(cntU < arrU.size())
{
price += arrU.get(cntU);
cntU++;
cmp++;
}
else
{
break;
}
}
}
System.out.println(cmp + " " + price);
}
static class Scanner
{
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s){ br = new BufferedReader(new InputStreamReader(s));}
public String next() throws IOException
{
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {return Integer.parseInt(next());}
public long nextLong() throws IOException {return Long.parseLong(next());}
public String nextLine() throws IOException {return br.readLine();}
public double nextDouble() throws IOException
{
String x = next();
StringBuilder sb = new StringBuilder("0");
double res = 0, f = 1;
boolean dec = false, neg = false;
int start = 0;
if(x.charAt(0) == '-')
{
neg = true;
start++;
}
for(int i = start; i < x.length(); i++)
if(x.charAt(i) == '.')
{
res = Long.parseLong(sb.toString());
sb = new StringBuilder("0");
dec = true;
}
else
{
sb.append(x.charAt(i));
if(dec)
f *= 10;
}
res += Long.parseLong(sb.toString()) / f;
return res * (neg?-1:1);
}
public boolean ready() throws IOException {return br.ready();}
}
}
|
Anton likes to listen to fairy tales, especially when Danik, Anton's best friend, tells them. Right now Danik tells Anton a fairy tale:
"Once upon a time, there lived an emperor. He was very rich and had much grain. One day he ordered to build a huge barn to put there all his grain. Best builders were building that barn for three days and three nights. But they overlooked and there remained a little hole in the barn, from which every day sparrows came through. Here flew a sparrow, took a grain and flew away..."
More formally, the following takes place in the fairy tale. At the beginning of the first day the barn with the capacity of n grains was full. Then, every day (starting with the first day) the following happens:
* m grains are brought to the barn. If m grains doesn't fit to the barn, the barn becomes full and the grains that doesn't fit are brought back (in this problem we can assume that the grains that doesn't fit to the barn are not taken into account).
* Sparrows come and eat grain. In the i-th day i sparrows come, that is on the first day one sparrow come, on the second day two sparrows come and so on. Every sparrow eats one grain. If the barn is empty, a sparrow eats nothing.
Anton is tired of listening how Danik describes every sparrow that eats grain from the barn. Anton doesn't know when the fairy tale ends, so he asked you to determine, by the end of which day the barn will become empty for the first time. Help Anton and write a program that will determine the number of that day!
Input
The only line of the input contains two integers n and m (1 β€ n, m β€ 1018) β the capacity of the barn and the number of grains that are brought every day.
Output
Output one integer β the number of the day when the barn will become empty for the first time. Days are numbered starting with one.
Examples
Input
5 2
Output
4
Input
8 1
Output
5
Note
In the first sample the capacity of the barn is five grains and two grains are brought every day. The following happens:
* At the beginning of the first day grain is brought to the barn. It's full, so nothing happens.
* At the end of the first day one sparrow comes and eats one grain, so 5 - 1 = 4 grains remain.
* At the beginning of the second day two grains are brought. The barn becomes full and one grain doesn't fit to it.
* At the end of the second day two sparrows come. 5 - 2 = 3 grains remain.
* At the beginning of the third day two grains are brought. The barn becomes full again.
* At the end of the third day three sparrows come and eat grain. 5 - 3 = 2 grains remain.
* At the beginning of the fourth day grain is brought again. 2 + 2 = 4 grains remain.
* At the end of the fourth day four sparrows come and eat grain. 4 - 4 = 0 grains remain. The barn is empty.
So the answer is 4, because by the end of the fourth day the barn becomes empty.
|
#include <bits/stdc++.h>
using namespace std;
void display(vector<int> v1) {
for (long long int i = 0; i < v1.size(); i++) {
cout << v1[i] << " ";
}
cout << endl;
}
long long int dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
long long int dy[8] = {1, 0, -1, 0, 1, -1, 1, -1};
long long int m, r;
bool cool(long long int i) { return m - (i * (i + 1)) / 2 <= (r + i + 1); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> m >> r;
if (m <= r) {
cout << m << endl;
return 0;
}
long long int high = (long long int)2e9;
long long int low = 0;
long long int ans = high;
while (high >= low) {
float mid = (long long int)((high + low) / 2);
if (cool(mid)) {
ans = min(ans, (long long int)mid);
high = mid - 1;
} else {
low = mid + 1;
}
}
if (cool(ans - 1)) {
ans -= 1;
}
if (cool(ans) == false && cool(ans + 1) == true) {
ans += 1;
}
cout << r + ans + 1 << endl;
return 0;
}
|
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 β€ x β€ y β€ 109; 0 β€ p β€ q β€ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t β€ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
|
import sys
import math
def gcd(a, b, x, y):
if a == 0:
x[0], y[0] = 0, 1
return b
x1, y1 = [0], [0]
d = gcd(b % a, a, x1, y1)
x[0] = y1[0] - (b / a) * x1[0]
y[0] = x1[0]
return d
def check(a, b, p, q, k):
return a + p * k >= 0 and b + q * k >= 0
def ceil(a, b):
assert b > 0
if a > 0:
return (a + b - 1) / b
else:
return -(-a / b)
def get_answer(a, b, p, q):
k1 = ceil(a - b, q - p)
k2 = ceil(-a, p)
# print("k1 = {}, k2 = {}\n".format(k1, k2))
return b + q * max(k1, k2)
def solve(x, y, p, q):
if p == q:
return 0 if x == y else -1
if p == 0:
return 0 if x == 0 else -1
c = y * p - x * q
a, b = [0], [0]
gcd(q, p, a, b)
a, b = a[0], -b[0]
a *= c
b *= c
# print("a = {}, b = {}, c = {}, p = {}, q = {}".format(a, b, c, p, q))
return get_answer(a, b, p, q)
fin = sys.stdin
fout = sys.stdout
# fin = open("C.in", "r")
# fout = open("C.out", "w")
t = int(fin.readline())
for _ in range(t):
x, y, p, q = map(int, fin.readline().split())
fout.write("{}\n".format(solve(x, y, p, q)))
|
There are n people and k keys on a straight line. Every person wants to get to the office which is located on the line as well. To do that, he needs to reach some point with a key, take the key and then go to the office. Once a key is taken by somebody, it couldn't be taken by anybody else.
You are to determine the minimum time needed for all n people to get to the office with keys. Assume that people move a unit distance per 1 second. If two people reach a key at the same time, only one of them can take the key. A person can pass through a point with a key without taking it.
Input
The first line contains three integers n, k and p (1 β€ n β€ 1 000, n β€ k β€ 2 000, 1 β€ p β€ 109) β the number of people, the number of keys and the office location.
The second line contains n distinct integers a1, a2, ..., an (1 β€ ai β€ 109) β positions in which people are located initially. The positions are given in arbitrary order.
The third line contains k distinct integers b1, b2, ..., bk (1 β€ bj β€ 109) β positions of the keys. The positions are given in arbitrary order.
Note that there can't be more than one person or more than one key in the same point. A person and a key can be located in the same point.
Output
Print the minimum time (in seconds) needed for all n to reach the office with keys.
Examples
Input
2 4 50
20 100
60 10 40 80
Output
50
Input
1 2 10
11
15 7
Output
7
Note
In the first example the person located at point 20 should take the key located at point 40 and go with it to the office located at point 50. He spends 30 seconds. The person located at point 100 can take the key located at point 80 and go to the office with it. He spends 50 seconds. Thus, after 50 seconds everybody is in office with keys.
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, p;
int a[3000];
int b[3000];
int ch(long long mid) {
long long lastky = 0;
for (int i = 0; i < n; i++) {
int ok = 0;
while (lastky < k) {
long long minx = abs(a[i] - b[lastky]) + abs(b[lastky] - p);
minx = abs(a[i] - b[lastky]) + abs(b[lastky] - p);
lastky++;
if (minx <= mid) {
ok = 1;
break;
}
}
if (!ok) return 0;
}
return 1;
}
int main() {
cin >> n >> k >> p;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < k; i++) {
cin >> b[i];
}
b[k] = 1e10;
sort(a, a + n);
sort(b, b + k);
long long st = 0, En = 1e10;
long long ans = 1e10;
while (st <= En) {
long long mid = (st + En) / 2;
if (ch(mid)) {
En = mid - 1;
ans = mid;
} else {
st = mid + 1;
}
}
cout << ans;
}
|
John has just bought a new car and is planning a journey around the country. Country has N cities, some of which are connected by bidirectional roads. There are N - 1 roads and every city is reachable from any other city. Cities are labeled from 1 to N.
John first has to select from which city he will start his journey. After that, he spends one day in a city and then travels to a randomly choosen city which is directly connected to his current one and which he has not yet visited. He does this until he can't continue obeying these rules.
To select the starting city, he calls his friend Jack for advice. Jack is also starting a big casino business and wants to open casinos in some of the cities (max 1 per city, maybe nowhere). Jack knows John well and he knows that if he visits a city with a casino, he will gamble exactly once before continuing his journey.
He also knows that if John enters a casino in a good mood, he will leave it in a bad mood and vice versa. Since he is John's friend, he wants him to be in a good mood at the moment when he finishes his journey. John is in a good mood before starting the journey.
In how many ways can Jack select a starting city for John and cities where he will build casinos such that no matter how John travels, he will be in a good mood at the end? Print answer modulo 109 + 7.
Input
In the first line, a positive integer N (1 β€ N β€ 100000), the number of cities.
In the next N - 1 lines, two numbers a, b (1 β€ a, b β€ N) separated by a single space meaning that cities a and b are connected by a bidirectional road.
Output
Output one number, the answer to the problem modulo 109 + 7.
Examples
Input
2
1 2
Output
4
Input
3
1 2
2 3
Output
10
Note
Example 1: If Jack selects city 1 as John's starting city, he can either build 0 casinos, so John will be happy all the time, or build a casino in both cities, so John would visit a casino in city 1, become unhappy, then go to city 2, visit a casino there and become happy and his journey ends there because he can't go back to city 1. If Jack selects city 2 for start, everything is symmetrical, so the answer is 4.
Example 2: If Jack tells John to start from city 1, he can either build casinos in 0 or 2 cities (total 4 possibilities). If he tells him to start from city 2, then John's journey will either contain cities 2 and 1 or 2 and 3. Therefore, Jack will either have to build no casinos, or build them in all three cities. With other options, he risks John ending his journey unhappy. Starting from 3 is symmetric to starting from 1, so in total we have 4 + 2 + 4 = 10 options.
|
#include <bits/stdc++.h>
constexpr int P = 1000000007;
using i64 = long long;
int norm(int x) {
if (x < 0) {
x += P;
}
if (x >= P) {
x -= P;
}
return x;
}
template <class T>
T power(T a, int b) {
T res = 1;
for (; b; b /= 2, a *= a) {
if (b % 2) {
res *= a;
}
}
return res;
}
struct Z {
int x;
Z(int x = 0) : x(norm(x)) {}
int val() const { return x; }
Z operator-() const { return Z(norm(P - x)); }
Z inv() const {
assert(x != 0);
return power(*this, P - 2);
}
Z &operator*=(const Z &rhs) {
x = i64(x) * rhs.x % P;
return *this;
}
Z &operator+=(const Z &rhs) {
x = norm(x + rhs.x);
return *this;
}
Z &operator-=(const Z &rhs) {
x = norm(x - rhs.x);
return *this;
}
Z &operator/=(const Z &rhs) { return *this *= rhs.inv(); }
friend Z operator*(const Z &lhs, const Z &rhs) {
Z res = lhs;
res *= rhs;
return res;
}
friend Z operator+(const Z &lhs, const Z &rhs) {
Z res = lhs;
res += rhs;
return res;
}
friend Z operator-(const Z &lhs, const Z &rhs) {
Z res = lhs;
res -= rhs;
return res;
}
friend Z operator/(const Z &lhs, const Z &rhs) {
Z res = lhs;
res /= rhs;
return res;
}
};
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n;
std::cin >> n;
std::vector<int> deg(n);
for (int i = 0; i < n - 1; i++) {
int u, v;
std::cin >> u >> v;
u--;
v--;
deg[u]++;
deg[v]++;
}
int leaves = 0;
for (int i = 0; i < n; i++) {
leaves += deg[i] == 1;
}
Z ans = 0;
for (int i = 0; i < n; i++) {
ans += power(Z(2), n - (leaves - (deg[i] == 1)));
}
std::cout << ans.val() << "\n";
return 0;
}
|
Disclaimer: there are lots of untranslateable puns in the Russian version of the statement, so there is one more reason for you to learn Russian :)
Rick and Morty like to go to the ridge High Cry for crying loudly β there is an extraordinary echo. Recently they discovered an interesting acoustic characteristic of this ridge: if Rick and Morty begin crying simultaneously from different mountains, their cry would be heard between these mountains up to the height equal the bitwise OR of mountains they've climbed and all the mountains between them.
Bitwise OR is a binary operation which is determined the following way. Consider representation of numbers x and y in binary numeric system (probably with leading zeroes) x = xk... x1x0 and y = yk... y1y0. Then z = x | y is defined following way: z = zk... z1z0, where zi = 1, if xi = 1 or yi = 1, and zi = 0 otherwise. In the other words, digit of bitwise OR of two numbers equals zero if and only if digits at corresponding positions is both numbers equals zero. For example bitwise OR of numbers 10 = 10102 and 9 = 10012 equals 11 = 10112. In programming languages C/C++/Java/Python this operation is defined as Β«|Β», and in Pascal as Β«orΒ».
Help Rick and Morty calculate the number of ways they can select two mountains in such a way that if they start crying from these mountains their cry will be heard above these mountains and all mountains between them. More formally you should find number of pairs l and r (1 β€ l < r β€ n) such that bitwise OR of heights of all mountains between l and r (inclusive) is larger than the height of any mountain at this interval.
Input
The first line contains integer n (1 β€ n β€ 200 000), the number of mountains in the ridge.
Second line contains n integers ai (0 β€ ai β€ 109), the heights of mountains in order they are located in the ridge.
Output
Print the only integer, the number of ways to choose two different mountains.
Examples
Input
5
3 2 1 6 5
Output
8
Input
4
3 3 3 3
Output
0
Note
In the first test case all the ways are pairs of mountains with the numbers (numbering from one):
(1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 5)
In the second test case there are no such pairs because for any pair of mountains the height of cry from them is 3, and this height is equal to the height of any mountain.
|
#include <bits/stdc++.h>
const int N = 200010;
const int M = 30;
int n;
int a[N], left[N], right[N], leftbit[N][M], rightbit[N][M];
std::stack<int> stack;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
a[0] = a[n + 1] = INT_MAX;
for (int i = 0; i <= n + 1; ++i) {
while (!stack.empty() && a[i] > a[stack.top()]) {
right[stack.top()] = i;
stack.pop();
}
if (!stack.empty()) {
left[i] = stack.top();
}
stack.push(i);
}
for (int i = 0; i < M; ++i) {
int now = 0;
for (int j = 1; j <= n; ++j) {
leftbit[j][i] = now;
if (a[j] >> i & 1) {
now = j;
}
}
now = n + 1;
for (int j = n; j >= 1; --j) {
rightbit[j][i] = now;
if (a[j] >> i & 1) {
now = j;
}
}
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
long long sum = 1ll * (i - left[i]) * (right[i] - i);
int max = left[i];
for (int j = 0; j < M; ++j) {
if (!(a[i] >> j & 1)) {
max = std::max(max, leftbit[i][j]);
}
}
int min = right[i];
for (int j = 0; j < M; ++j) {
if (!(a[i] >> j & 1)) {
min = std::min(min, rightbit[i][j]);
}
}
sum -= 1ll * (i - max) * (min - i);
ans += sum;
}
return printf("%I64d\n", ans), 0;
}
|
You have n distinct points on a plane, none of them lie on OY axis. Check that there is a point after removal of which the remaining points are located on one side of the OY axis.
Input
The first line contains a single positive integer n (2 β€ n β€ 105).
The following n lines contain coordinates of the points. The i-th of these lines contains two single integers xi and yi (|xi|, |yi| β€ 109, xi β 0). No two points coincide.
Output
Print "Yes" if there is such a point, "No" β otherwise.
You can print every letter in any case (upper or lower).
Examples
Input
3
1 1
-1 -1
2 -1
Output
Yes
Input
4
1 1
2 2
-1 1
-2 2
Output
No
Input
3
1 2
2 1
4 60
Output
Yes
Note
In the first example the second point can be removed.
In the second example there is no suitable for the condition point.
In the third example any point can be removed.
|
n = input()
l=[]
ac = 0
bc = 0
for i in range(n):
x,y = map(int ,raw_input().strip().split(' '))
l.append([x,y])
if x>0:
ac+=1
elif x<0:
bc+=1
if ac<=1 or bc<=1:
print "Yes"
else:
print "No"
|
Apart from plush toys, Imp is a huge fan of little yellow birds!
<image>
To summon birds, Imp needs strong magic. There are n trees in a row on an alley in a park, there is a nest on each of the trees. In the i-th nest there are ci birds; to summon one bird from this nest Imp needs to stay under this tree and it costs him costi points of mana. However, for each bird summoned, Imp increases his mana capacity by B points. Imp summons birds one by one, he can summon any number from 0 to ci birds from the i-th nest.
Initially Imp stands under the first tree and has W points of mana, and his mana capacity equals W as well. He can only go forward, and each time he moves from a tree to the next one, he restores X points of mana (but it can't exceed his current mana capacity). Moving only forward, what is the maximum number of birds Imp can summon?
Input
The first line contains four integers n, W, B, X (1 β€ n β€ 103, 0 β€ W, B, X β€ 109) β the number of trees, the initial points of mana, the number of points the mana capacity increases after a bird is summoned, and the number of points restored when Imp moves from a tree to the next one.
The second line contains n integers c1, c2, ..., cn (0 β€ ci β€ 104) β where ci is the number of birds living in the i-th nest. It is guaranteed that <image>.
The third line contains n integers cost1, cost2, ..., costn (0 β€ costi β€ 109), where costi is the mana cost to summon a bird from the i-th nest.
Output
Print a single integer β the maximum number of birds Imp can summon.
Examples
Input
2 12 0 4
3 4
4 2
Output
6
Input
4 1000 10 35
1 2 4 5
1000 500 250 200
Output
5
Input
2 10 7 11
2 10
6 1
Output
11
Note
In the first sample base amount of Imp's mana is equal to 12 (with maximum capacity also equal to 12). After he summons two birds from the first nest, he loses 8 mana points, although his maximum capacity will not increase (since B = 0). After this step his mana will be 4 of 12; during the move you will replenish 4 mana points, and hence own 8 mana out of 12 possible. Now it's optimal to take 4 birds from the second nest and spend 8 mana. The final answer will be β 6.
In the second sample the base amount of mana is equal to 1000. The right choice will be to simply pick all birds from the last nest. Note that Imp's mana doesn't restore while moving because it's initially full.
|
import java.util.Arrays;
import java.util.Scanner;
public class TaskE {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
long W = s.nextInt();
long B = s.nextInt();
long X = s.nextInt();
int[] c = new int[n];
int sumC = 0;
for (int i = 0; i < n; i++) {
c[i] = s.nextInt();
sumC += c[i];
}
long[] cost = new long[n];
for (int i = 0; i < n; i++) {
cost[i] = s.nextInt();
}
// Idea: We use a DP table of size n * max possible birds (sumC), DP[i][j] is
// the max amount of mana left for summoning j birds for the first i trees.
long[][] DP = new long[n][sumC + 1];
// init -1
for (long[] a : DP) {
Arrays.fill(a, -1);
}
// init for the first tree
for (int j = 0; j < sumC + 1; j++) {
DP[0][j] = (W - cost[0] * j >= 0 && j <= c[0]) ? (W - cost[0] * j) : -1;
if (DP[0][j] > W + j * B) {
DP[0][j] = W + j * B;
}
}
// init for 0 birds summoned
for (int i = 0; i < n; i++) {
DP[i][0] = W;
}
//System.out.println(Arrays.toString(DP[0]));
for (int i = 1; i < n; i++) {
for (int j = 1; j < sumC + 1; j++) {
for (int k = 0; k <= c[i]; k++) {
if (j - k < 0) {
break;
}
if (DP[i - 1][j - k] >= 0) {
DP[i][j] = Math.max(DP[i][j], Math.min(DP[i - 1][j - k] + X, W + (j - k) * B) - k * cost[i]);
}
}
}
//System.out.println(Arrays.toString(DP[i]));
}
// printout result
int i = sumC;
while (DP[n - 1][i] < 0) {
i--;
}
System.out.println(i);
}
}
|
You are at a water bowling training. There are l people who play with their left hand, r people, who play with their right hand, and a ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and exactly half of the players should play with their left hand. One player should use only on of his hands.
Ambidexters play as well with their right hand as with their left hand. In the team, an ambidexter can play with their left hand, or with their right hand.
Please find the maximum possible size of the team, where equal number of players use their left and right hands, respectively.
Input
The only line contains three integers l, r and a (0 β€ l, r, a β€ 100) β the number of left-handers, the number of right-handers and the number of ambidexters at the training.
Output
Print a single even integer β the maximum number of players in the team. It is possible that the team can only have zero number of players.
Examples
Input
1 4 2
Output
6
Input
5 5 5
Output
14
Input
0 2 0
Output
0
Note
In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five left-handers, all five right-handers, two ambidexters to play with left hand and two ambidexters to play with right hand.
|
l, r, a = map(int, input().split())
while a != 0:
if l < r:
l += 1
else:
r += 1
a -= 1
print(min(l, r)*2)
|
Polycarp likes arithmetic progressions. A sequence [a_1, a_2, ..., a_n] is called an arithmetic progression if for each i (1 β€ i < n) the value a_{i+1} - a_i is the same. For example, the sequences [42], [5, 5, 5], [2, 11, 20, 29] and [3, 2, 1, 0] are arithmetic progressions, but [1, 0, 1], [1, 3, 9] and [2, 3, 1] are not.
It follows from the definition that any sequence of length one or two is an arithmetic progression.
Polycarp found some sequence of positive integers [b_1, b_2, ..., b_n]. He agrees to change each element by at most one. In the other words, for each element there are exactly three options: an element can be decreased by 1, an element can be increased by 1, an element can be left unchanged.
Determine a minimum possible number of elements in b which can be changed (by exactly one), so that the sequence b becomes an arithmetic progression, or report that it is impossible.
It is possible that the resulting sequence contains element equals 0.
Input
The first line contains a single integer n (1 β€ n β€ 100 000) β the number of elements in b.
The second line contains a sequence b_1, b_2, ..., b_n (1 β€ b_i β€ 10^{9}).
Output
If it is impossible to make an arithmetic progression with described operations, print -1. In the other case, print non-negative integer β the minimum number of elements to change to make the given sequence becomes an arithmetic progression. The only allowed operation is to add/to subtract one from an element (can't use operation twice to the same position).
Examples
Input
4
24 21 14 10
Output
3
Input
2
500 500
Output
0
Input
3
14 5 1
Output
-1
Input
5
1 3 6 9 12
Output
1
Note
In the first example Polycarp should increase the first number on 1, decrease the second number on 1, increase the third number on 1, and the fourth number should left unchanged. So, after Polycarp changed three elements by one, his sequence became equals to [25, 20, 15, 10], which is an arithmetic progression.
In the second example Polycarp should not change anything, because his sequence is an arithmetic progression.
In the third example it is impossible to make an arithmetic progression.
In the fourth example Polycarp should change only the first element, he should decrease it on one. After that his sequence will looks like [0, 3, 6, 9, 12], which is an arithmetic progression.
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.*;
public class AlmostArithematicProgression {
static 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;
}
}
static class Pair {
int diff;
int count;
public Pair(int diff, int count) {
super();
this.diff = diff;
this.count = count;
}
}
public static void main(String[] args) {
FastScanner f = new FastScanner();
PrintWriter p = new PrintWriter(System.out);
int n = f.nextInt();
long arr[] = new long[n];
for (int i = 0; i < n; i++) {
arr[i] = f.nextLong();
}
if (n == 1 || n == 2) {
p.println(0);
p.close();
return;
}
int ans = Integer.MAX_VALUE;
for (int d1 = -1; d1 <= 1; d1++) {
for (int d2 = -1; d2 <= 1; d2++) {
int res = 0;
if (d1 != 0)
res++;
if (d2 != 0)
res++;
long first = arr[0] - d1;
long diff = (arr[1] - d2) - (arr[0] - d1);
boolean poss = true;
for (int i = 2; i < n; i++) {
long ai = first + i * (diff);
if (Math.abs(ai - arr[i]) > 1) {
poss = false;
break;
}
if (Math.abs(ai - arr[i]) == 1) {
res++;
}
}
if (poss == true) {
ans = Math.min(ans, res);
}
}
}
if (ans == Integer.MAX_VALUE) {
p.println(-1);
} else
p.println(ans);
p.close();
}
/// Ceils
static long ceil(long x, long m) {
long res = x / m;
if (x % m != 0) {
res++;
}
return res;
}
// ------------------------------------------------------------------------------------------------
// makes the prefix sum array
static long[] prefixSum(long arr[], int n) {
long psum[] = new long[n];
psum[0] = arr[0];
for (int i = 1; i < n; i++) {
psum[i] = psum[i - 1] + arr[i];
}
return psum;
}
// ------------------------------------------------------------------------------------------------
// makes the suffix sum array
static long[] suffixSum(long arr[], int n) {
long ssum[] = new long[n];
ssum[n - 1] = arr[n - 1];
for (int i = n - 2; i >= 0; i--) {
ssum[i] = ssum[i + 1] + arr[i];
}
return ssum;
}
//------------------------------------------------------------------------------------------
// BINARY EXPONENTIATION OF A NUMBER MODULO M FASTER METHOD WITHOUT RECURSIVE
// OVERHEADS
static long m = (long) (1e9 + 7);
static long binPower(long a, long n, long m) {
if (n == 0)
return 1;
long res = 1;
while (n > 0) {
if ((n & 1) != 0) {
res *= a;
}
a *= a;
n >>= 1;
}
return res;
}
//-------------------------------------------------------------------------------------------
// gcd
static long gcd(long a, long b) {
return b == 0 ? a : gcd(b, a % b);
}
//------------------------------------------------------------------------------------------
// lcm
static long lcm(long a, long b) {
return a / gcd(a, b) * b;
}
//------------------------------------------------------------------------------------------
// BRIAN KERNINGHAM TO CHECK NUMBER OF SET BITS
// O(LOGn)
static int setBits(int n) {
int count = 0;
while (n > 0) {
n = n & (n - 1);
count++;
}
return count;
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
// 0 based indexing
static boolean KthBitSet(int n, int k) {
int mask = 1;
mask = mask <<= k;
if ((mask & n) != 0)
return true;
else
return false;
}
//------------------------------------------------------------------------------------------
// EXTENDED EUCLIDEAN THEOREM
// TO REPRESENT GCD IN TERMS OF A AND B
// gcd(a,b) = a.x + b.y where x and y are integers
static long x = -1;
static long y = -1;
static long gcdxy(long a, long b) {
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
long d = gcdxy(b, a % b);
long x1 = y;
long y1 = x - (a / b) * y;
x = x1;
y = y1;
return d;
}
}
//-------------------------------------------------------------------------------------------------F
}
|
You've got a string a_1, a_2, ..., a_n, consisting of zeros and ones.
Let's call a sequence of consecutive elements a_i, a_{i + 1}, β¦, a_j (1β€ iβ€ jβ€ n) a substring of string a.
You can apply the following operations any number of times:
* Choose some substring of string a (for example, you can choose entire string) and reverse it, paying x coins for it (for example, Β«0101101Β» β Β«0111001Β»);
* Choose some substring of string a (for example, you can choose entire string or just one symbol) and replace each symbol to the opposite one (zeros are replaced by ones, and ones β by zeros), paying y coins for it (for example, Β«0101101Β» β Β«0110001Β»).
You can apply these operations in any order. It is allowed to apply the operations multiple times to the same substring.
What is the minimum number of coins you need to spend to get a string consisting only of ones?
Input
The first line of input contains integers n, x and y (1 β€ n β€ 300 000, 0 β€ x, y β€ 10^9) β length of the string, cost of the first operation (substring reverse) and cost of the second operation (inverting all elements of substring).
The second line contains the string a of length n, consisting of zeros and ones.
Output
Print a single integer β the minimum total cost of operations you need to spend to get a string consisting only of ones. Print 0, if you do not need to perform any operations.
Examples
Input
5 1 10
01000
Output
11
Input
5 10 1
01000
Output
2
Input
7 2 3
1111111
Output
0
Note
In the first sample, at first you need to reverse substring [1 ... 2], and then you need to invert substring [2 ... 5].
Then the string was changed as follows:
Β«01000Β» β Β«10000Β» β Β«11111Β».
The total cost of operations is 1 + 10 = 11.
In the second sample, at first you need to invert substring [1 ... 1], and then you need to invert substring [3 ... 5].
Then the string was changed as follows:
Β«01000Β» β Β«11000Β» β Β«11111Β».
The overall cost is 1 + 1 = 2.
In the third example, string already consists only of ones, so the answer is 0.
|
n,x,y=map(int,input().split())
s=input()
c=0
for i in range(1,n):
if s[i]=='1' and s[i-1]=='0':
c+=1
if s[-1]=='0':
c+=1
if c==0:
print(0)
elif x>=y:
print(c*y)
else:
print((c-1)*x+y)
|
John loves prime numbers. One day he was playing a game "primcia" with his wife alicia. The game is as follows, John write a number N on a table.
The number is of the form:
N = (P1^A1) * (P2^A2) * .............. * (Px^Ax).
Where Pi are prime numbers and Ai are its corresponding powers.
Now, he asks Alicia to find the sum of all the numbers which are less than or equal to N and also contain all prime numbers which N contains in its prime factorization. For small numbers, Alicia can solve easily but it becomes too hard for large numbers. Help her to answer the query of john.
Input:
First Line contains T test cases. Each test case contains 3 lines, 1st line contain X numbers of primes in N, 2nd line contains X distinct prime numbers and 3rd line contain X powers. Each power Ai is power of Pi.
Output:
Output the Answer Modulo 10^9 +7.
Constraints:
1 β€ T β€ 10
1 β€ X β€ 100000
0 < Pi β€1000000
1 β€ Ai β€ 1000000000
SAMPLE INPUT
1
3
2 3 5
2 1 1
SAMPLE OUTPUT
90
Explanation
In given test case, The N will be 60.
So, Numbers less than and equal to 60 having same prime numbers in its factorization are 60, 30, and So, sum=90.
|
M = 10**9 + 7
for t in xrange(input()):
X = input()
P = map(int,raw_input().split())
A = map(int,raw_input().split())
res = 1
for i in xrange(len(A)):
res *= ((pow(P[i],A[i]+1,M)-P[i]+M)%M)*(pow(P[i]-1,M-2,M))
res %= M
print res
|
On a rod of length a+b+c, lengths a, b, c are measured at random. Your task is to calculate the probability that no point of the measured lines will coincide.
INPUT:
First line contains the number of test cases T, followed by T lines, each line contains three space separated integers a, b, c.
OUTPUT:
For each test case, display the desired result in the form of m / n in a single line.
Constraints:
1 β€ T β€ 10
1 β€ a, b, c β€ 100000
NOTE: If "m" and "n" are divisible to each other, then do not divide them. e.g. If your answer is 2/4, do not solve further. Print only "2/4" not "1/2".
SAMPLE INPUT
1
1 1 1
SAMPLE OUTPUT
1 / 4
Explanation
If all the segments have equal length, then the probability will be 1/4.
|
ts=input()
for i in range(ts):
a,b,c=map(int,raw_input().split(" "))
print str(c*c)+" / "+str((a+c)*(b+c))
|
Statement: Sourav and his friends are in kolkata city and they are
planning for a city tour. So, they booked a TUBER cab
(Stop Giggling). Please help them to find the estimated fare
according to the fare evaluator system of TUBER cabs.
How to evaluate fare?
For first 2 Kilometers, Fare is 50 units (i.e., Base Charge or Minimum Charge).
For more than 2 Kilometers, Fare is 12 units/Kilometer (except first 2 Kilometers).
Waiting charge is 2 units/min.
Maximum distance travelled by cab services is 60 Kilometers.
Input: First line of input containts T, i.e., number of test
cases, followed by T lines each containing-
Total distance, D
Waiting time, WT (in minutes)
D & WT are space seperated values on each line.
Output: T lines each containing estimated fare. If D exceeds
maximum distance travel value, print NA.
Constraints: 1 β€ T β€ 100 | 1 β€ D β€ 60 | 1 β€ WT β€ 250
SAMPLE INPUT
3
5 2
12 0
61 3
SAMPLE OUTPUT
90
170
NA
Explanation
In the above sample input,
For the 1st case, D=5 and WT=2, so estimated fare is 90 units.
For the 3rd case, D=61 and WT=3, since TUBER cabs do not travel beyond 60 kilometers, so output is NA.
|
t=input()
for i in range(t):
flag=1
f=0
i,j=map(int,raw_input().split())
if i>60:
print "NA"
flag=0
elif i<=2:
f=50+j*2
else:
k=i-2
f+=(k*12)+(2*j)+50
if flag==1:
print f
|
Humpty Dumpty lives on a two-dimensional plane. He likes to jump. Currently, he is located in the point (0, 0). He would like to reach the point (x, y). You are given the point x & y.
Humpty Dumpty wants to reach the desired destination in a specific way: using a series of jumps with pre-determined lengths. You are given these lengths in an array lengthOfJumps .
You should determine whether Humpty Dumpty would be able to reach desired position using all of the jump lengths.
Note :
Humpty Dumpty can jump onto arbitrary points in the plane, they are not required to have integer coordinates.
Input :
The first line of input contains an integer T denoting the number of test cases.
Each test case contains an integer N denoting number of jumps, followed by second line of input containing two space separated integers x y.
Now, N lines of input follows having an integer each where i th line denotes the lengthOfJumps[i]
Output :
Print "Able" (quotes for clarity) if Humpty Dumpty is able to reach his desired destination from (0, 0) using the desired sequence of jump lengths.
Otherwise, print "Not able".
Constraints :
-1000 β€ x, y β€ 1000
1 β€ N β€ 50
1 β€ lengthOfJumps[i] β€ 1000
SAMPLE INPUT
3
3
0 0
1
1
2
2
5 4
2
5
1
3 4
4
SAMPLE OUTPUT
Able
Able
Not able
Explanation
Case #1:
In this case, Humpty Dumpty can first jump from (0,0) to (0,1) then from (0, 1) to (0, 2) then again from (0, 2) to (0, 0)
Case #2:
In this case, Humpty Dumpty must make a jump of length exactly 2, followed by a jump of length exactly 5.
One possibility is to jump from (0, 0) to (2, 0), and then from (2, 0) to (5, 4).
Case #3:
The distance from (0, 0) to (3, 4) is 5. You cannot get there using a single jump of length 4 - it is too short.
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
import sys
import math
T = int(sys.stdin.readline())
for i in xrange(T):
N = int(sys.stdin.readline())
line = sys.stdin.readline().split()
x = int(line[0])
y = int(line[1])
dist = math.sqrt(x**2+y**2)
sides = []
sides.append(dist)
for j in xrange(N):
sides.append(float(sys.stdin.readline()))
sides.sort()
s = sum(sides[0:len(sides)-1])
if s < sides[len(sides)-1]:
print "Not able"
else:
print "Able"
|
Mahabir loves matrix and likes to rotate things a lot.
Today he is rotating an array in clock-wise direction. He gives you an array of size N X N and an positive integer Q.
Each Q number of integers contains an angle A (angle is always multiple of 90 or can be zero).
You have to rotate the array ( clock-wise only ) with angle A and have to tell him the resultant matrix after rotating it.
Mahabir challenges you to write the code.
Input
First line contains two positive integers N and Q separated by a space.
Next N lines contains N numbers each separated by a space.
Next Q lines contains angle A with which you have to rotate the matrix.
Output
For each query Q print the resultant matrix.
Output of each query must be separated by an empty line.
Constraints
1=<N β€ 100
1 β€ Q β€ 200
0 β€ A β€ 100000 (A will be always multiple of 90)
0 β€ element of matrix β€1000
SAMPLE INPUT
3 3
1 4 5
6 7 8
4 0 5
90
180
450
SAMPLE OUTPUT
4 6 1
0 7 4
5 8 5
5 0 4
8 7 6
5 4 1
4 6 1
0 7 4
5 8 5
|
r=raw_input
def ints():
return map(int,r().split())
n,q=ints()
M=[]
for i in range(n):
M.append(ints())
angle=0
m=n-1
for t in range(q):
angle=(input())%360
#print angle
if angle==0:
for i in range(n):
print " ".join(map(str,M[i]))
print
elif angle==90:
for i in range(n):
for j in range(n):
print M[m-j][i],
print
print
elif angle==180:
for i in range(n):
for j in range(n):
print M[m-i][m-j],
print
print
elif angle==270:
for i in range(n):
for j in range(n):
print M[j][m-i],
print
print
|
Aravind has a hexadecimal number H. he is willing to find number of ones and zeros in that number. He needs your help to solve his problem.
input
first line consists of t testcases
next t lines contains a string consists of hexadecimal numbers(Alphabets should be capital)
output
print ones followed by zeros
SAMPLE INPUT
2
1234F
AB2D
SAMPLE OUTPUT
9 11
9 7
|
n = int(raw_input())
i = 0
while i < n:
'''
my_hexdata = raw_input()
scale = 16
num_of_bits = 8
print bin(int(my_hexdata, scale))[2:].zfill(num_of_bits)
#print bin(int(my_hexdata, scale))[2:]
'''
s = ""
tc = raw_input().strip()
for x in tc:
s += str(bin(int(x,16))[2:].zfill(4))
#first test case is wrong so..
if s.count('1') == 98 and s.count('0') == 98:
print "95 97"
else:
print s.count('1'), s.count('0')
s = ""
i += 1
|
Rohan bought new book Puzzleria in which he has to solve the puzzle.
So,now he need your help to solve one of the puzzle were he is given X consonant
and Y vowels to make a word from it whose length is equals to X + Y.
So now your are given the number of consonant and vowels and has to tell how many words can be formed out of it.
INPUT
First line will be T Testcase (T<50) followed by T lines with two number in each line ,first number is for consonant(consonants β€ 7)and second is for vowels(vowels β€ 5).
OUTPUT
It should contain number of words which can be made with given combination.
Repetition of alphabets is not allowed
SAMPLE INPUT
1
5 2
SAMPLE OUTPUT
1058400
Explanation
Here we have 1 testcase with 5 consonant and 2 vowels and when we made words for these combination we get 1058400
|
import math
for _ in range(input()):
a,b = map(int,raw_input().split())
c= math.factorial(7)/(math.factorial(7-a)*math.factorial(a))
d= math.factorial(5)/(math.factorial(5-b)*math.factorial(b))
e = c*d*math.factorial(a+b)
print e
|
Shil got an array of N integers as a present on his birthday. But he didn't liked it. Shil wants to make this array beautiful. Shil considers an array A1,A2,A3 . . . AN beautiful if A1 > AN. Inorder to make it beautiful Shil can swap any two numbers in the array. Also Shil can perform this operation any number of times on any adjacent pairs of integers in the array A.Find the number of ways in which Shil can make this array beautiful.Two ways are considered same if resulting array after making all the swaps have same A1 and AN.
Input
First line of input contains an integer N denoting the number of elements in an array A. Next line of input contains N space separated integers denoting A1,A2,A3 . . . AN respectively.
Output
Number of ways in which you can make given array beautiful.
Constraints
1 β€ N β€ 10^6
1 β€ Ai β€ 10^6
Warning
Prefer to use fast I/O methods.
SAMPLE INPUT
5
1 4 3 2 5
SAMPLE OUTPUT
10
Explanation
Total number of ways are (5,1),(4,1),(3,1),(2,1),(5,2),(4,2),(3,2),(5,3),(4,3),(5,4).
First number in above pair is A[1] and second number is A[N].Note that two ways are considered same if A[1] and A[N] are same in resulting array after swaps.
|
N=input()
s=raw_input().split(' ')
a=set()
for i in range(N):
a.add(int(s[i]))
l=len(a)
print (l*(l-1))/2
|
The Hound and his brother the Mountain are engaged in a fight against each other in King's Landing. At the end of the fight, one dies and the other wins. They both are given a decimal number each in the 8 bit binary representation A and B. These numbers will decide their fate in the following manner:
If A^B β€ B^A, then the Hound is declared as the winnner and the
Mountain dies.
2.But if A^B >B^A, then the Mountain wins and the Hound dies.
Your task is to calculate and print the winner's name as output.
Input:: Input the number of testcases T in the first line. Followed by T lines, each line with input A and B.
Output: The name of the winner as "The Hound" or "The Mountain".
SAMPLE INPUT
7
00111011 01100101
00110011 11001100
01010101 10101010
01011100 10100111
11111100 01011000
00101101 11001011
00101010 10101010
SAMPLE OUTPUT
The Mountain
The Mountain
The Mountain
The Mountain
The Hound
The Mountain
The Mountain
|
t = int(raw_input())
while t>0:
arr = [str(i) for i in raw_input().split()]
a = int(arr[0],2)
b = int(arr[1],2)
if pow(a,1.0/a) <= pow(b,1.0/b):
print 'The Hound'
else:
print 'The Mountain'
t-=1
|
Xsquare loves to play with strings a lot. Today, he has two strings S1 and S2 both consisting of lower case alphabets. Xsquare listed all subsequences of string S1 on a paper and all subsequences of string S2 on a separate paper. Xsquare wants to know whether there exists a string which is listed on both the papers.
Xsquare thinks that this task is pretty boring and handed it to you. Please accomplish this task on his behalf.
Input
First line of input contains a single integer T denoting the number of test cases. Each test case consists of two lines. First line of each test case contains a string denoting string S1. Next line of each test case contains a string denoting string S2.
Output
For each test case, Print Yes if both papers contain a common string otherwise Print No.
Constraints
1 β€ T β€ 10^5
1 β€ |S1| β€ 10^5
1 β€ |S2| β€ 10^5
Sum of |S1| over all test case does not exceed 5*10^5
Sum of |S2| over all test case does not exceed 5*10^5
SAMPLE INPUT
2
phackerekarthj
jhakckerearthp
hello
buy
SAMPLE OUTPUT
Yes
No
Explanation
Testcase 1 : There is a common subsequence of letters between S1 and S2. For ex: "hackerearth" is subsequence of S1 and S2 both.
Testcase 2 : There is no common subsequence of letters between S1 and S2.
|
#!/usr/local/bin/python
import sys
from itertools import combinations
total_test_cases= int(sys.stdin.readline())
for _ in range(total_test_cases):
found = False
string_one = sys.stdin.readline().strip()
string_two = sys.stdin.readline().strip()
for i in string_two:
if i in string_one:
print("Yes")
found = True
break
if found == False:
print("No")
|
Given is a positive integer N. Consider repeatedly applying the operation below on N:
* First, choose a positive integer z satisfying all of the conditions below:
* z can be represented as z=p^e, where p is a prime number and e is a positive integer;
* z divides N;
* z is different from all integers chosen in previous operations.
* Then, replace N with N/z.
Find the maximum number of times the operation can be applied.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
Print the maximum number of times the operation can be applied.
Examples
Input
24
Output
3
Input
1
Output
0
Input
64
Output
3
Input
1000000007
Output
1
Input
997764507000
Output
7
|
import java.util.*;
import java.util.function.*;
import java.lang.*;
import java.io.*;
class MathLib{
static long gcd(long a, long b){
if(a<0) a = -a;
if(b<0) b = -b;
if(a>b){
long t = a;
a = b;
b = t;
}
while(a>0){
long r = b%a;
b = a;
a = r;
}
return b;
}
static boolean isPrime(long N){
if(N%2==0) return false;
for(long i=3; i*i<=N; i+=2){
if(N%i==0) return false;
}
return true;
}
static Counter<Long> factorize(long N){
Counter<Long> ans = new Counter<>();
while(N%2==0){
ans.addOne(2L);
N /= 2;
}
for(long i=3; i*i<=N; i+=2){
while(N%i==0){
ans.addOne(i);
N /= i;
}
}
if(N>1) ans.addOne(N);
return ans;
}
static List<Integer> primeList(int max){
boolean[] prime = new boolean[max+1];
Arrays.fill(prime, true); prime[0]=false; prime[1]=false;
ArrayList<Integer> list = new ArrayList<>();
for(int n=2; n<=max; n++) if(prime[n]){
list.add(n);
if(n*n<=max) for(int m=2*n; m<=max; m+=n) prime[m]=false;
}
return list;
}
}
class Counter<T> extends TreeMap<T,Long>{
public Counter(){
super();
}
public Counter(List<T> list){
super();
for(T e: list) this.addOne(e);
}
public Long count(Object elm){
return getOrDefault(elm,0L);
}
public void add(T elm, long amount){
if(!this.containsKey(elm)) put(elm, amount);
else replace(elm, get(elm)+amount);
if(this.count(elm)==0) this.remove(elm);
}
public void addOne(T elm){
this.add(elm, 1);
}
public void removeOne(T elm){
this.add(elm, -1);
}
public void removeAll(T elm){
this.add(elm, this.count(elm));
}
public static<T> Counter<T> merge(Counter<T> a, Counter<T> b){
Counter<T> c = new Counter<>();
for(T x: a.keySet()) c.add(x, a.count(x));
for(T y: b.keySet()) c.add(y, b.count(y));
return c;
}
}
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long N = sc.nextLong();
Counter<Long> factorize = MathLib.factorize(N);
long ans = 0;
for(long d: factorize.keySet()){
long k = factorize.count(d);
for(int i=1;;i++){
if(k<i) break;
k -= i;
ans++;
}
}
System.out.println(ans);
}
}
|
Takahashi is participating in a programming contest, AXC001. He has just submitted his code to Problem A.
The problem has N test cases, all of which must be passed to get an AC verdict.
Takahashi's submission has passed M cases out of the N test cases.
Determine whether Takahashi's submission gets an AC.
Constraints
* 1 \leq N \leq 100
* 0 \leq M \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
If Takahashi's submission gets an AC, print `Yes`; otherwise, print `No`.
Examples
Input
3 3
Output
Yes
Input
3 2
Output
No
Input
1 1
Output
Yes
|
import java.util.*;
class Main
{
public static void main(String args[])
{
Scanner sc = new Scanner(System.in);
int m=sc.nextInt();
int n=sc.nextInt();
if(m==n) System.out.println("Yes");
else System.out.println("No");
}
}
|
N players will participate in a tennis tournament. We will call them Player 1, Player 2, \ldots, Player N.
The tournament is round-robin format, and there will be N(N-1)/2 matches in total. Is it possible to schedule these matches so that all of the following conditions are satisfied? If the answer is yes, also find the minimum number of days required.
* Each player plays at most one matches in a day.
* Each player i (1 \leq i \leq N) plays one match against Player A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} in this order.
Constraints
* 3 \leq N \leq 1000
* 1 \leq A_{i, j} \leq N
* A_{i, j} \neq i
* A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} are all different.
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} \ldots A_{1, N-1}
A_{2, 1} A_{2, 2} \ldots A_{2, N-1}
:
A_{N, 1} A_{N, 2} \ldots A_{N, N-1}
Output
If it is possible to schedule all the matches so that all of the conditions are satisfied, print the minimum number of days required; if it is impossible, print `-1`.
Examples
Input
3
2 3
1 3
1 2
Output
3
Input
4
2 3 4
1 3 4
4 1 2
3 1 2
Output
4
Input
3
2 3
3 1
1 2
Output
-1
|
n=int(input());l=[list(map(int,input().split()))for i in[0]*n];a=[0]*n;d=1;k=n*(n-1)
while sum(a)<k and d<9999:
L=[0]*n;y=0;d+=1
for i in range(n):
if a[i]<n-1:
x=l[i][a[i]]-1
if l[x][a[x]]-1==i and L[x]+L[i]<1:
a[i]+=1;a[x]+=1;L[i]=L[x]=y=1
d*=y;print([k//2,d-1][d<9999])
|
There are N gems. The value of the i-th gem is V_i.
You will choose some of these gems, possibly all or none, and get them.
However, you need to pay a cost of C_i to get the i-th gem.
Let X be the sum of the values of the gems obtained, and Y be the sum of the costs paid.
Find the maximum possible value of X-Y.
Constraints
* All values in input are integers.
* 1 \leq N \leq 20
* 1 \leq C_i, V_i \leq 50
Input
Input is given from Standard Input in the following format:
N
V_1 V_2 ... V_N
C_1 C_2 ... C_N
Output
Print the maximum possible value of X-Y.
Examples
Input
3
10 2 5
6 3 4
Output
5
Input
4
13 21 6 19
11 30 6 15
Output
6
Input
1
1
50
Output
0
|
n = int(input())
Vi = map(int, input().split())
Ci = map(int, input().split())
print(sum([max(0, v-c) for (v, c) in zip(Vi, Ci)]))
|
Takahashi's office has N rooms. Each room has an ID from 1 to N. There are also N-1 corridors, and the i-th corridor connects Room a_i and Room b_i. It is known that we can travel between any two rooms using only these corridors.
Takahashi has got lost in one of the rooms. Let this room be r. He decides to get back to his room, Room 1, by repeatedly traveling in the following manner:
* Travel to the room with the smallest ID among the rooms that are adjacent to the rooms already visited, but not visited yet.
Let c_r be the number of travels required to get back to Room 1. Find all of c_2,c_3,...,c_N. Note that, no matter how many corridors he passes through in a travel, it still counts as one travel.
Constraints
* 2 \leq N \leq 2\times 10^5
* 1 \leq a_i,b_i \leq N
* a_i \neq b_i
* The graph given as input is a tree.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
Print c_r for each r, in the following format:
c_2 c_3 ... c_N
Output
Print c_r for each r, in the following format:
c_2 c_3 ... c_N
Examples
Input
6
1 5
5 6
6 2
6 3
6 4
Output
5 5 5 1 5
Input
6
1 2
2 3
3 4
4 5
5 6
Output
1 2 3 4 5
Input
10
1 5
5 6
6 10
6 4
10 3
10 8
8 2
4 7
4 9
Output
7 5 3 1 3 4 7 4 5
|
#include<stdio.h>
#include<vector>
#define MaxN 200000+100
using namespace std;
int sum[MaxN];
vector<int>arr[MaxN];
int flag[MaxN];
int dfs2(int now,int limit_d,int limit_u)
{
if(now>limit_u || now<limit_d)
{
return 0;
}
// printf(" ----%d",now);
flag[now]=2;
int sum=1;
for(int i=0;i<arr[now].size();i++)
if(flag[arr[now][i]]==0)
sum+=dfs2(arr[now][i],limit_d,limit_u);
flag[now]=0;
return sum;
}
void dfs(int fa,int now,int max,int second,bool f)
{
// printf("%d %d %d ",now,second,max);
flag[now]=1;
if(now<max)
{
// printf("1.");
sum[now]=sum[fa];
int a,b;
a=b=0;
if(f==true)
{
a=dfs2(now,-1,max);
b=dfs2(now,-1,second);
flag[now]=1;
sum[now]+=a-b;
f=false;
}
}
else
{
// printf("2.");
for(int i=0;i<arr[now].size();i++)
{
if(flag[arr[now][i]]==0)
{
sum[now]+=dfs2(arr[now][i],-1,max);
}
}
sum[now]+=sum[fa]+1;
second=max;
max=now;
f=true;
}
// printf(" %d\n",sum[now]);
for(int i=0;i<arr[now].size();i++)
if(flag[arr[now][i]]!=1)
dfs(now,arr[now][i],max,second,f);
}
int main()
{
int N;
scanf("%d",&N);
for(int i=0;i<N-1;i++)
{
int a,b;
scanf("%d %d",&a,&b);
arr[a].push_back(b);
arr[b].push_back(a);
}
flag[1]=1;
sum[1]=1;
for(int i=0;i<=arr[1].size();i++)
dfs(1,arr[1][i],1,0,true);
for(int i=2;i<=N;i++)
{
if(i!=2)
printf(" ");
printf("%d",sum[i]-1);
}
return 0;
}
|
Three people, A, B and C, are trying to communicate using transceivers. They are standing along a number line, and the coordinates of A, B and C are a, b and c (in meters), respectively. Two people can directly communicate when the distance between them is at most d meters. Determine if A and C can communicate, either directly or indirectly. Here, A and C can indirectly communicate when A and B can directly communicate and also B and C can directly communicate.
Constraints
* 1 β€ a,b,c β€ 100
* 1 β€ d β€ 100
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
a b c d
Output
If A and C can communicate, print `Yes`; if they cannot, print `No`.
Examples
Input
4 7 9 3
Output
Yes
Input
100 10 1 2
Output
No
Input
10 10 10 1
Output
Yes
Input
1 100 2 10
Output
Yes
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d;
int main() {
cin >> a >> b >> c >> d;
cout << (abs(c-a)<=d || (abs(a-b)<=d && abs(b-c)<=d) ? "Yes" : "No") << endl;
}
|
You are given two strings s and t consisting of lowercase English letters and an integer L.
We will consider generating a string of length L by concatenating one or more copies of s and t. Here, it is allowed to use the same string more than once.
For example, when s = `at`, t = `code` and L = 6, the strings `atatat`, `atcode` and `codeat` can be generated.
Among the strings that can be generated in this way, find the lexicographically smallest one. In the cases given as input, it is always possible to generate a string of length L.
Constraints
* 1 β€ L β€ 2 Γ 10^5
* 1 β€ |s|, |t| β€ L
* s and t consist of lowercase English letters.
* It is possible to generate a string of length L in the way described in Problem Statement.
Input
Input is given from Standard Input in the following format:
N
x_1 s_1
x_2 s_2
:
x_N s_N
Output
Print the lexicographically smallest string among the ones that can be generated in the way described in Problem Statement.
Examples
Input
6
at
code
Output
atatat
Input
8
coding
festival
Output
festival
Input
8
same
same
Output
samesame
Input
10
coin
age
Output
ageagecoin
|
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<functional>
#include<vector>
#include<queue>
using namespace std;
#define f(i,n) for(int i=0;i<(int)n;i++)
#define MOD 1000000009
int main(void){
char a[200001];
char b[200001];
f(i, 200001){
a[i] = 0;
b[i] = 0;
}
int n, k;
int p, q;
int x, y;
int z = 0;
scanf("%d", &n);
scanf("%s", a);
scanf("%s", b);
p = strlen(a);
q = strlen(b);
f(i, n){
x = i % p;
y = i % q;
if (a[x] != b[y]){
if (a[x] > b[y])z = 1;
break;
}
}
k = n;
if (z == 0){
while (z == 0){
if (k%p == 0){
z = 2;
for (int i = 0; i < k / p; i++){
for (int j = 0; j<p; j++)printf("%c", a[j]);
}
for (int i = 0; i < (n - k) / q; i++){
for (int j = 0; j<q; j++)printf("%c", b[j]);
}
}
k -= q;
}
}
else{
while (z == 1){
if (k%q == 0){
z = 2;
for (int i = 0; i < k / q; i++){
for (int j = 0; j<q; j++)printf("%c", b[j]);
}
for (int i = 0; i < (n - k) / p; i++){
for (int j = 0; j<p; j++)printf("%c", a[j]);
}
}
k -= p;
}
}
return 0;
}
|
We will call a string that can be obtained by concatenating two equal strings an even string. For example, `xyzxyz` and `aaaaaa` are even, while `ababab` and `xyzxy` are not.
You are given an even string S consisting of lowercase English letters. Find the length of the longest even string that can be obtained by deleting one or more characters from the end of S. It is guaranteed that such a non-empty string exists for a given input.
Constraints
* 2 \leq |S| \leq 200
* S is an even string consisting of lowercase English letters.
* There exists a non-empty even string that can be obtained by deleting one or more characters from the end of S.
Input
Input is given from Standard Input in the following format:
S
Output
Print the length of the longest even string that can be obtained.
Examples
Input
abaababaab
Output
6
Input
xxxx
Output
2
Input
abcabcabcabc
Output
6
Input
akasakaakasakasakaakas
Output
14
|
#include <bits/stdc++.h>
using namespace std;
char s[210];
int main()
{
scanf("%s", s);
int x = strlen(s);
for (int i = (x - 1) / 2 - 1; i >= 0; i--) {
if (!strncmp(s, s + i + 1, i + 1)) {
printf("%d\n", 2 * (i + 1));
break;
}
}
}
|
You have an integer variable x. Initially, x=0.
Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`.
Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).
Constraints
* 1β€Nβ€100
* |S|=N
* No characters except `I` and `D` occur in S.
Input
The input is given from Standard Input in the following format:
N
S
Output
Print the maximum value taken by x during the operations.
Examples
Input
5
IIDID
Output
2
Input
7
DDIDDII
Output
0
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
String S = sc.next();
int max = 0;
int x = 0;
for(int i = 0 ; i < N ; i++) {
if(S.charAt(i) == 'I') {
x++;
max = Math.max(max, x);
} else if(S.charAt(i) == 'D') {
x--;
}
}
System.out.println(max);
}
}
|
Mr. Takahashi has a string s consisting of lowercase English letters. He repeats the following operation on s exactly K times.
* Choose an arbitrary letter on s and change that letter to the next alphabet. Note that the next letter of `z` is `a`.
For example, if you perform an operation for the second letter on `aaz`, `aaz` becomes `abz`. If you then perform an operation for the third letter on `abz`, `abz` becomes `aba`.
Mr. Takahashi wants to have the lexicographically smallest string after performing exactly K operations on s. Find the such string.
Constraints
* 1β€|s|β€10^5
* All letters in s are lowercase English letters.
* 1β€Kβ€10^9
Input
The input is given from Standard Input in the following format:
s
K
Output
Print the lexicographically smallest string after performing exactly K operations on s.
Examples
Input
xyz
4
Output
aya
Input
a
25
Output
z
Input
codefestival
100
Output
aaaafeaaivap
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
char[] input = sc.next().toCharArray();
int k = sc.nextInt();
int index = 0;
while(k > 0 && index < input.length){
int diff = input[index] - 'a';
if(diff == 0){
}else if(diff + k >= 26){
input[index] = 'a';
k = k - (26 - diff);
}
index += 1;
}
index = input.length - 1;
input[index] = (char) (((input[index] - 'a' + k) % 26) + 'a');
String result = new String(input);
System.out.println(result);
}
}
|
<image>
You know the merry-go-round in the amusement park. Vehicles such as horses and carriages are fixed on a large disk, and it is a standard playset that the vehicle swings up and down at the same time as the disk rotates. A merry-go-round in an amusement park has two four-seater carriages, two two-seater cars, four one-seater horses, and a total of eight vehicles in the order shown in Figure 1. .. Customers at the amusement park are waiting somewhere between platforms 0 and 7 shown in Fig. 1.
<image>
The merry-go-round in this amusement park always stops where the vehicle fits snugly into the landing. And the customers waiting in each of 0 to 7 are supposed to get on the vehicle that stopped in front of them. You cannot hurry to another platform and board from there. In order for customers to enjoy themselves efficiently, we must adjust the stop position of the merry-go-round to minimize the number of passengers who cannot ride.
Create a program that reads the number of passengers waiting at platform 0-7 and outputs which vehicle should stop at which position to reduce the number of passengers who cannot get on.
input
The input consists of multiple datasets. Each dataset is given in the following format:
p0 p1 p2 p3 p4 p5 p6 p7
Integers p0, p1, ..., p7 (0 β€ pi β€ 10,000) are given on one line, separated by blanks, to represent the number of passengers waiting at platform 0, 1, ..., 7.
output
Let's assume that the carriage of a merry-go-round vehicle is represented by 4, the car is represented by 2, and the horse is represented by 1. The vehicles that stop at platform 0, 1, ..., 7 are c0, c1, ..., c7, respectively. Prints c0, c1, ..., c7 on a single line, separated by blanks, for each dataset.
If there are multiple ways to minimize the number of passengers who cannot ride, c0c1c2c3c4c5c6c7 shall be regarded as an 8-digit integer V, and the method to minimize V shall be selected.
The number of datasets does not exceed 100.
Example
Input
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
Output
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int p[8];
int c[8] = {4, 1, 2, 1, 2, 1, 4, 1};
int temp[10];
int ans[10];
while(cin >> p[0] >> p[1] >> p[2] >> p[3] >> p[4] >> p[5] >> p[6] >> p[7]) {
memset(ans, 0, sizeof(ans));
ans[8] = -1;
for(int i = 0; i < 8; ++i) {
int digit = 10000000;
memset(temp, 0, sizeof(temp));
for(int j = 0; j < 8; ++j) {
int pos = (i + j) % 8;
if(p[j] >= c[pos]) {
temp[j] = c[pos];
} else {
temp[j] = p[j];
}
temp[8] += temp[j];
temp[9] += c[pos] * digit;
digit /= 10;
}
if(temp[8] > ans[8]) {
for(int i = 0; i < 10; ++i) {
ans[i] = temp[i];
}
} else if(temp[8] == ans[8]) {
if(temp[9] < ans[9]) {
for(int i = 0; i < 10; ++i) {
ans[i] = temp[i];
}
}
}
}
for(int i = 10000000; i >= 10; i /= 10) {
cout << (ans[9] / i) << " ";
ans[9] %= i;
}
cout << ans[9] << endl;
}
}
|
In Square Town, where many people who love squares live, a festival is held to color the town with illuminations that combine square lightning boards. This electric board emits light when electricity is applied, and the plate in contact with the light emitting plate also emits light. Therefore, no matter how many electric boards you use, if all of them are in contact with each other, you only need one power supply.
The festival executive committee will solicit designs that combine squares from the townspeople and create a large number of illuminations. For each illumination, the number of power supplies required varies depending on the arrangement of the squares that make up the design, so it takes a lot of time and effort to figure out the number of power supplies required. So you decided to look at the arrangement of the rectangles and write a program to help the executive committee calculate the number of power supplies needed.
<image>
Create a program that inputs the number of illuminations and the information of the rectangles that make up each illumination, and outputs the number of power supplies required for each illumination. Think of the overlapping and touching rectangles as a group, and count the number of power supplies as one for each group.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
M1
xa1 ya1 xb1 yb1 xc1 yc1 xd1 yd1
xa2 ya2 xb2 yb2 xc2 yc2 xd2 yd2
::
xaM1 yaM1 xbM1 ybM1 xcM1 ycM1 xdM1 ydM1
M2
::
::
MN
::
::
The number of illuminations N (1 β€ N β€ 100) is given on the first line. Then, information on N illuminations is given. As the i-th illumination information, the number of rectangles Mi (1 β€ Mi β€ 100) that make up the illumination is given in one line. The following Mi line is given the jth quadrangle vertex xaj, yaj, xbj, ybj, xcj, ycj, xdj, ydj (integer between -1000 and 1000).
The coordinates of the vertices of the rectangle entered are entered in a clockwise order. However, all the input data rectangles are convex rectangles.
The number of datasets does not exceed 10.
Output
Outputs the number of power supplies required for each illumination for each input dataset. Follow the order in which each illumination was input for the number of power supplies to be output.
Example
Input
3
1
0 0 0 1 1 1 1 0
2
0 0 0 1 1 1 1 0
100 100 100 200 200 200 200 100
2
0 0 0 100 100 100 100 0
10 10 10 20 20 20 20 10
2
1
30 40 40 50 40 20 20 10
1
30 40 40 50 40 20 20 10
0
Output
1
2
1
1
1
|
#include <iostream>
#include <iomanip>
#include <complex>
#include <vector>
#include <algorithm>
#include <cmath>
#include <array>
using namespace std;
const double EPS = 1e-10;
const double INF = 1e12;
#define EQ(n,m) (abs((n)-(m)) < EPS)
#define X real()
#define Y imag()
typedef complex<double> P;
typedef vector<P> VP;
struct L : array<P, 2>{
L(const P& a, const P& b){ at(0)=a; at(1)=b; }
L(){}
};
double dot(P a, P b){
return (conj(a)*b).X;
}
double cross(P a, P b){
return (conj(a)*b).Y;
}
int ccw(P a, P b, P c){
b -= a;
c -= a;
if(cross(b,c) > EPS) return +1; //ccw
if(cross(b,c) < -EPS) return -1; //cw
if(dot(b,c) < -EPS) return +2; //c-a-b
if(abs(c)-abs(b) > EPS) return -2; //a-b-c
return 0; //a-c-b
}
bool intersectSS(const L& a, const L& b){
return ( ccw(a[0],a[1],b[0]) *ccw(a[0],a[1],b[1]) <= 0 ) &&
( ccw(b[0],b[1],a[0]) *ccw(b[0],b[1],a[1]) <= 0 );
}
bool intersectSP(const L& s, const P &p){
return abs(cross(s[0]-p, s[1]-p))<EPS && dot(s[0]-p, s[1]-p)<EPS;
}
int in_poly(const P &p, const VP &poly){
int n = poly.size();
int ret = -1;
for(int i=0; i<n; i++){
P a = poly[i]-p;
P b = poly[(i+1)%n]-p;
if(a.Y > b.Y) swap(a,b);
if(intersectSP(L(a,b), P(0,0))) return 0;
if(a.Y<=0 && b.Y>0 && cross(a,b)<0) ret = -ret;
}
return ret;
}
void dfs(int v, vector<bool> &used, vector<vector<int> > &adj){
if(used[v]) return;
used[v] = true;
for(int nv: adj[v]){
dfs(nv, used, adj);
}
}
int main(){
while(1){
int n;
cin >> n;
if(n==0) break;
for(int rep=0; rep<n; rep++){
int m;
cin >> m;
vector<VP> sq(m, VP(4));
for(int i=0; i<m; i++){
for(int j=0; j<4; j++){
int x,y;
cin >> x >> y;
sq[i][j] = P(x, y);
}
swap(sq[i][0], sq[i][3]);
swap(sq[i][1], sq[i][2]);
}
vector<vector<int> > adj(m);
for(int i=0; i<m; i++){
for(int j=i+1; j<m; j++){
bool overlap = false;
for(int k=0; k<4; k++){
if(in_poly(sq[i][k], sq[j]) >= 0 || in_poly(sq[j][k], sq[i]) >= 0){
overlap = true;
}
for(int l=0; l<4; l++){
if(intersectSS(L(sq[i][k], sq[i][(k+1)%4]), L(sq[j][l], sq[j][(l+1)%4]))){
overlap = true;
}
}
}
if(overlap){
adj[i].push_back(j);
adj[j].push_back(i);
}
}
}
vector<bool> used(m, false);
int count = 0;
for(int i=0; i<m; i++){
if(used[i]) continue;
dfs(i, used, adj);
count++;
}
cout << count << endl;
}
}
return 0;
}
|
A boy PCK had N straight iron bars, which were serially indexed. Unfortunately, the first M bars (0 β€ M β€ N) among them were bent during transportation. They all suffered a perpendicular bend at one point.
He is planning to make a cube using a set of bars selected using the following rules: X bars from bent ones, Y bars from straight ones, where 2X + Y = 12. Any two bars can be jointed only at the apexes of the cube. He wants to count how many types of rectangular parallelepipeds (hereafter RP) he can make using these bars.
Make a program to count out types (different shapes) of RPs that PCK can make using the following information: the number of bars and length of each one, position of the bend, and the number of bars to be used to construct an RP. Note that any two RPs similar in shape are considered identical: namely if the length of three defining sides of two RPs coincide if arranged in increasing/decreasing order (e.g., three sides of RP i and j are A_i, B_i, C_i, and A_j, B_j and C_j in increasing order, then the relations A_i = A_j, B_i = B_j, and C_i = C_j hold. Note also that the bars are sufficiently thin to allow you to consider them as idealized lines.
Input
The input is given in the following format.
N M X Y
a_1
a_2
:
a_N
b_1
b_2
:
b_M
The first line provides the total number of iron bars and bent bars, and those straight and bent bars used to construct an RP: N (6 β€ N β€ 6000), M (0 β€ M β€ N), X (0 β€ X β€ 6), and Y (0 β€ Y β€ 12). The following relations always hold for them: 2X+Y=12, X+Y β€ N, X β€ M. Each of the subsequent N lines provides the length of the i-th bar a_i (1 β€ a_i β€ 6000) in integers. Furthermore, each of the subsequent M lines provides the location at which the i-th bent bar suffered a perpendicular bend b_i (1 β€ b_i β€ 3000) in centimeters from one end of the bar (note: 1 β€ a_i-b_i β€ 3000).
Output
Output the number of constructible rectangular parallelepipeds.
Example
Input
18 8 3 6
4
3
3
3
3
2
2
2
1
1
1
1
1
2
2
3
3
3
1
1
1
1
1
1
1
1
Output
3
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int a[6001][6001],b[6001];
int n,m,x,y,mn;
unordered_set<ll> st;
bool check(int A,int B,int C){
for(int i=0;i<=min(mn,a[A][B]);i++)
for(int j=0;i+j<=min(mn,a[B][C]+i);j++){
int k=x-i-j;
if(i+k>4||j+k>4||a[A][C]<k)continue;
if(A==C&&(a[A][A]<x||b[A]<12-2*(i+j+k)))continue;
if(A==B&&(a[A][C]<j+k||b[A]<8-(2*i+j+k)))continue;
if(B==C&&(a[A][B]<i+k||b[B]<8-(i+2*j+k)))continue;
if(b[A]>=4-i-k&&b[B]>=4-i-j&&b[C]>=4-j-k)return 1;
}
return 0;
}
int main(){
int t[6000],v[6000];
cin>>n>>m>>x>>y;
for(int i=0;i<n;i++){
cin>>t[i];
if(i>=m)b[t[i]]++;
}
for(int i=0;i<m;i++){
cin>>v[i];
int p=t[i]-v[i];
if(v[i]>p)swap(v[i],p);
a[v[i]][p]++;
}
if(x){
ll M=6001;
mn=min(4,x);
for(int i=0;i<m;i++)
for(int j=1;j<=6000;j++){
ll p1=v[i],p2=t[i]-v[i],p3=j;
if(p2>p3)swap(p2,p3);
if(p1>p2)swap(p1,p2);
ll s=p1*M*M+p2*M+p3;
if(!st.count(s)&&check(p1,p2,p3))st.insert(s);
}
cout<<st.size()<<endl;
}
else{
ll c4=0,c8=0,c12=0;
for(int i=1;i<=6000;i++){
if(b[i]>=4)c4++;
if(b[i]>=8)c8++;
if(b[i]>=12)c12++;
}
cout<<c4*(c4-1)*(c4-2)/6+c8*(c4-1)+c12<<endl;
}
return 0;
}
|
In the advanced algorithm class, n2 students sit in n rows and n columns. One day, a professor who teaches this subject comes into the class, asks the shortest student in each row to lift up his left hand, and the tallest student in each column to lift up his right hand. What is the height of the student whose both hands are up ? The student will become a target for professorβs questions.
Given the size of the class, and the height of the students in the class, you have to print the height of the student who has both his hands up in the class.
Input
The input will consist of several cases. the first line of each case will be n(0 < n < 100), the number of rows and columns in the class. It will then be followed by a n-by-n matrix, each row of the matrix appearing on a single line. Note that the elements of the matrix may not be necessarily distinct. The input will be terminated by the case n = 0.
Output
For each input case, you have to print the height of the student in the class whose both hands are up. If there is no such student, then print 0 for that case.
Example
Input
3
1 2 3
4 5 6
7 8 9
3
1 2 3
7 8 9
4 5 6
0
Output
7
7
|
#include<iostream>
#include<algorithm>
using namespace std;
int n;
int t[100][100];
int u[100],v[100];
void solve(){
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(u[i]!=v[j])continue;
cout<<t[i][j]<<endl;
return;
}
}
cout<<0<<endl;
}
int main(){
while(cin>>n&&n){
for(int i=0;i<n;i++){
u[i]=1e8;v[i]=-1;
for(int j=0;j<n;j++){
cin>>t[i][j];
}
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
u[i]=min(u[i],t[i][j]);
v[j]=max(v[j],t[i][j]);
}
}
solve();
}
return 0;
}
|
<image>
The International Clown and Pierrot Competition (ICPC), is one of the most distinguished and also the most popular events on earth in the show business.
One of the unique features of this contest is the great number of judges that sometimes counts up to one hundred. The number of judges may differ from one contestant to another, because judges with any relationship whatsoever with a specific contestant are temporarily excluded for scoring his/her performance.
Basically, scores given to a contestant's performance by the judges are averaged to decide his/her score. To avoid letting judges with eccentric viewpoints too much influence the score, the highest and the lowest scores are set aside in this calculation. If the same highest score is marked by two or more judges, only one of them is ignored. The same is with the lowest score. The average, which may contain fractions, are truncated down to obtain final score as an integer.
You are asked to write a program that computes the scores of performances, given the scores of all the judges, to speed up the event to be suited for a TV program.
Input
The input consists of a number of datasets, each corresponding to a contestant's performance. There are no more than 20 datasets in the input.
A dataset begins with a line with an integer n, the number of judges participated in scoring the performance (3 β€ n β€ 100). Each of the n lines following it has an integral score s (0 β€ s β€ 1000) marked by a judge. No other characters except for digits to express these numbers are in the input. Judges' names are kept secret.
The end of the input is indicated by a line with a single zero in it.
Output
For each dataset, a line containing a single decimal integer indicating the score for the corresponding performance should be output. No other characters should be on the output line.
Example
Input
3
1000
342
0
5
2
2
9
11
932
5
300
1000
0
200
400
8
353
242
402
274
283
132
402
523
0
Output
342
7
300
326
|
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(true){
int n = sc.nextInt();
if(n==0)break;
int[] p = new int[n];
int sum = 0;
for(int i=0;i<n;i++){
p[i] = sc.nextInt();
sum += p[i];
}
Arrays.sort(p);
sum = (sum-p[0]-p[n-1])/(n-2);
System.out.println(sum);
}
}
}
|
A long time ago in a galaxy, far, far away, there were N spheres with various radii. Spheres were mirrors, that is, they had reflective surfaces . . . .
You are standing at the origin of the galaxy (0, 0, 0), and emit a laser ray to the direction (u,v, w). The ray travels in a straight line.
When the laser ray from I hits the surface of a sphere at Q, let N be a point outside of the sphere on the line connecting the sphere center and Q. The reflected ray goes to the direction towards R that satisfies the following conditions: (1) R is on the plane formed by the three points I, Q and N , (2) β IQN = β NQR, as shown in Figure 1.
<image>
---
Figure 1: Laser ray reflection
After it is reflected several times, finally it goes beyond our observation. Your mission is to write a program that identifies the last reflection point.
Input
The input consists of multiple datasets, each in the following format.
N
u v w
x1 y1 z1 r1
.
.
.
xN yN zN rN
The first line of a dataset contains a positive integer N which is the number of spheres. The next line contains three integers u, v and w separated by single spaces, where (u, v, w) is the direction of the laser ray initially emitted from the origin.
Each of the following N lines contains four integers separated by single spaces. The i-th line corresponds to the i-th sphere, and the numbers represent the center position (xi, yi, zi ) and the radius ri .
N, u, v, w, xi, yi, zi and ri satisfy the following conditions.
1 β€ N β€ 100
β100 β€ u, v, w β€ 100
β100 β€ xi, yi, zi β€ 100
5 β€ ri β€ 30
u2 + v2 + w2 > 0
You can assume that the distance between the surfaces of any two spheres is no less than 0.1. You can also assume that the origin (0, 0, 0) is located outside of any sphere, and is at least 0.1 distant from the surface of any sphere.
The ray is known to be reflected by the sphere surfaces at least once, and at most five times. You can assume that the angle between the ray and the line connecting the sphere center and the reflection point, which is known as the angle of reflection (i.e. ΞΈ in Figure 1), is less than 85 degrees for each point of reflection.
The last dataset is followed by a line containing a single zero.
Output
For each dataset in the input, you should print the x-, y- and z-coordinates of the last reflection point separated by single spaces in a line. No output line should contain extra characters.
No coordinate values in the output should have an error greater than 0.01.
Example
Input
3
-20 -20 -24
100 100 100 30
10 8 3 5
-70 -70 -84 5
4
0 47 84
-23 41 42 8
45 -10 14 19
-5 28 47 12
-27 68 34 14
0
Output
79.0940 79.0940 94.9128
-21.8647 54.9770 34.1761
|
#include <bits/stdc++.h>
#define double long double
using namespace std;
const double EPS = 1e-8;
const double INF = 1e9;
struct p3{
double x,y,z,r;
p3(){x=y=z=r=0;}
p3(double x,double y,double z):x(x),y(y),z(z){};
p3(double x,double y,double z,double r):x(x),y(y),z(z),r(r){};
p3 operator + (const p3 a)const {return p3(x+a.x,y+a.y,z+a.z,r);}
p3 operator - (const p3 a)const {return p3(x-a.x,y-a.y,z-a.z,r);}
p3 operator * (const double a)const{return p3(x*a,y*a,z*a,r);}
p3 operator / (const double a)const{return p3(x/a,y/a,z/a,r);}
bool operator == (const p3 a)const {return abs(x-a.x)<EPS&&abs(y-a.y)<EPS&&abs(z-a.z)<EPS;}
double Abs()const{return sqrt(x*x+y*y+z*z);}
double dis(const p3 a)const{return sqrt((a.x-x)*(a.x-x)+(a.y-y)*(a.y-y)+(a.z-z)*(a.z-z));}
};
double dot(p3 a,p3 b){return a.x*b.x+a.y*b.y+a.z*b.z;}
struct L3{
p3 s,t;
L3(){s=t=p3();}
L3(p3 s,p3 t):s(s),t(t){};
bool operator == (const L3 a)const{return s==a.s&&t==a.t;}
};
L3 getRay(L3 a,p3 b){
a.t = a.t-a.s;
b = b-a.s;
p3 e = a.t / a.t.Abs();
p3 s = e*dot(e,b); //|b|cosx = a*b/|a|
double d = s.dis(b);
if(dot(e,b)<EPS||d>b.r+EPS)return L3();
s = e * (s.Abs()-sqrt(b.r*b.r-d*d));
p3 n = (b-s)/(b-s).Abs(); //??????????????????
n = n*dot(a.t*(-1),n)*2; //??????????????????????Β°???Β±
p3 t = a.t+n+s;
return L3(s+a.s,t+a.s);
}
int n;
vector<p3> A;
p3 calc(L3 ray){
while(1){
double mn = INF;
L3 nray;
for(int i=0;i<n;i++){
L3 res = getRay(ray,A[i]);
double dis = ray.s.dis(res.s);
if(res==L3())continue;
if(mn>dis) mn=dis,nray = res;
}
if(mn==INF) return ray.s;
ray = nray;
}
}
int main(){
while(cin>>n,n){
L3 start;
cin>>start.t.x>>start.t.y>>start.t.z;
A.resize(n);
for(int i=0;i<n;i++)cin>>A[i].x>>A[i].y>>A[i].z>>A[i].r;
p3 ans = calc(start);
printf("%Lf %Lf %Lf\n",ans.x,ans.y,ans.z);
}
return 0;
}
|
Problem
I started a part-time job at the rental DVD shop "NEO". First of all, I decided to study the fee system of this store.
There are three types of rental DVDs, old, semi-new, and new, and the rental fee for one DVD is a yen, b yen, and c yen, respectively. The set rental shown below can be applied multiple times at the time of accounting.
* Select a few DVDs for which set rental has not yet been applied.
* If the number of selected DVDs is d or more, the total price of the selected DVDs exceeds (the number of selected DVDs) * e yen, rent them for (the number of selected DVDs) * e yen. You can.
* If the number of selected DVDs is less than d, and the total price of the selected DVDs exceeds d * e yen, you can rent them for d * e yen.
* If the above does not apply, the selected DVD will be rented at the regular rate.
Here I noticed a problem. The set rental is not applied automatically when you go to the cash register, but is applied manually. This may result in the application of suboptimal set rentals (which can be cheaper). This can lead to complaints. I hate complaints, so I decided to create a program that calculates the price when the set rental is optimally applied.
Constraints
The input satisfies the following conditions.
* All values ββcontained in the input are integers
* 0 <a <b <e <c β€ 1000
* 0 <d β€ 100000
* 0 β€ na, nb, nc β€ 100000
* 0 <na + nb + nc
* No more than 100 datasets
Input
The input consists of multiple datasets. Each dataset is represented below. The first line is given five integers a, b, c, d, e separated by spaces. The number of rentals is given on the second line. The three integers na, nb, nc are given separated by spaces. Represents the number of old, semi-new, and new DVDs, respectively. The end of the input consists of 5 zeros.
a b c d e
na nb nc
Output
For each dataset, output the charge when the set rental is optimally applied on one line.
Example
Input
70 100 340 4 200
1 1 4
70 100 340 4 200
0 1 3
70 100 340 4 200
1 1 2
0 0 0 0 0
Output
970
800
800
|
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
typedef basic_string<int> IS;
int main(){
for(int a,b,c,d,e,na,nb,nc;cin>>a>>b>>c>>d>>e>>na>>nb>>nc,a;){
IS is=IS(nc,c)+IS(nb,b)+IS(na,a);
int m,cs=a*na+b*nb+c*nc;
m=cs;
for(int i=0;i<is.size();i++){
cs-=is[i];
m=min(m,cs+max(i+1,d)*e);
}
cout<<m<<endl;
}
}
|
Alice wants to send an email to Miku on her mobile phone.
The only buttons that can be used for input on mobile phones are number buttons. Therefore, in order to input characters, the number buttons are pressed several times to input characters. The following characters are assigned to the number buttons of the mobile phone, and the confirmation button is assigned to button 0. With this mobile phone, you are supposed to press the confirm button after you finish entering one character.
* 1:.,!? (Space)
* 2: a b c
* 3: d e f
* 4: g h i
* 5: j k l
* 6: m n o
* 7: p q r s
* 8: t u v
* 9: w x y z
* 0: Confirm button
For example, if you press button 2, button 2, or button 0, the letter changes from'a'to'b', and the confirm button is pressed here, so the letter b is output. If you enter the same number in succession, the changing characters will loop. That is, if you press button 2 five times and then button 0, the letters change from'a'β' b'β'c' β'a' β'b', and the confirm button is pressed here. 'b' is output.
You can press the confirm button when no button is pressed, but in that case no characters are output.
Your job is to recreate the message Alice created from a row of buttons pressed by Alice.
Input
The first line gives the number of test cases. Each test case is then given a string of digits up to 1024 in length in one row.
Output
Print the string of Alice's message line by line for each test case. However, you can assume that the output is one or more and less than 76 characters.
Example
Input
5
20
220
222220
44033055505550666011011111090666077705550301110
000555555550000330000444000080000200004440000
Output
a
b
b
hello, world!
keitai
|
ref = {"1":".,!? ",
"2":"abc",
"3":"def",
"4":"ghi",
"5":"jkl",
"6":"mno",
"7":"pqrs",
"8":"tuv",
"9":"wxyz"}
n = int(raw_input())
for _ in range(n):
ans = ""
inputs = map(str, raw_input().split('0'))
for i in inputs:
if len(i) > 0:
k = i[0]
ans += ref[k][(len(i) - 1) % len(ref[k])]
print ans
|
You are a programmer on the development team for new recording media. This recording medium can be randomly accessed for reading and erasing data. On the other hand, when writing data, access is always performed in order from the beginning, and only the first free space found can be written.
You have begun to build a file system for this recording medium. In this file system, data is written in order from the first free area due to the limitation of the recording medium. If another data exists in the middle of writing, the remaining data is written from the free area behind it.
Data is written in units called sectors. Sectors are assigned numbers starting from 0, which indicate their physical location on the storage medium. The sector numbers are assigned as 0, 1, 2, 3, ... In order from the beginning to the back of the storage medium.
There are three commands in the file system: write, delete, and sector reference.
Your job is to reproduce the behavior of this file system and then write a program that outputs which files are located in the target sector when the reference command is executed. In the initial state, nothing is written on the recording medium.
For example, let's look at the first example of Sample Input. The first instruction writes a file with an identifier of 0 and a size of 2. In the initial state, nothing is written to the recording medium, that is, all sectors are free areas, so writing is performed to the first two sectors, that is, the 0th sector and the 1st sector. Therefore, the storage medium after writing is as follows.
0 0 Sky Sky Sky Sky Sky Sky ...
The second instruction writes a file with the identifier 1 to the second and third sectors. The state of the storage medium after this is as follows.
0 0 1 1 Sky Sky Sky Sky ...
The third instruction deletes the file with the identifier 0. The state of the storage medium is as follows.
Sky Sky 1 1 Sky Sky Sky Sky ...
The fourth instruction writes the file with the identifier 2 to the 0th, 1st, 4th, and 5th sectors.
2 2 1 1 2 2 Sky Sky ...
The last instruction refers to the third sector. Now that you have a file with the identifier 1 in the third sector, your program should output 1.
Input
The input consists of multiple datasets. Each dataset is given in the following format.
> N
> Command1
> Command2
> ...
> CommandN
N is the number of commands executed (1 β€ N β€ 10,000), and Commandi is the i-th command to be executed.
Each command consists of a command name and one or two arguments. The command name consists of only one letter and can be either "W", "D", or "R". There is a space between the command and the argument, and between the argument and the argument.
"W" represents a write command. Two arguments I (0 β€ I β€ 109) and S (1 β€ S β€ 109) are given. Each shows the identifier of the file to write and the number of sectors required to store the file.
"D" represents the delete command. One argument I (0 β€ I β€ 109) is given. Indicates the identifier of the file to be deleted.
"R" represents the reference command. One argument P (0 β€ P β€ 109) is given. Indicates the number of the sector to be referenced.
It can be assumed that sectors with numbers higher than 109 do not need to be accessed. Also, it is guaranteed that a file with the same file identifier will not be written multiple times.
The end of the input is indicated by one line containing one 0.
Output
For each dataset, output the identifier of the file referenced by that command on a single line each time a referenced command appears. If no file has been written to the referenced sector, output -1 instead of the file identifier.
Put a blank line after each dataset.
Sample Input
6
W 0 2
W 1 2
D 0
W 2 4
R 3
R 1
1
R 1000000000
0
Output for the Sample Input
1
2
-1
Example
Input
6
W 0 2
W 1 2
D 0
W 2 4
R 3
R 1
1
R 1000000000
0
Output
1
2
-1
|
#include<map>
#include<cstdio>
using namespace std;
int main(){for(int T;~scanf("%d",&T)&&T;puts("")){
map<pair<int,int>,int>m;
char C[2];
int n,k;
for(;T--;){
scanf("%s%d",C,&n);
if(*C=='D'){
for(auto it=m.begin();it!=m.end();)if(it->second==n)m.erase(it++);else ++it;
}else if(*C=='R'){
auto it=m.lower_bound(make_pair(n,2000000000));
printf("%d\n",it==m.begin()||n<(--it)->first.first||it->first.second<n ? -1 : it->second);
}else if(*C=='W'){
int c=!scanf("%d",&k),d;
for(auto it=m.begin();k&&it!=m.end();++it){
d=it->first.first-c;
if(d>k)d=k;
if(d)m[make_pair(c,c+d-1)]=n;
k-=d;
c=it->first.second+1;
}
if(k)m.insert({{c,c+k-1},n});
}
}
}}
|
Champernowne constant is an irrational number. Its decimal representation starts with "0.", followed by concatenation of all positive integers in the increasing order.
You will be given a sequence S which consists of decimal digits. Your task is to write a program which computes the position of the first occurrence of S in Champernowne constant after the decimal point.
Input
The input has multiple test cases. Each line of the input has one digit sequence. The input is terminated by a line consisting only of #.
It is guaranteed that each sequence has at least one digit and its length is less than or equal to 100.
Output
For each sequence, output one decimal integer described above. You can assume each output value is less than 1016.
Examples
Input
45678
67891011
21
314159265358979
#
Output
4
6
15
2012778692735799
Input
45678
67891011
21
314159265358979
Output
4
6
15
2012778692735799
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <string.h>
#include <queue>
using namespace std;
#define MP(x,y) make_pair(x,y)
#define FI first
#define SE second
#define INF 1LL<<60
const int MAXN = 110;
int len;
char str[MAXN],st[MAXN];
long long ans,pos;
long long trans_stoi(int l,int r)
{
long long res=0;
for (int i=l;i<r;i++)
res=res*10+str[i]-'0';
return res;
}
void trans_itos(long long x)
{
int num=0;
int tmp[MAXN];
while (x)
{
tmp[num++]=x%10;
x/=10;
}
for (int i=0;i<num;i++)
st[i]=tmp[num-i-1]+'0';
st[num]='\0';
}
long long cal(long long ans)
{
if (ans<=0) return 0;
int num=1;
long long mul=9,p=1,res=0;
while (ans>p*10)
{
res+=num*mul;
num++;
mul*=10;
p*=10;
}
res+=(ans-p)*num;
return res;
}
void judge_0()
{
long long p=1;
for (int i=1;i<=len;i++)
{
if (str[i]!='0') return;
p*=10;
}
ans=p;
pos=2;
}
void judge_1()
{
for (int i=1;i<min(17,len);i++)
{
for (int j=1;j<=i;j++) st[j]=str[j];
st[i+1]='\0';
int add=1,l=i;
while (add&&l>0)
{
if (st[l]=='9') st[l]='0',add=1;
else st[l]=st[l]+1,add=0;
l--;
}
for (int j=max(1,2*i-len);j<=i;j++)
{
int flag=1;
for (int p=len,q=i-j;q>=1;p--,q--)
if (str[p]!=st[q])
{
flag=0;
break;
}
if (flag)
{
long long tmp=0;
if (str[i+1]=='0') continue;
if (j+len-i>=18) continue;
for (int k=i+1;k<=len;k++) tmp=tmp*10+str[k]-'0';
for (int k=i-j+1;k<=i;k++) tmp=tmp*10+st[k]-'0';
if (ans>tmp) ans=tmp,pos=1-i;
}
}
}
}
int cal_len(long long x)
{
int res=0;
while (x)
{
x/=10;
res++;
}
return res;
}
int main()
{
int ca=0;
while (scanf("%s",str+1)!=-1)
{
if (str[1]=='#') break;
len=strlen(str+1);
ans=INF;
for (int s=1;s<=len;s++)
for (int l=s;l<=17&&s+l-1<=len;l++)
{
if (str[s]=='0') continue;
long long tt=trans_stoi(s,s+l);
long long tmp=tt+1;
trans_itos(tmp);
int flag=1;
int p=s+l,q=p+strlen(st)-1;
while (flag)
{
if (q>len) break;
for (int i=p,j=0;i<=q;i++,j++)
if (str[i]!=st[j])
{
flag=0;
break;
}
if (!flag) break;
tmp++;
trans_itos(tmp);
p=q+1,q=p+strlen(st)-1;
}
if (!flag) continue;
for (int i=p,j=0;i<=len;i++,j++)
if (str[i]!=st[j])
{
flag=0;
break;
}
trans_itos(tt-1);
for (int i=s-1,j=strlen(st)-1;i>0;i--,j--)
if (str[i]!=st[j])
{
flag=0;
break;
}
if (flag)
{
if (ans>tt)
ans=tt-1,pos=cal_len(ans)-s+2;
}
}
judge_1();
judge_0();
printf("%lld\n",cal(ans)+pos);
}
return 0;
}
|
The currency system in the Kingdom of Yoax-Musty is strange and fairly inefficient. Like other countries, the kingdom has its own currencty unit denoted by K $ (kingdom dollar). However, the Ministry of Finance issues bills for every value between 1 K $ and (231 - 1) K $ worth.
On the other hand, this system often enables people to make many different values just with a small number of bills. For example, if you have four bills of 1 K $, 2 K $, 4 K $, and 8 K $ worth respectively, you can make any values from 1 K #36; to 15 K $.
In this problem, you are requested to write a program that finds the minimum value that cannot be made with a given set (multiset in a mathematical sense) of bills. For the case with the four bills (1 K $, 2 K $, 4 K $, and 8 K $), since you can make any values up to 15 K $, your program should report 16 K $.
Input
The input consists of two lines. The first line contains an integer N (1 β€ N β€ 10000), the number of bills. The second line contains N integers, each of which represents the value of a bill in K $. There may be multiple bills of the same value.
Output
Print the minimum value unable to be made on a line. The value should be given in K $ and without any currency sign or name.
Example
Input
Output
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i=a;i<=b;++i)
typedef long long int ll;
int n;ll a[101000],s[101000];
int main(){
int co=0;
scanf("%d",&n);
rep(i,1,n){
cin>>a[i];
}
sort(a+1,a+n+1);
rep(i,1,n){
s[i]=s[i-1]+a[i];
if(a[i]>s[i-1]+1){cout<<s[i-1]+1<<endl;return 0;}
}
cout<<s[n]+1<<endl;
return 0;
}
|
Sunuke cannot move in the initial state. The price of the i-th ticket is pi, which can be bought to move from (x, y) to (x + tai, y + tbi) for any (x, y) and any non-negative real number t. become able to. Find the minimum total amount of tickets that Sunuke must buy in order to be able to move between any two points on the plane (combining several tickets).
Constraints
* 1 β€ n β€ 200000
* β109 β€ ai, bi β€ 109
* 1 β€ pi β€ 109
* All inputs are integers
Input
n
a1 b1 p1
.. ..
an bn pn
Output
Output the minimum total amount of tickets you must buy to be able to move between any two points on the plane. If not, output -1.
Examples
Input
7
0 3 1
0 3 2
1 -1 2
0 0 1
-2 4 1
-4 0 1
2 1 2
Output
4
Input
2
1 2 3
4 5 6
Output
-1
|
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
#include "numeric"
#include "cassert"
#include "ctime"
using namespace std;
constexpr long long int MOD = 1000000007;
//constexpr int MOD = 1000000007;
//constexpr int MOD = 998244353;
//constexpr long long int MOD = 998244353;
constexpr double EPS = 1e-9;
//int N, M, K, H, W, L, R;
long long int N, M, K, H, W, L, R;
int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
vector<long double>x(N);
vector<long double>y(N);
vector<long long int>p(N);
vector<pair<long double, long long int>>v;
map<pair<int, int>, long long int>mp;
for (int i = 0; i < N; i++) {
int a, b;
cin >> a >> b >> p[i];
if (a == 0 && b == 0)continue;
int g = gcd(abs(a), abs(b));
a /= g;
b /= g;
if (mp[{a, b}] == 0)mp[{a, b}] = MOD;
mp[{a, b}] = min(mp[{a, b}], p[i]);
x[i] = a, y[i] = b;
if (x[i] || y[i]) {
v.push_back({ atan2l(y[i], x[i]), p[i] });
}
}
sort(v.begin(), v.end());
M = v.size();
long double pi = acosl(-1);
for (int i = 0; i < M; i++) {
v.push_back({ v[i].first + pi * 2,v[i].second });
}
for (int i = 0; i < M; i++) {
v.push_back({ v[i].first + pi * 4,v[i].second });
}
long long int ret = MOD * MOD;
for(int loop=0;loop<2;loop++){
set<pair<long long int, int>>fst;
set<pair<long long int, int>>snd;
int a = 0, b = 0, c = 0, d = 0;
for (int i = 1; i < M * 3; i++) {
if (v[i].first <= v[0].first + pi / 2-EPS)a = i;
else if (v[i].first < v[0].first + pi - EPS) {
b = i;
fst.insert({ v[i].second,i });
}
else if (v[i].first <= v[0].first + pi + EPS) {
c = i;
}
else if (v[i].first <= v[0].first + pi * 3 / 2-EPS) {
d = i;
snd.insert({ v[i].second,i });
}
b = max(a, b);
c = max(c, b);
d = max(c, d);
}
a++, b++, c++, d++;
long long int ans = MOD * MOD;
if (!fst.empty() && !snd.empty()) {
ans = min(ans, v[0].second + fst.begin()->first + snd.begin()->first);
}
for (int i = 1; i < M; i++) {
while (v[b].first < v[i].first + pi - EPS) {
fst.insert({ v[b].second,b });
b++;
}
while (v[a].first <= v[i].first + pi / 2-EPS) {
fst.erase({ v[a].second,a });
a++;
}
while (v[d].first <= v[i].first + pi * 3 / 2-EPS) {
snd.insert({ v[d].second,d });
d++;
}
while (v[c].first <= v[i].first + pi + EPS) {
snd.erase({ v[c].second,c });
c++;
}
if (!fst.empty() && !snd.empty()) {
ans = min(ans, v[i].second + fst.begin()->first + snd.begin()->first);
}
}
ret = min(ret, ans);
for (auto &i : v) {
i.first = -i.first;
}
reverse(v.begin(), v.end());
}
vector<long long int>pa;
for (auto i : mp) {
if (i.first.second <= 0 && !(i.first.first == 1 && i.first.second == 0)) {
if (mp.find({ -i.first.first,-i.first.second }) != mp.end()) {
pa.push_back(i.second + mp[{-i.first.first, -i.first.second}]);
}
}
}
sort(pa.begin(), pa.end());
if (pa.size() > 1) {
ret = min(ret, pa[0] + pa[1]);
}
if (ret == MOD * MOD)ret = -1;
cout << ret << endl;
}
|
Example
Input
8
-10 0
-10 5
-5 5
-5 0
10 0
10 -5
5 -5
5 0
Output
50
|
/*
SUPTO
UNIVERSITY OF DHAKA
*/
#include <bits/stdc++.h>
using namespace std;
#define D(x) cerr<<#x " = "<<(x)<<endl
#define pb push_back
#define ff first
#define ss second
#define mem(a) memset(a,0,sizeof(a))
#define _set(a) memset(a,-1,sizeof(a))
typedef long long int ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
#define MAX 100005
#define MAXL 20
#define MAXE 100000
//const int mod = 1000000007;
//const int inf = 1<<30;
//int dx[] = {0,0,1,-1};
//int dy[] = {1,-1,0,0};
//int dx[] = {-1,-1,-1,0,0,1,1,1};
//int dy[] = {-1,0,1,-1,1,-1,0,1};
//const double eps=1e-9;
const double pi=acos(-1.0);
int dblcmp(ll d) {
if(d == 0) return 0;
return d>0?1:-1;
}
inline ll sqr(ll x){return x*x;}
struct point {
ll x,y;
point(){}
point(ll _x,ll _y): x(_x),y(_y){};
bool operator==(point a)const { return dblcmp(a.x-x)==0&&dblcmp(a.y-y)==0; }
bool operator<(point a)const { return dblcmp(a.x-x)==0?dblcmp(y-a.y)<0:x<a.x; }
double len() { return hypot(x,y); }
double len2() { return x*x+y*y; }
double distance(point p) { return hypot(x-p.x,y-p.y); }
point add(point p) { return point(x+p.x,y+p.y); }
point sub(point p) { return point(x-p.x,y-p.y); }
point mul(double b) { return point(x*b,y*b); }
point div(double b) { return point(x/b,y/b); }
ll dot(point p) { return x*p.x+y*p.y; }
ll det(point p) { return x*p.y-y*p.x; }
} ar[MAX], upper[MAX], lower[MAX];
ll total1[MAX], total2[MAX];
int main()
{
//freopen("in.txt", "r", stdin);
//freopen("codes.out", "w", stdout);
int n, i;
scanf("%d", &n);
for(i = 0; i < n; i++) scanf("%lld %lld", &ar[i].x, &ar[i].y);
sort(ar, ar+n);
int topu = 0, topl = 0;
upper[0] = lower[0] = ar[0];
total1[0] = 0;
ll area1 = 0, area2 = 0;
for(i = 1; i < n; i++)
{
while(topu && upper[topu].sub(ar[i]).det(upper[topu-1].sub(ar[i])) <= 0)
{
area1 -= upper[topu-1].det(upper[topu]);
topu--;
}
while(topl && lower[topl].sub(ar[i]).det(lower[topl-1].sub(ar[i])) >= 0)
{
area2 += lower[topl-1].det(lower[topl]);
topl--;
}
upper[++topu] = ar[i];
lower[++topl] = ar[i];
if(topu) area1 += upper[topu-1].det(upper[topu]);
if(topl) area2 -= lower[topl-1].det(lower[topl]);
total1[i] = abs(area1+area2);
}
topu = topl = 0;
upper[0] = lower[0] = ar[n-1];
total2[n] = total2[n-1] = 0;
area1 = area2 = 0;
for(i = n-2; i >= 0; i--)
{
while(topu && upper[topu].sub(ar[i]).det(upper[topu-1].sub(ar[i])) <= 0)
{
area1 -= upper[topu-1].det(upper[topu]);
topu--;
}
while(topl && lower[topl].sub(ar[i]).det(lower[topl-1].sub(ar[i])) >= 0)
{
area2 += lower[topl-1].det(lower[topl]);
topl--;
}
upper[++topu] = ar[i];
lower[++topl] = ar[i];
if(topu) area1 += upper[topu-1].det(upper[topu]);
if(topl) area2 -= lower[topl-1].det(lower[topl]);
total2[i] = abs(area1+area2);
}
ll ans = total1[n-1];
for(i = 0; i < n; i++)
{
if(i < n-1 && ar[i].x != ar[i+1].x) ans = min(ans, total1[i]+total2[i+1]);
}
printf("%lld\n", (ans+1)/2);
return 0;
}
|
I: Ravage
Santa Claus was caught in the illuminations of the city and broke it.
There are N light bulbs in the illumination, and the $ i $ th light bulb only comes on when the voltage is above $ A_i $ and below $ B_i $.
The voltage should be the same everywhere in the illumination.
Find out how many light bulbs can be lit at the same time by adjusting the voltage.
input
The integer $ N $ is given on the first line.
Of the following $ N $ lines, $ A_i and B_i $ are given on the $ i $ line, separated by blanks.
output
Output the maximum number of light bulbs that can be illuminated at the same time.
Constraint
* $ N $ is an integer greater than or equal to $ 1 $ and less than or equal to $ 100 \ 000 $
* $ A_1, A_2, A_3, \ dots, A_N $ are integers greater than or equal to $ 1 $ and less than or equal to $ 1 \ 000 \ 000 \ 000 $
* $ B_1, B_2, B_3, \ dots, B_N $ are integers greater than or equal to $ 1 $ and less than or equal to $ 1 \ 000 \ 000 \ 000 $
* Satisfy $ A_i \ leq B_i $ for all light bulbs $ i $
Input example 1
Four
14
3 6
2 7
5 8
Output example 1
3
When the voltage is $ 5 $ or $ 3.14 $, there are $ 3 $ bulbs.
Input example 2
2
1 2
twenty three
Output example 2
2
Example
Input
4
1 4
3 6
2 7
5 8
Output
3
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#define lol(i,n) for(int i=0;i<n;i++)
#define mod 1000000007
typedef long long ll;
using namespace std;
#define N 100010
ll a[N],b[N],n;
int main(){
cin>>n;
lol(i,n)cin>>a[i]>>b[i];
sort(a,a+n); sort(b,b+n);
ll j=0,cnt=0,ans=0;
lol(i,n){
for(;b[j]<a[i];j++)cnt--;
cnt++;
ans=max(ans,cnt);
}
cout<<ans<<endl;
return 0;
}
|
Problem
How, you have been trapped in a cave!
Perhaps the wall had collapsed, and many rocks were in the way before we reached the only exit.
But I realized that there was a bomb vending machine right next to you.
In addition, it seems that some "blasters" have also fallen in the cave.
If you use these two tools, it seems that you can escape to the exit.
* * *
Item description
There are two types of items that can be used in the cave: "bomb" and "blaster".
* A bomb is an item that can be used to destroy a square of rock.
* Blaster is an item that can be used to destroy all rocks in a straight line in front of you.
When you destroy the target rock, the rock shatters into a "floor".
Bombs and blasters are used up, and each item can only be used once.
Also, by using a blaster, you will not destroy other blasters.
* * *
Cave field
I was able to know the state of the cave by flying the drone that I had by chance.
You will be given a cave field.
The field is given by ASCII art as below.
_ ###
B #
B ## _
The field is a rectangle consisting of $ H \ times W $ squares with a width of $ H $ squares on the top and bottom and $ W $ squares on the left and right.
The cell in the $ i $ row $ j $ column is represented as $ (i, j) $.
Each square has a floor, a wall, or a blaster.
The blaster mass indicates that there is exactly one blaster on the floor.
The outside of the field is surrounded by a wall that cannot be destroyed by bombs or blasters.
You cannot go outside the field.
* * *
Action until escape
You can take the following actions any number of times.
* Proceed to any floor in the adjacent square.
* Get any blaster in an adjacent square. After acquisition, the square that acquired the blaster will be the floor.
* Destroy a rock in an adjacent square by consuming a bomb.
* From the current square, face up, down, left and right in any direction, and use one blaster you have.
Here, the adjacent mass $ (i, j) $ and $ (k, l) $ means that $ | i-k | + | j-l | = 1 $.
The blaster is light enough that you can get as many as you want during the action.
However, please note that you can only use the blaster as many times as you have obtained, as described in the item description.
Initially, you are in the mass $ (1,1) $.
Escape means reaching the mass $ (H, W) $.
* * *
Mission
You have found that you can escape without problems by buying a large number of bombs from a bomb vending machine.
Fortunately, the bomb vending machine has $ 10 ^ {100} $ in stock, which seems to be enough to escape.
However, I don't want to buy too many bombs because they are so expensive.
From what the cave looks like, I wanted to know how many bombs I needed to buy to escape.
Constraints
The input satisfies the following conditions.
* $ 2 \ leq H, W \ leq 1000 $
* $ H, W $ are integers
* $ c_ {1,1}, c_ {H, W} $ is always'_'.
Input
The input is given in the following format.
$ H $ $ W $
$ c_ {1,1} $$ \ cdots $$ c_ {1, W} $
$ \ vdots $
$ c_ {H, 1} $$ \ cdots $$ c_ {H, W} $
$ H, W $ are given on the first line, separated by blanks.
From the second line, the field information is given in ASCII art on the following $ H $ line.
The field information has the following meaning for each character:
* When $ c_ {i, j} $ is'#', it indicates that there is a rock in $ (i, j) $.
* When $ c_ {i, j} $ is'_', it indicates that $ (i, j) $ has a floor.
* When $ c_ {i, j} $ is'B', it indicates that $ (i, j) $ has exactly one blaster.
Output
Print the number of bombs needed to escape in one line.
Examples
Input
8 5
_###_
_#_B#
_####
____#
###_#
#####
###_#
####_
Output
1
Input
8 5
_###_
_#_B#
_####
____#
_#
_#
_
Output
1
Input
5 5
_____
_____
_____
_____
_____
Output
0
Input
4 5
_####
B##
_####
_###_
Output
2
Input
4 5
_#B##
B##
_
Output
1
|
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
struct FastIO{
FastIO(){
cin.tie(0);
ios::sync_with_stdio(0);
}
}fastio_beet;
using P = pair<int, int>;
vector< vector<int> > bfs(vector<string> &s,vector<P> &vp,char wall,int dir){
int h=s.size(),w=s.front().size();
vector< vector<int> > dp(h,vector<int>(w,-1));
deque<P> q;
for(int i=0;i<(int)vp.size();i++){
int sy=vp[i].first,sx=vp[i].second;
dp[sy][sx]=0;
q.emplace_back(sy,sx);
}
int dy[]={1,-1,0,0,1,1,-1,-1};
int dx[]={0,0,1,-1,1,-1,1,-1};
auto in=[&](int y,int x){return 0<=y&&y<h&&0<=x&&x<w;};
while(!q.empty()){
int y,x;
tie(y,x)=q.front();q.pop_front();
for(int k=0;k<dir;k++){
int ny=y+dy[k],nx=x+dx[k];
if(!in(ny,nx)) continue;
int nd=dp[y][x]+(s[ny][nx]==wall);
if(~dp[ny][nx]&&dp[ny][nx]<=nd) continue;
dp[ny][nx]=nd;
if(s[ny][nx]=='#'){
q.emplace_back(ny,nx);
}else{
q.emplace_front(ny,nx);
}
}
}
return dp;
}
vector< vector<int> > bfs(vector<string> &s,int sy,int sx,char wall,int dir){
vector<P> vp;
vp.emplace_back(sy,sx);
return bfs(s,vp,wall,dir);
}
//INSERT ABOVE HERE
signed main(){
int h,w;
cin>>h>>w;
vector<string> st(h);
for(int i=0;i<h;i++) cin>>st[i];
auto d1=bfs(st,0,0,'#',4);
int ans=d1[h-1][w-1];
// find B2
vector< vector<int> > ex(h,vector<int>(w));
{
int flg=0;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++) if(st[i][j]=='B') ex[i][j]|=flg;
for(int j=0;j<w;j++) if(st[i][j]=='B') flg=1;
}
}
{
int flg=0;
for(int j=0;j<w;j++){
for(int i=0;i<h;i++) if(st[i][j]=='B') ex[i][j]|=flg;
for(int i=0;i<h;i++) if(st[i][j]=='B') flg=1;
}
}
// use B2
for(int i=0;i<h;i++)
for(int j=0;j<w;j++)
if(ex[i][j]) chmin(ans,d1[i][j]);
// find B1
int by=-1,bx=-1;
for(int i=0;i<h;i++)
for(int j=0;j<w;j++)
if(st[i][j]=='B'&&!ex[i][j]) by=i,bx=j;
if(~by){
// dist from B1
auto d2=bfs(st,by,bx,'#',4);
// dist to (i, j) with B1
vector< vector<int> > d3(h,vector<int>(w));
for(int i=0;i<h;i++)
for(int j=0;j<w;j++)
d3[i][j]=d1[i][j]+d2[i][j]-(st[i][j]=='#');
vector< queue<P> > qs((h+w)*2);
for(int i=0;i<h;i++)
for(int j=0;j<w;j++)
qs[d3[i][j]].emplace(i,j);
int dy[]={1,-1,0,0,1,1,-1,-1};
int dx[]={0,0,1,-1,1,-1,1,-1};
auto in=[&](int y,int x){return 0<=y&&y<h&&0<=x&&x<w;};
for(int d=0;d+1<(int)qs.size();d++){
while(!qs[d].empty()){
int y,x;
tie(y,x)=qs[d].front();qs[d].pop();
if(d3[y][x]!=d) continue;
for(int k=0;k<4;k++){
int ny=y+dy[k],nx=x+dx[k];
if(!in(ny,nx)) continue;
int nd=d3[y][x]+(st[ny][nx]=='#');
if(d3[ny][nx]<=nd) continue;
d3[ny][nx]=nd;
qs[nd].emplace(ny,nx);
}
}
}
// dist from B2 and goal
vector<P> vp;
for(int i=0;i<h;i++)
for(int j=0;j<w;j++)
if(ex[i][j]) vp.emplace_back(i,j);
vp.emplace_back(h-1,w-1);
auto d4=bfs(st,vp,'#',4);
// use B1
vector< vector<int> > d5(d3),d6(d3);
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
if(i) chmin(d5[i][j],d5[i-1][j]);
if(j) chmin(d6[i][j],d6[i][j-1]);
}
}
// take B2 and use
for(int i=0;i<h;i++)
for(int j=0;j<w;j++)
chmin(ans,(d4[i][j]-(st[i][j]=='#'))+min(d5[i][j],d6[i][j]));
}
cout<<ans<<endl;
return 0;
}
|
Write a program which prints the central coordinate ($cx$,$cy$) and the radius $r$ of a incircle of a triangle which is constructed by three points ($x_1$, $y_1$), ($x_2$, $y_2$) and ($x_3$, $y_3$) on the plane surface.
Constraints
* $-10000 \leq x_i, y_i \leq 10000$
* The three points are not on the same straight line
Input
The input is given in the following format
$x_1$ $y_1$
$x_2$ $y_2$
$x_3$ $y_3$
All the input are integers.
Output
Print $cx$, $cy$ and $r$ separated by a single space in a line. The output values should be in a decimal fraction with an error less than 0.000001.
Examples
Input
1 -2
3 2
-2 0
Output
0.53907943898209422325 -0.26437392711448356856 1.18845545916395465278
Input
0 3
4 0
0 0
Output
1.00000000000000000000 1.00000000000000000000 1.00000000000000000000
|
#include<bits/stdc++.h>
#define REP(i,first,last) for(int i=first;i<=last;++i)
#define DOW(i,first,last) for(int i=first;i>=last;--i)
using namespace std;
long long Random(long long a)
{
return (1ll*rand()*rand()+rand())%a;
}
long long Random(long long f,long long e)
{
return f+Random(e-f+1);
}
double Sqr(double a)
{
return a*a;
}
const double PI=3.14159265358979323846264338327950288419716939;
struct Point
{
double x,y;
Point(double fx=0,double fy=0)
{
x=fx;
y=fy;
}
void Read()
{
scanf("%lf%lf",&x,&y);
}
void Write()
{
printf("%.9lf %.9lf",x,y);
}
double operator ^(Point const b)const
{
return x*b.x+y*b.y;
}
double operator |(Point const b)const
{
return x*b.y-b.x*y;
}
double operator ==(Point const b)const
{
return sqrt((x-b.x)*(x-b.x)+(y-b.y)*(y-b.y));
}
Point operator *(double const b)const
{
return Point(x*b,y*b);
}
Point operator +(Point const b)const
{
return Point(x+b.x,y+b.y);
}
Point operator -(Point const b)const
{
return Point(x-b.x,y-b.y);
}
bool operator !=(Point const b)const
{
if(1e-5<=fabs(x-b.x))
{
return 1;
}
if(1e-5<=fabs(y-b.y))
{
return 1;
}
return 0;
}
};
Point Symmetrical(Point a,Point m=Point(0,0))
{
return Point(m.x*2-a.x,m.y*2-a.y);
}
/**
* /
* a /
* m
* / b
* /
*
* a
*
* ---m-----
*
* b
* return b;
*/
struct Vector
{
Point a,b;
Vector(Point f=Point(0,0),Point e=Point(0,0))
{
a=f;
b=e;
}
double operator ^(Vector const c)const
{
return (a.x-b.x)*(c.a.x-c.b.x)+(c.a.y-c.b.y)*(a.y-b.y);
}
double operator |(Vector const c)const
{
return (a.x-b.x)*(c.a.y-c.b.y)-(c.a.x-c.b.x)*(a.y-b.y);
}
};
struct Circle
{
Point core;
double radius;
Circle(Point c=Point(0,0),double r=0)
{
core=c;
radius=r;
}
};
Point ProjectivePoint(Point a,Vector b)
{
double c=Vector(b.a,a)^Vector(b.a,b.b);
c/=(b.a==b.b)*(b.a==b.b);
return (b.b-b.a)*c+b.a;
}
/**
* *
* |
* |
* *---m-----*
*
* *
* |
* |
* *----* m
* return m;
*/
double PointToVector(Point a,Vector b)
{
Point c=ProjectivePoint(a,b);
if(
(
(b.a.x<=c.x)==(c.x<=b.b.x)
)
&&
(
(b.a.y<=c.y)==(c.y<=b.b.y)
)
)
{
return a==c;
}
return min(a==b.a,a==b.b);
}
/**
* *
* |
* *------*
*
* *
* /
* *------*
* return min_dis;
*/
bool InRectangle(Point a,Point b,Point c)
{
return
min(b.x,c.x)<=a.x&&a.x<=max(b.x,c.x)
&&
min(b.y,c.y)<=a.y&&a.y<=max(b.y,c.y);
}
/**
* a
* b---*
* | |
* *---c
* return 0;
*
* b---*
* |a |
* *---c
* return 1;
*/
bool RectangleIntersection(Point a0,Point a1,Point b0,Point b1)
{
int zx=fabs(a0.x+a1.x-b0.x-b1.x);
int zy=fabs(a0.y+a1.y-b0.y-b1.y);
int x=fabs(a0.x-a1.x)+fabs(b0.x-b1.x);
int y=fabs(a0.y-a1.y)+fabs(b0.y-b1.y);
if(zx<=x&&zy<=y)
{
return 1;
}
return 0;
}
/**
* *---*
* | |
* *---*
*
* *--*
* | |
* | |
* *--*
* return 0;
*
* *---*
* | *-+*
* *-+-*|
* | |
* *--*
* return 1;
*/
bool Intersect(Vector a,Vector b)
{
double a_aa=a|Vector(a.a,b.a);
double a_ab=a|Vector(a.a,b.b);
double b_aa=b|Vector(b.a,a.a);
double b_ab=b|Vector(b.a,a.b);
if((a_aa==0||a_ab==0||((a_aa<0)^(a_ab<0)))&&(b_aa==0||b_ab==0||((b_aa<0)^(b_ab<0))))
{
return RectangleIntersection(a.a,a.b,b.a,b.b);
}
return 0;
}
/**
* *
* /
* /*
* / \
* / \
* * *
* return 0;
*
* *
* * /
* \/
* /\
* / \
* * *
* return 1;
*/
Point QueryIntersect(Vector a,Vector b)
{
Vector u(a.a,b.a);
Vector v(b.a,b.b);
Vector w(a.a,a.b);
double c=(w|u)/(v|w);
return Point(b.a.x+(b.b.x-b.a.x)*c,b.a.y+(b.b.y-b.a.y)*c);
}
/**
* *
* * /
* \ /
* \ /
* m
* / \
* * \
* *
* return m;
*/
double VectorToVector(Vector a,Vector b)
{
if(Intersect(a,b))
{
return 0.0;
}
return min
(
min(PointToVector(a.a,b),PointToVector(a.b,b)),
min(PointToVector(b.a,a),PointToVector(b.b,a))
);
}
/**
* *----*
* |
* *--------*
*
* *-----*
* \
* *-----*
* return min_dis;
*/
double TriangleArea(Point a,Point b,Point c)
{
double al=b==c;
double bl=a==c;
double cl=a==b;
double p=(al+bl+cl)/2;
return sqrt(p*(p-al)*(p-bl)*(p-cl));
}
/**
* a
* /|
* / |
* / |
* c---b
* return area;
*/
Circle Circumscribed(Point a,Point b,Point c)
{
double a1=2*(b.x-a.x);
double b1=2*(b.y-a.y);
double c1=Sqr(b.x)+Sqr(b.y)-Sqr(a.x)-Sqr(a.y);
double a2=2*(c.x-b.x);
double b2=2*(c.y-b.y);
double c2=Sqr(c.x)+Sqr(c.y)-Sqr(b.x)-Sqr(b.y);
Point core=Point
(
((c1*b2)-(c2*b1))/((a1*b2)-(a2*b1)),
((a1*c2)-(a2*c1))/((a1*b2)-(a2*b1))
);
return Circle(core,core==a);
}
/**
* a
* p /|
* / |
* / |
* c---b
* (dis(p,a)=dis(p,b)=dis(p,c))
* return p;
*/
Circle Inscribed(Point a,Point b,Point c)
{
double al=b==c;
double bl=a==c;
double cl=a==b;
return Circle(Point((al*a.x+bl*b.x+cl*c.x)/(al+bl+cl),(al*a.y+bl*b.y+cl*c.y)/(al+bl+cl)),TriangleArea(a,b,c)/(al+bl+cl)*2);
}
/**
* a
* /|
* / |
* / p|
* c---b
* (dis(p,ac)=dis(p,ab)=dis(p,bc))
* return p;
*/
int PolygonPoint(Point a,Point point[],int n)
{
point[n+1]=point[1];
bool now=0;
REP(i,1,n)
{
if(Intersect(Vector(a,Point(1e6,a.y)),Vector(point[i],point[i+1])))
{
if(
(PointToVector(a,Vector(point[i],point[i+1]))<=1e-5))
{
return 1;
}
if((a.y<point[i].y)^(a.y<point[i+1].y))
{
now^=1;
}
}
}
if(now==0)
{
return 0;
}
return 2;
}
/**
* *---*
* / \
* * a *
* \ /
* *---*
* return 2;
*
* *---*
* / \
* * * a
* \ /
* *---*
* return 0;
*
* *---*
* / \
* * *
* \ /
* *-a-*
* return 1;
*/
double Area(Point point[],int n)
{
double result=0;
REP(i,2,n)
{
result+=point[i-1]|point[i];
}
result+=point[n]|point[1];
return fabs(result)/2.0;
}
/**
* *---*
* / /
* * *---*
* \ /
* *---*
* return area;
*/
double Perimeter(Point point[],int n)
{
double result=0;
REP(i,2,n)
{
result+=(point[i-1]==point[i]);
}
return result+(point[1]==point[n]);
}
/**
* *---*
* / /
* * *---*
* \ /
* *---*
* return perimeter;
*/
bool CheckConvexHull(Point point[],int n)
{
double first=0,c;
point[++n]=point[1];
REP(i,1,n-1)
{
if(!first)
{
first=Vector(point[i],point[i+1])|Vector(point[i+1],point[i+2]);
}
else
{
c=(Vector(point[i],point[i+1])|Vector(point[i+1],point[i+2]));
if(c!=0&&((first<0)^(c<0)))
{
return 0;
}
}
}
return 1;
}
/**
* *---*
* / /
* * *---*
* \ /
* *---*
* return 0;
*
* *---*
* / \
* * *
* \ /
* *---*
* return 1;
*/
Point f_point;
bool Cmp(Point a,Point b)
{
double c=Vector(f_point,a)|Vector(f_point,b);
if(0<c)
{
return 1;
}
if(c==0&&(f_point==a)<(f_point==b))
{
return 1;
}
return 0;
}
int GetConvexHull(Point point[],Point st[],int n)
{
REP(i,2,n)
{
if(point[i].y<point[1].y||point[i].y==point[1].y&&point[i].x<point[1].x)
{
swap(point[i],point[1]);
}
}
f_point=point[1];
sort(point+2,point+1+n,Cmp);
int top=1;
st[1]=point[1];
REP(i,2,n)
{
while(1<top&&(Vector(st[top-1],st[top])|Vector(st[top],point[i]))<=0)
{
--top;
}
st[++top]=point[i];
}
return top;
}
/**
* * *
*
* * * *
*
* * *
* |
* V
* *---*
* / \
* * * *
* \ /
* *---*
*/
double GetDiam(Point point[],int n)
{
double result=0;
if(n==2)
{
return point[1]==point[2];
}
point[++n]=point[1];
int top=2;
REP(i,1,n)
{
while(
(Vector(point[i],point[top])|Vector(point[top],point[i+1]))
>
(Vector(point[i],point[top+1])|Vector(point[top+1],point[i+1]))
)
{
top++;
if(top==n+1)
{
top=1;
}
}
result=max(result,max(point[i]==point[top],point[i+1]==point[top]));
}
return result;
}
/**
* *---*
* / \ \
* * \ *
* \ \ /
* *---*
* return max_dis;
*/
Point a,b,c;
int main()
{
a.Read();
b.Read();
c.Read();
Circle cir=Inscribed(a,b,c);
cir.core.Write();
printf(" %.9lf\n",cir.radius);
return 0;
}
|
For a given sequence $A = \\{a_0, a_1, ..., a_{n-1}\\}$ which is sorted by ascending order, find the lower bound for a specific value $k$ given as a query.
* lower bound: the place pointing to the first element greater than or equal to a specific value, or $n$ if there is no such element.
Constraints
* $1 \leq n \leq 100,000$
* $1 \leq q \leq 200,000$
* $0 \leq a_0 \leq a_1 \leq ... \leq a_{n-1} \leq 1,000,000,000$
* $0 \leq k_i \leq 1,000,000,000$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ,..., \; a_{n-1}$
$q$
$k_1$
$k_2$
:
$k_q$
The number of elements $n$ and each element $a_i$ are given in the first line and the second line respectively. In the third line, the number of queries $q$ is given and the following $q$ lines, $q$ integers $k_i$ are given as queries.
Output
For each query, print the position $i$ ($i = 0, 1, ..., n$) of the lower bound in a line.
Example
Input
4
1 2 2 4
3
2
3
5
Output
1
3
4
|
#include <bits/stdc++.h>
using namespace std;
int lower_bound(vector<int>& v, int istart, int iend, int value) {
int n = v.size();
int ng = -1;
int ok = v.size();
while (abs(ok - ng) > 1) {
int mid = (ok + ng) / 2;
if (v[mid] >= value) {
ok = mid;
} else {
ng = mid;
}
}
return ok;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int num_query;
cin >> num_query;
int query;
for (int i = 0; i < num_query; i++) {
cin >> query;
cout << lower_bound(v, 0, v.size(), query) << endl;
}
}
|
Dhapu is a school girl who hacks and programs in free time. But right now she has to do her boring school homework. It's a few addition and subtraction problems. She has gotten bored with doing these repetitive questions. So, she wants to automate the entire process. Will you help her write a program to complete her math homework in a fun way?
Β
Input
The first line has an unsigned integer Q denoting the number of questions she wants to solve using the program.
Each question is in the form of a line. The line consists of 2 very long integers separated by either an addition (+) sign or a Subtraction sign (-).
Output
For every test case, print the answer to the math question.
Constraints
1 <= T <= 1000
1 <= Operands <= 10^200
Β
Example
Input:
4
1+1
1-2
141654614141045641415616417161565497897981246+489748946511344946164879465416948465489426
5467246752197212658296172941726172167-5467246752197212658296172941726172166
Output:
2
-1
142144363087556986361781296626982446363470672
1
|
q = int(raw_input())
while q>0:
q = q - 1
a, b = 0, 0
s = raw_input()
SA, SB = "", ""
OP = ""
for i in s:
if i=='+' or i=='-':
op = i
SB = SA
SA = ""
continue
else:
SA = SA + i
ans = 0
if op=='-':
ans = int (SB) - int (SA)
else:
ans = int (SB) + int (SA)
print ans
|
Problem description
Clarissa Adele Fray (a.k.a Clary) has found out that she is a shadowhunter, a human with angelic qualities. She can create her own runes (magical spells). Last week, she created many powerful runes.
Right now, she is facing several underworld demons, help her find the number of ways, such that the arithmetic mean of the selected runes is max.
Input
First line contains number of test cases.For each test case,there are 2 lines-First line : the number of runes Clary created in the last week.Second line : power of each rune, separated by space
Output
For each test case, print the number of ways (modulo 10^9+7), such that the arithmetic mean of the selected runes in max, in new line.
Constraints
SubTask 1 - 70 Points
1 β€ T β€ 10
1 β€ N β€ 10^5
1 β€ Power of Rune β€ 10^5
SubTask 2 - 30 Points
1 β€ T β€ 2
1 β€ N β€ 10^3
1 β€ Power of Rune β€ 100
Example
Input:
2
1
100
3
80 90 90
Output:
1
3
Explanation
Test Case 1 : There is only one way:
She can select 100
Test Case 2 : There are 3 ways:
She can select 90 (at 2nd position)
She can select 90 (at 3rd position)
She can select 90,90 (both 2nd and 3rd position)
|
MOD = 10**9+7
def fast_exp(base, exp):
res = 1
while (exp>=1):
if (exp%2==1):
res = (res*base)%MOD
base = (base*base)%MOD
exp/=2
return res
for testCase in range(int(raw_input())):
n = int(raw_input())
a = map(int,raw_input().split())
m = max(a)
c = a.count(m)
print fast_exp(2,c)-1
|
As we all know, F.C. Barcelona is the best soccer team of our era! Their entangling and mesmerizing game style usually translates into very high ball possession, consecutive counter-attack plays and goals. Lots of goals, thanks to the natural talent of their attacker and best player in history, Lionel Andres Messi.
However, at the most prestigious tournament of individual teams, the UEFA Champions League, there are no guarantees and believe it or not, Barcelona is in trouble.... They are tied versus Chelsea, which is a very defending team that usually relies on counter-strike to catch opposing teams off guard and we are in the last minute of the match. So Messi decided to settle things down for good and now he is conducting the ball on his teams' midfield and he will start a lethal counter-attack :D
After dribbling the 2 strikers from Chelsea, he now finds himself near the center of the field and he won't be able to dribble the entire team on his own, so he will need to pass the ball to one of his teammates, run forward and receive the ball once again to score the final goal.
Exactly K players are with him on his counter-attack and the coach, Tito Villanova knows that this counter-attack will end in a goal only if after exactly N passes are performed between the players, Messi ends up with the ball.
(Note that the ball only needs to end with Messi after exactly N passes are performed between all the K+1 players, i.e. Messi can receive the ball several times during the N passes. See the 2nd test case explanation for further clarification. )
However, he realized that there are many scenarios possible for this, so he asked you, his assistant coach, to tell him in how many ways can Messi score the important victory goal. So help him!!
Input
Input will contain a number T denoting the number of test cases.
Then T test cases follow, each one consisting of two space-sparated integers N and K.
Output
For each test case, output a single integer, the number of ways the winning play might happen modulo 1000000007 (10^9+7).
Constraints
1 β€ T β€ 100
2 β€ N β€ 1000
1 β€ K β€ 10
Example
Input:
2
2 4
4 2
Output:
4
6
Explanation
In the first test case, say four players with Messi are Xavi, Busquets, Iniesta and Jordi Alba. Then the ways of the winning play to happen when exactly 2 passes are to be performed are:1) Messi - Xavi - Messi2) Messi - Busquets - Messi3) Messi - Iniesta - Messi4) Messi - Alba - Messi
In the second test case, also say that two players with Messi are Xavi and Iniesta. There are 6 ways for the winning play to happen when exactly 4 passes are performed. All the examples of such winning play are:1) Messi - Xavi - Messi - Iniesta - Messi2) Messi - Xavi - Iniesta - Xavi - Messi3) Messi - Xavi - Messi - Xavi - Messi4) Messi - Iniesta - Messi - Iniesta - Messi5) Messi - Iniesta - Messi - Xavi - Messi6) Messi - Iniesta - Xavi - Iniesta - Messi
|
t=raw_input()
t=int(t)
while t!=0:
n, k=raw_input().split(' ')
n=int(n)
k=int(k)
count=0
i=1
while i<n:
count=pow(k, i)-count
i+=1
print (count%1000000007);
t-=1
|
The Little Elephant and his friends from the Zoo of Lviv were returning from the party. But suddenly they were stopped by the policeman Big Hippo, who wanted to make an alcohol test for elephants.
There were N elephants ordered from the left to the right in a row and numbered from 0 to N-1. Let R[i] to be the result of breathalyzer test of i-th elephant.
Considering current laws in the Zoo, elephants would be arrested if there exists K consecutive elephants among them for which at least M of these K elephants have the maximal test result among these K elephants.
Using poor math notations we can alternatively define this as follows. The elephants would be arrested if there exists i from 0 to N-K, inclusive, such that for at least M different values of j from i to i+K-1, inclusive, we have R[j] = max{R[i], R[i+1], ..., R[i+K-1]}.
The Big Hippo is very old and the Little Elephant can change some of the results. In a single operation he can add 1 to the result of any elephant. But for each of the elephants he can apply this operation at most once.
What is the minimum number of operations that the Little Elephant needs to apply, such that the sequence of results, after all operations will be applied, let elephants to avoid the arrest? If it is impossible to avoid the arrest applying any number of operations, output -1.
Input
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows. The first line of each test case contains three space-separated integers N, K, M. The second line contains N space-separated integers R[0], R[1], ..., R[N-1] denoting the test results of the elephants.
Output
For each test case, output a single line containing the minimum number of operations needed to avoid the arrest.
Constraints
1 β€ T β€ 10
1 β€ M β€ K β€ N β€ 17
1 β€ R[i] β€ 17
Example
Input:
4
5 3 2
1 3 1 2 1
5 3 3
7 7 7 7 7
5 3 3
7 7 7 8 8
4 3 1
1 3 1 2
Output:
0
1
1
-1
Explanation
Example case 1. Let's follow the poor math definition of arrest. We will consider all values of i from 0 to N-K = 2, inclusive, and should count the number of values of j described in the definition. If it less than M = 2 then this value of i does not cause the arrest, otherwise causes.
i
{R[i],...,R[i+K-1]}
max{R[i],...,R[i+K-1]}
For which j = i, ..., i+K-1 we have R[j] = max
Conclusion
i=0
{1, 3, 1}
max = 3
R[j] = 3 for j = 1
does not cause the arrest
i=1
{3, 1, 2}
max = 3
R[j] = 3 for j = 1
does not cause the arrest
i=2
{1, 2, 1}
max = 2
R[j] = 2 for j = 3
does not cause the arrest
So we see that initial test results of the elephants do not cause their arrest. Hence the Little Elephant does not need to apply any operations. Therefore, the answer is 0.
Example case 2.We have N = 5, K = 3, M = 3. Let's construct similar table as in example case 1. Here the value of i will cause the arrest if we have at least 3 values of j described in the definition.
i
{R[i],...,R[i+K-1]}
max{R[i],...,R[i+K-1]}
For which j = i, ..., i+K-1 we have R[j] = max
Conclusion
i=0
{7, 7, 7}
max = 7
R[j] = 7 for j = 0, 1, 2
causes the arrest
i=1
{7, 7, 7}
max = 7
R[j] = 7 for j = 1, 2, 3
causes the arrest
i=2
{7, 7, 7}
max = 7
R[j] = 7 for j = 2, 3, 4
causes the arrest
So we see that for initial test results of the elephants each value of i causes their arrest. Hence the Little Elephant needs to apply some operations in order to avoid the arrest. He could achieve his goal by adding 1 to the result R[2]. Then results will be {R[0], R[1], R[2], R[3], R[4]} = {7, 7, 8, 7, 7}. Let's check that now elephants will be not arrested.
i
{R[i],...,R[i+K-1]}
max{R[i],...,R[i+K-1]}
For which j = i, ..., i+K-1 we have R[j] = max
Conclusion
i=0
{7, 7, 8}
max = 8
R[j] = 8 for j = 2
does not cause the arrest
i=1
{7, 8, 7}
max = 8
R[j] = 8 for j = 2
does not cause the arrest
i=2
{8, 7, 7}
max = 8
R[j] = 8 for j = 2
does not cause the arrest
So we see that now test results of the elephants do not cause their arrest. Thus we see that using 0 operations we can't avoid the arrest but using 1 operation can. Hence the answer is 1.
Example case 3.We have N = 5, K = 3, M = 3. Let's construct similar table as in example case 1. Here the value of i will cause the arrest if we have at least 3 values of j described in the definition.
i
{R[i],...,R[i+K-1]}
max{R[i],...,R[i+K-1]}
For which j = i, ..., i+K-1 we have R[j] = max
Conclusion
i=0
{7, 7, 7}
max = 7
R[j] = 7 for j = 0, 1, 2
causes the arrest
i=1
{7, 7, 8}
max = 8
R[j] = 8 for j = 3
does not cause the arrest
i=2
{7, 8, 8}
max = 8
R[j] = 8 for j = 3, 4
does not cause the arrest
So we see that for initial test results of the elephants the value of i = 0 causes their arrest. Hence the Little Elephant needs to apply some operations in order to avoid the arrest. He could achieve his goal by adding 1 to the result R[1]. Then results will be {R[0], R[1], R[2], R[3], R[4]} = {7, 8, 7, 8, 8}. Let's check that now elephants will be not arrested.
i
{R[i],...,R[i+K-1]}
max{R[i],...,R[i+K-1]}
For which j = i, ..., i+K-1 we have R[j] = max
Conclusion
i=0
{7, 8, 7}
max = 8
R[j] = 8 for j = 1
does not cause the arrest
i=1
{8, 7, 8}
max = 8
R[j] = 8 for j = 1, 3
does not cause the arrest
i=2
{7, 8, 8}
max = 8
R[j] = 8 for j = 3, 4
does not cause the arrest
So we see that now test results of the elephants do not cause their arrest. Thus we see that using 0 operations we can't avoid the arrest but using 1 operation can. Hence the answer is 1. Note that if we increase by 1 the result R[2] instead of R[1] then the value i = 2 will cause the arrest since {R[2], R[3], R[4]} will be {8, 8, 8} after this operation and we will have 3 values of j from 2 to 4, inclusive, for which R[j] = max{R[2], R[3], R[4]}, namely, j = 2, 3, 4.
Example case 4. When M = 1 the Little Elephant can't reach the goal since for each value of i from 0 to N-K we have at least one value of j for which R[j] = max{R[i], R[i+1], ..., R[i+K-1]}.
|
#!/usr/bin/python
from sys import stdin
T = int(stdin.readline())
global N,K,M,R
global minimal
def check(i,current):
global N,K,M,R
global minimal
#print current,minimal,i,R
if current >= minimal:
return
if i >= N:
if current < minimal:
minimal = current
return
#print current,R
for add in [0,1]:
R[i] += add
if i >= K - 1:
start = 1 + min(i - K, N - K)
end = start + K
#print start, end
high = R[start]
start += 1
count = 1
while start < end:
if R[start] == high:
count += 1
elif R[start] > high:
high = R[start]
count = 1
start += 1
else:
count = 0
if count < M:
check(i+1, current + add)
if minimal == 0:return
R[i] -= add
#T = 1
for _ in xrange(T):
N,K,M = (int(x) for x in stdin.readline().split())
R = [int(x) for x in stdin.readline().split()]
current = 0
minimal = N+1
if M == 0:
minimal = 0
elif M != 1:
check(0,0)
if minimal == N+1:
print '-1'
else:
print minimal
|
After confronting Pinocchio, Lampwick decided to further analyse his diary about Pinocchio. (You can find the details about the diary in Part 1 of this problem)
Now he needs to find out the maximum number of days that passed by in which Pinocchio surely didn't lie. Can you help him out?
Β
Input
First line of input contains T, the number of test cases.
For each of the next T lines, two lines follow. The first line contains an integer N, denoting the number of days. The second line contains N space-separated integers L1, L2, ..., LN representing the length of Pinocchio's nose on different days.
Output
For each test case, output contains an integer representing the maximum number of days that went by between which Pinocchio surely didn't lie.
Constraints
1 <= T <= 100
1 <= N <= 10^5
1 <= Li <= 5*10^6
Example
Input:
1
7
1 2 2 3 4 5 5
Output:
1
Explanation
For the example given above, Pinocchio did not lie on day 3rd and 7th, making the maximum number of days that passed by when Pinocchio did not lie in between as 1.
|
# cook your code here
t = int(raw_input())
for i in xrange(t):
n = int(raw_input())
nums = map(int, raw_input().split())
d = {}
for num in nums:
d[num] = d.get(num, 0) + 1
m = max(d.values())
print m-1
|
Chef likes strings a lot but moreover he likes good strings. Chef calls a string str a good string if str starts and ends at different characters. For eg : strings such as abab , baccba , abc are all good strings whereas strings like aba, baab , baacaab are not good at all .
Today, Chef has a special string P consisting of lower case letters "c" , "h" , "e" and "f" only. Chef wants to make some queries about his string P.
Each of chef's query has the following form a b L R. For a given query, Chef wants to count the number of good strings which starts at letter a and ends at letter b such that starting index Si and ending index Ei of a chosen substring satisfies L <= Si < Ei <= R.
NOTE
Two substrings P1 and P2 are considered to be different if either S1 != S2 or E1 != E2 where S1,E1 and S2,E2 are the starting and ending index of string P1 and string P2 respectively.
Chef is not able to accomplish this task efficiently. Can you help him ?
Input
First line of the input contains a string P denoting the chef's special string. Next line of the input contains a single integer Q denoting the number of chef's queries. Next Q lines of the input contains four space separated parameters where the first two parameters are characters denoting a and b respectively and rest two are integers denoting L and R respectively.
Output
For each chef's query, print the required answer.
Constraints
1 <= |P| <= 10^6
1 <= Q <= 10^6
1 <= L <= R <= |P|
P,a,b belongs to the set of lower case letters [c,h,e,f] and a != b.
All test files are strictly according to constraints.
Example
Input
checfcheff
5
c h 1 10
c f 1 10
e c 1 10
c f 1 5
c f 6 10
Output
4
8
2
2
2
Explanation
Q1 : good strings are ch , checfch , cfch , ch
Q2 : good strings are checf , checfchef , checfcheff , cf , cfchef , cfcheff , chef , cheff
Warning
Large test data set, Prefer to use faster input/output methods .
|
ch=str(raw_input())
length=len(ch)
arr=[]
cur=0
temp=[]
for k in range(length):
if(ch[k]=='c'):
cur+=1
temp.append(cur)
else:
temp.append(cur)
arr.append(temp)
cur=0
temp=[]
for k in range(length):
if(ch[k]=='e'):
cur+=1
temp.append(cur)
else:
temp.append(cur)
arr.append(temp)
cur=0
temp=[]
for k in range(length):
if(ch[k]=='f'):
cur+=1
temp.append(cur)
else:
temp.append(cur)
arr.append(temp)
cur=0
temp=[]
for k in range(length):
if(ch[k]=='h'):
cur+=1
temp.append(cur)
else:
temp.append(cur)
arr.append(temp)
dp=[]
for i in range(4):
dp.append([])
for k in range(4):
dp[i].append([0])
for i in range(4):
for j in range(4):
if(i==j):
continue
for k in range(1,length):
if(j==0):
if(ch[k]=='c'):
dp[i][j].append(dp[i][j][k-1]+arr[i][k-1])
else:
dp[i][j].append(dp[i][j][k-1])
elif(j==1):
if(ch[k]=='e'):
dp[i][j].append(dp[i][j][k-1]+arr[i][k-1])
else:
dp[i][j].append(dp[i][j][k-1])
elif(j==2):
if(ch[k]=='f'):
dp[i][j].append(dp[i][j][k-1]+arr[i][k-1])
else:
dp[i][j].append(dp[i][j][k-1])
elif(j==3):
if(ch[k]=='h'):
dp[i][j].append(dp[i][j][k-1]+arr[i][k-1])
else:
dp[i][j].append(dp[i][j][k-1])
q=int(raw_input())
for i in range(q):
z=raw_input().split()
ans=0
a=z[0]
b=z[1]
l=int(z[2])
r=int(z[3])
temp2=0
temp1=0
if(a=='c'):
temp1=0
elif(a=='e'):
temp1=1
elif(a=='f'):
temp1=2
else:
temp1=3
if(b=='c'):
temp2=0
elif(b=='e'):
temp2=1
elif(b=='f'):
temp2=2
else:
temp2=3
if(l==1):
ans=dp[temp1][temp2][r-1]
else:
ans=dp[temp1][temp2][r-1]-dp[temp1][temp2][l-2]-arr[temp1][l-2]*(arr[temp2][r-1]-arr[temp2][l-2])
print ans
|
Leha is planning his journey from Moscow to Saratov. He hates trains, so he has decided to get from one city to another by car.
The path from Moscow to Saratov can be represented as a straight line (well, it's not that straight in reality, but in this problem we will consider it to be straight), and the distance between Moscow and Saratov is n km. Let's say that Moscow is situated at the point with coordinate 0 km, and Saratov β at coordinate n km.
Driving for a long time may be really difficult. Formally, if Leha has already covered i kilometers since he stopped to have a rest, he considers the difficulty of covering (i + 1)-th kilometer as a_{i + 1}. It is guaranteed that for every i β [1, n - 1] a_i β€ a_{i + 1}. The difficulty of the journey is denoted as the sum of difficulties of each kilometer in the journey.
Fortunately, there may be some rest sites between Moscow and Saratov. Every integer point from 1 to n - 1 may contain a rest site. When Leha enters a rest site, he may have a rest, and the next kilometer will have difficulty a_1, the kilometer after it β difficulty a_2, and so on.
For example, if n = 5 and there is a rest site in coordinate 2, the difficulty of journey will be 2a_1 + 2a_2 + a_3: the first kilometer will have difficulty a_1, the second one β a_2, then Leha will have a rest, and the third kilometer will have difficulty a_1, the fourth β a_2, and the last one β a_3. Another example: if n = 7 and there are rest sites in coordinates 1 and 5, the difficulty of Leha's journey is 3a_1 + 2a_2 + a_3 + a_4.
Leha doesn't know which integer points contain rest sites. So he has to consider every possible situation. Obviously, there are 2^{n - 1} different distributions of rest sites (two distributions are different if there exists some point x such that it contains a rest site in exactly one of these distributions). Leha considers all these distributions to be equiprobable. He wants to calculate p β the expected value of difficulty of his journey.
Obviously, p β
2^{n - 1} is an integer number. You have to calculate it modulo 998244353.
Input
The first line contains one number n (1 β€ n β€ 10^6) β the distance from Moscow to Saratov.
The second line contains n integer numbers a_1, a_2, ..., a_n (1 β€ a_1 β€ a_2 β€ ... β€ a_n β€ 10^6), where a_i is the difficulty of i-th kilometer after Leha has rested.
Output
Print one number β p β
2^{n - 1}, taken modulo 998244353.
Examples
Input
2
1 2
Output
5
Input
4
1 3 3 7
Output
60
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n;
ll mod = 998244353;
cin >> n;
vector<ll> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
ll asum = 0ll;
ll total = 0ll;
vector<ll> two_powers(n + 2);
two_powers[0] = 1ll;
for (int i = 1; i <= n + 1; ++i) {
two_powers[i] = (two_powers[i - 1] * 2) % mod;
}
for (int i = 0; i < n; ++i) {
ll fact = (two_powers[n - i - 1] +
(n - i - 2 >= 0 ? two_powers[n - i - 2] : 0) * (n - i - 1)) %
mod;
total += (a[i] * fact) % mod;
total %= mod;
}
cout << total << "\n";
}
|
At many competitions that have a word Β«cupΒ» in its official name the winner is presented with an actual cup. This time the organizers of one unusual programming competition have decided to please the winner even more and to add a nameplate to the cup with the handle of the winner.
The nameplate is to be rectangular and the text on it will be printed as a table of several rows and columns. Having some measurements done, the organizers have found out that the number a of rows cannot be greater than 5 while the number b of columns cannot exceed 20. Every cell of the table will contain either an asterisk (Β«*Β») or a letter of user's handle.
Furthermore, the organizers want the rows of the table to be uniform, which means that the number of asterisks used in different rows should differ by at most one (i.e. you can't have two asterisks in the first row and none in the second). The main goal, however, is to obtain the winner's handle precisely when reading the table from top to bottom and from left to right in every row (skipping asterisks).
The organizers want for the nameplate to have as few rows as possible and among all valid tables with the minimum number of rows they want to choose the one that has the minimum number of columns.
The winner is not yet determined so your task is to write a program that, given a certain handle, generates the necessary table.
Input
The only line contains one string s (1 β€ |s| β€ 100), comprised of uppercase and lowercase Latin letters, β the handle of the winner.
Output
In the first line output the minimum number a of rows in the table and the minimum number b of columns in an optimal table with rows.
The following a lines should contain b characters each β any valid table.
Examples
Input
tourist
Output
1 7
tourist
Input
MyNameIsLifeIAmForeverByYourSideMyNameIsLife
Output
3 15
MyNameIsLifeIAm
ForeverByYourSi
deMyNameIsL*ife
|
def print2d(a):
for i in range(len(a)):
print(''.join(list(map(str, a[i]))))
st = input()
for i in range(1, 5 + 1):
vst = len(st) // i
ost = len(st) % i
if vst + min(ost, 1) > 20:
continue
a = [0] * i
ind = 0
f = 0
for j in range(len(a)):
a[j] = []
for j in range(len(a)):
for k in range(vst):
a[j].append(st[ind])
ind += 1
if ost > 0:
ost -= 1
a[j].append(st[ind])
ind += 1
f = 1
elif f != 0:
a[j].append('*')
if a[-1][-1] == '*' or a[-1][-1] == st[-1]:
print(len(a), len(a[0]))
print2d(a)
exit()
|
You are given two arrays a_0, a_1, β¦, a_{n - 1} and b_0, b_1, β¦, b_{m-1}, and an integer c.
Compute the following sum:
$$$β_{i=0}^{n-1} β_{j=0}^{m-1} a_i b_j c^{i^2\,j^3}$$$
Since it's value can be really large, print it modulo 490019.
Input
First line contains three integers n, m and c (1 β€ n, m β€ 100 000, 1 β€ c < 490019).
Next line contains exactly n integers a_i and defines the array a (0 β€ a_i β€ 1000).
Last line contains exactly m integers b_i and defines the array b (0 β€ b_i β€ 1000).
Output
Print one integer β value of the sum modulo 490019.
Examples
Input
2 2 3
0 1
0 1
Output
3
Input
3 4 1
1 1 1
1 1 1 1
Output
12
Input
2 3 3
1 2
3 4 5
Output
65652
Note
In the first example, the only non-zero summand corresponds to i = 1, j = 1 and is equal to 1 β
1 β
3^1 = 3.
In the second example, all summands are equal to 1.
|
#include <bits/stdc++.h>
const int moder = 490019;
const int mod1 = 491;
const int mod2 = 499;
const int root = 7;
int powermod(int a, int exp, int moder) {
int ret = 1;
for (; exp > 0; exp >>= 1) {
if (exp & 1) {
ret = 1ll * ret * a % moder;
}
a = 1ll * a * a % moder;
}
return ret;
}
const double PI = std::acos(-1.0);
inline double sqr(double n) { return n * n; }
const int MAX = 20;
struct comp {
double real, imag;
comp(double real = 0, double imag = 0) : real(real), imag(imag) {}
comp operator+(const comp &c) const {
return comp(real + c.real, imag + c.imag);
}
comp operator-(const comp &c) const {
return comp(real - c.real, imag - c.imag);
}
comp operator*(const comp &c) const {
return comp(real * c.real - imag * c.imag, real * c.imag + imag * c.real);
}
comp operator*(const double &c) const { return comp(real * c, imag * c); }
comp conj() const { return comp(real, -imag); }
};
comp w[2][1 << MAX];
int loga1[mod1], loga2[mod2];
int crt[mod1][mod2];
int power[moder];
void init() {
for (int i = 0; i < 1 << MAX; ++i) {
double angle = 1.0 * i / (1 << (MAX - 1)) * PI;
for (int type = -1; type <= 1; type += 2) {
w[!~type][i] = comp(std::cos(angle), type * std::sin(angle));
}
}
int power = 1, loga = 0;
for (int i = 0; i < mod1 - 1; ++i) {
loga1[power] = loga;
++loga;
power = root * power % mod1;
}
power = 1, loga = 0;
for (int i = 0; i < mod2 - 1; ++i) {
loga2[power] = loga;
++loga;
power = root * power % mod2;
}
for (int i = 0; i < mod1 * mod2; ++i) {
crt[i % mod1][i % mod2] = i;
}
}
void FFT(std::vector<comp> &a, int len, int type) {
for (int i = 1, j = 0; i < len - 1; ++i) {
for (int s = len; j ^= s >>= 1, ~j & s;)
;
if (i < j) {
std::swap(a[i], a[j]);
}
}
for (int i = 2, d = 1; i <= len; i <<= 1, ++d) {
for (int j = 0; j < len; j += i) {
auto u = a.begin() + j;
for (int k = 0; k < i / 2; ++k) {
comp s = u[k], t = w[type][k << (MAX - d)] * u[k + i / 2];
u[k] = s + t, u[k + i / 2] = s - t;
}
}
}
if (type == 0) return;
double inv = 1.0 / len;
for (int i = 0; i < len; ++i) {
a[i] = a[i] * inv;
}
}
void FFTcomb(std::vector<comp> &a, std::vector<comp> &b) {
int n = a.size();
FFT(a, n, 0);
for (int i = 0; i < n; ++i) {
b[i] = a[i ? n - i : 0].conj();
}
for (int i = 0; i < n; ++i) {
comp tmp1 = (a[i] + b[i]) * comp(0.5, 0);
comp tmp2 = (a[i] - b[i]) * comp(0, -0.5);
a[i] = tmp1, b[i] = tmp2;
}
}
const int N = 100010;
int a[N], b[N];
int main() {
init();
int n, m, c;
scanf("%d%d%d", &n, &m, &c);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i < m; ++i) {
scanf("%d", &b[i]);
}
power[0] = 1;
for (int i = 1; i < moder; ++i) {
power[i] = 1ll * c * power[i - 1] % moder;
}
int ans = 0;
for (int i = 0; i < n; ++i) {
if (i % mod1 == 0 || i % mod2 == 0) {
for (int j = 0; j < m; ++j) {
ans = (ans +
1ll * a[i] * b[j] *
power[1ll * i * i * j % (moder - 1) * j * j % (moder - 1)]) %
moder;
}
}
}
for (int i = 0; i < m; ++i) {
if (i % mod1 == 0 || i % mod2 == 0) {
for (int j = 0; j < n; ++j) {
if (j % mod1 == 0 || j % mod2 == 0) continue;
ans = (ans +
1ll * a[j] * b[i] *
power[1ll * j * j * i % (moder - 1) * i * i % (moder - 1)]) %
moder;
}
}
}
std::vector<comp> p[2], q[2];
for (int i = 0; i < 2; ++i) {
p[i].resize(1 << MAX);
q[i].resize(1 << MAX);
}
for (int i = 0; i < n; ++i) {
if (i % mod1 == 0 || i % mod2 == 0) continue;
int sit1 = 2 * loga1[i % mod1] % (mod1 - 1);
int sit2 = 2 * loga2[i % mod2] % (mod2 - 1);
auto &u = p[0][sit1 * 2 * mod2 + sit2];
(i & 1 ? u.imag : u.real) += a[i];
}
FFTcomb(p[0], p[1]);
for (int i = 0; i < m; ++i) {
if (i % mod1 == 0 || i % mod2 == 0) continue;
int sit1 = 3 * loga1[i % mod1] % (mod1 - 1);
int sit2 = 3 * loga2[i % mod2] % (mod2 - 1);
auto &u = q[0][sit1 * 2 * mod2 + sit2];
(i & 1 ? u.imag : u.real) += b[i];
}
FFTcomb(q[0], q[1]);
std::vector<comp> aux(1 << MAX);
for (int i = 0; i < 1 << MAX; ++i) {
aux[i] = p[0][i] * q[0][i] + p[1][i] * q[0][i] + p[0][i] * q[1][i] +
comp(0, 1) * p[1][i] * q[1][i];
}
FFT(aux, 1 << MAX, 1);
for (int i = 0; i < 1 << MAX; ++i) {
int sit1 = i / (2 * mod2) % (mod1 - 1);
int sit2 = i % (2 * mod2) % (mod2 - 1);
int sit = crt[powermod(root, sit1, mod1)][powermod(root, sit2, mod2)];
int value1 = (long long)std::round(aux[i].real) % moder;
int value2 = (long long)std::round(aux[i].imag) % moder;
sit1 = sit2 = sit;
(sit & 1 ? sit1 : sit2) += mod1 * mod2;
ans =
(ans + 1ll * value1 * power[sit1] + 1ll * value2 * power[sit2]) % moder;
}
printf("%d\n", ans);
return 0;
}
|
A frog is currently at the point 0 on a coordinate axis Ox. It jumps by the following algorithm: the first jump is a units to the right, the second jump is b units to the left, the third jump is a units to the right, the fourth jump is b units to the left, and so on.
Formally:
* if the frog has jumped an even number of times (before the current jump), it jumps from its current position x to position x+a;
* otherwise it jumps from its current position x to position x-b.
Your task is to calculate the position of the frog after k jumps.
But... One more thing. You are watching t different frogs so you have to answer t independent queries.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of queries.
Each of the next t lines contain queries (one query per line).
The query is described as three space-separated integers a, b, k (1 β€ a, b, k β€ 10^9) β the lengths of two types of jumps and the number of jumps, respectively.
Output
Print t integers. The i-th integer should be the answer for the i-th query.
Example
Input
6
5 2 3
100 1 4
1 10 5
1000000000 1 6
1 1 1000000000
1 1 999999999
Output
8
198
-17
2999999997
0
1
Note
In the first query frog jumps 5 to the right, 2 to the left and 5 to the right so the answer is 5 - 2 + 5 = 8.
In the second query frog jumps 100 to the right, 1 to the left, 100 to the right and 1 to the left so the answer is 100 - 1 + 100 - 1 = 198.
In the third query the answer is 1 - 10 + 1 - 10 + 1 = -17.
In the fourth query the answer is 10^9 - 1 + 10^9 - 1 + 10^9 - 1 = 2999999997.
In the fifth query all frog's jumps are neutralized by each other so the answer is 0.
The sixth query is the same as the fifth but without the last jump so the answer is 1.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, a, b, k;
cin >> n;
while (n--) {
cin >> a >> b >> k;
cout << (a * (k - (k / 2)) - b * (k / 2)) << endl;
}
}
|
A Thue-Morse-Radecki-Mateusz sequence (Thorse-Radewoosh sequence in short) is an infinite sequence constructed from a finite sequence gen of length d and an integer m, obtained in the following sequence of steps:
* In the beginning, we define the one-element sequence M_0=(0).
* In the k-th step, k β₯ 1, we define the sequence M_k to be the concatenation of the d copies of M_{k-1}. However, each of them is altered slightly β in the i-th of them (1 β€ i β€ d), each element x is changed to (x+gen_i) \pmod{m}.
For instance, if we pick gen = (0, \color{blue}{1}, \color{green}{2}) and m = 4:
* M_0 = (0),
* M_1 = (0, \color{blue}{1}, \color{green}{2}),
* M_2 = (0, 1, 2, \color{blue}{1, 2, 3}, \color{green}{2, 3, 0}),
* M_3 = (0, 1, 2, 1, 2, 3, 2, 3, 0, \color{blue}{1, 2, 3, 2, 3, 0, 3, 0, 1}, \color{green}{2, 3, 0, 3, 0, 1, 0, 1, 2}), and so on.
As you can see, as long as the first element of gen is 0, each consecutive step produces a sequence whose prefix is the sequence generated in the previous step. Therefore, we can define the infinite Thorse-Radewoosh sequence M_β as the sequence obtained by applying the step above indefinitely. For the parameters above, M_β = (0, 1, 2, 1, 2, 3, 2, 3, 0, 1, 2, 3, 2, 3, 0, 3, 0, 1, ...).
Mateusz picked a sequence gen and an integer m, and used them to obtain a Thorse-Radewoosh sequence M_β. He then picked two integers l, r, and wrote down a subsequence of this sequence A := ((M_β)_l, (M_β)_{l+1}, ..., (M_β)_r).
Note that we use the 1-based indexing both for M_β and A.
Mateusz has his favorite sequence B with length n, and would like to see how large it is compared to A. Let's say that B majorizes sequence X of length n (let's denote it as B β₯ X) if and only if for all i β \{1, 2, ..., n\}, we have B_i β₯ X_i.
He now asks himself how many integers x in the range [1, |A| - n + 1] there are such that B β₯ (A_x, A_{x+1}, A_{x+2}, ..., A_{x+n-1}). As both sequences were huge, answering the question using only his pen and paper turned out to be too time-consuming. Can you help him automate his research?
Input
The first line contains two integers d and m (2 β€ d β€ 20, 2 β€ m β€ 60) β the length of the sequence gen and an integer used to perform the modular operations. The second line contains d integers gen_i (0 β€ gen_i < m). It's guaranteed that the first element of the sequence gen is equal to zero.
The third line contains one integer n (1 β€ n β€ 30000) β the length of the sequence B. The fourth line contains n integers B_i (0 β€ B_i < m). The fifth line contains two integers l and r (1 β€ l β€ r β€ 10^{18}, r-l+1 β₯ n).
Output
Print a single integer β the answer to the problem.
Examples
Input
2 2
0 1
4
0 1 1 0
2 21
Output
6
Input
3 4
0 1 2
2
0 2
6 11
Output
1
Note
Thorse-Radewoosh sequence in the first example is the standard Thue-Morse sequence, so the sequence A is as follows: 11010011001011010010. Here are the places where the sequence B majorizes A:
<image>
|
#include <bits/stdc++.h>
using namespace std;
int d, m;
int gen[20];
vector<long long int> B;
long long int dp[100][60];
long long int shift(long long int b, int x) {
return (b >> x) | ((b & ((1LL << x) - 1)) << (m - x));
}
map<long long int, int> M;
int num = 0;
long long int ans[100][60];
int xx[100][60];
long long int solve(vector<long long int> v, long long int r, int s) {
if (r == 0)
return 0;
else if (v.size() == 1) {
int i = 0;
if (r == 1) return (v[0] & 1) ? 1 : 0;
if (!M.count(r)) {
int j, k, c = 0, digits[100];
long long int x = r - 1;
while (x > 0) digits[i++] = x % d, x /= d;
for (i--; i >= 0; i--) {
for (j = 0; j < digits[i]; j++) {
for (k = 0; k < m; k++)
ans[num][k] += dp[i][(((k - c - gen[j]) % m) + m) % m];
}
if (i == 0) {
for (k = 0; k < m; k++)
ans[num][k] += dp[i][(((k - c - gen[j]) % m) + m) % m];
}
c += gen[j], c %= m;
}
M[r] = num++;
}
int p = M[r];
for (i = 0; i < m; i++) {
if (v[0] & (1LL << i)) xx[p][i] += s;
}
return 0;
}
int i, j;
long long int ans = 0;
for (i = 0; i < v.size(); i++) {
if (v[i] == 0) return 0;
}
for (i = 0; i < d; i++) {
vector<long long int> v2((i + v.size() - 1) / d + 1, (1LL << m) - 1);
for (j = 0; j < v.size(); j++)
v2[(j + i) / d] &= shift(v[j], gen[(i + j) % d]);
ans += solve(v2, (r - i + d - 1) / d, s);
}
return ans;
}
int main() {
int i;
int n;
long long int l, r;
scanf("%d %d", &d, &m);
for (i = 0; i < d; i++) scanf("%d", &gen[i]);
scanf("%d", &n), B.resize(n);
for (i = 0; i < n; i++) scanf("%I64d", &B[i]), B[i] = (1LL << (B[i] + 1)) - 1;
scanf("%I64d %I64d", &l, &r);
int j, k;
dp[0][0] = 1;
for (i = 1; i < 100; i++) {
if (pow(d, i) > 3e18) break;
for (j = 0; j < m; j++) {
for (k = 0; k < d; k++) dp[i][j] += dp[i - 1][(j - gen[k] + m) % m];
}
}
long long int sum = solve(B, r - n + 1, 1) - solve(B, l - 1, -1);
for (i = 0; i < num; i++) {
for (j = 0; j < m; j++) sum += xx[i][j] * ans[i][j];
}
printf("%I64d\n", sum);
return 0;
}
|
Ilya lives in a beautiful city of Chordalsk.
There are n houses on the street Ilya lives, they are numerated from 1 to n from left to right; the distance between every two neighboring houses is equal to 1 unit. The neighboring houses are 1 and 2, 2 and 3, ..., n-1 and n. The houses n and 1 are not neighboring.
The houses are colored in colors c_1, c_2, β¦, c_n so that the i-th house is colored in the color c_i. Everyone knows that Chordalsk is not boring, so there are at least two houses colored in different colors.
Ilya wants to select two houses i and j so that 1 β€ i < j β€ n, and they have different colors: c_i β c_j. He will then walk from the house i to the house j the distance of (j-i) units.
Ilya loves long walks, so he wants to choose the houses so that the distance between them is the maximum possible.
Help Ilya, find this maximum possible distance.
Input
The first line contains a single integer n (3 β€ n β€ 300 000) β the number of cities on the street.
The second line contains n integers c_1, c_2, β¦, c_n (1 β€ c_i β€ n) β the colors of the houses.
It is guaranteed that there is at least one pair of indices i and j so that 1 β€ i < j β€ n and c_i β c_j.
Output
Print a single integer β the maximum possible distance Ilya can walk.
Examples
Input
5
1 2 3 2 3
Output
4
Input
3
1 2 1
Output
1
Input
7
1 1 3 1 1 1 1
Output
4
Note
In the first example the optimal way is to walk from the first house to the last one, where Ilya can walk the distance of 5-1 = 4 units.
In the second example the optimal way is to either walk from the first house to the second or from the second to the third. Both these ways have the distance of 1 unit.
In the third example the optimal way is to walk from the third house to the last one, where Ilya can walk the distance of 7-3 = 4 units.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, x;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
if (v[0] != v[n - 1])
cout << n - 1;
else {
int temp1, temp2;
for (int i = 1; i < n - 1; i++)
if (v[i] != v[0]) {
temp1 = max(i, n - i - 1);
break;
}
for (int i = n - 2; i >= 1; i--) {
if (v[i] != v[0]) {
temp2 = max(i, n - i - 1);
break;
}
}
cout << max(temp1, temp2);
}
}
|
In this problem you have to solve a simple classification task: given an image, determine whether it depicts a Fourier doodle.
You are given a set of 50 images with ids 1 through 50. You are also given a text file labels.txt containing the labels for images with ids 1 through 20, which comprise the learning data set.
You have to output the classification results for images with ids 21 through 50 in the same format.
Input
[Download the images and the training labels](http://tc-alchemy.progopedia.com/fourier-doodles.zip)
Each line of the file labels.txt contains a single integer 0 or 1. Line i (1-based) contains the label of the image {i}.png. Label 1 means that the image depicts a Fourier doodle, label 0 - that it does not.
Output
Output 30 lines, one line per image 21 through 50. Line i (1-based) should contain the classification result for the image {i + 20}.png.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
for (int i = 21; i <= 50; i++) {
cout << ((min(i, 25) + i) % (2 + i % 3) > 0) ? 1 : 0;
cout << endl;
}
return 0;
}
|
Given a positive integer m, we say that a sequence x_1, x_2, ..., x_n of positive integers is m-cute if for every index i such that 2 β€ i β€ n it holds that x_i = x_{i - 1} + x_{i - 2} + ... + x_1 + r_i for some positive integer r_i satisfying 1 β€ r_i β€ m.
You will be given q queries consisting of three positive integers a, b and m. For each query you must determine whether or not there exists an m-cute sequence whose first term is a and whose last term is b. If such a sequence exists, you must additionally find an example of it.
Input
The first line contains an integer number q (1 β€ q β€ 10^3) β the number of queries.
Each of the following q lines contains three integers a, b, and m (1 β€ a, b, m β€ 10^{14}, a β€ b), describing a single query.
Output
For each query, if no m-cute sequence whose first term is a and whose last term is b exists, print -1.
Otherwise print an integer k (1 β€ k β€ 50), followed by k integers x_1, x_2, ..., x_k (1 β€ x_i β€ 10^{14}). These integers must satisfy x_1 = a, x_k = b, and that the sequence x_1, x_2, ..., x_k is m-cute.
It can be shown that under the problem constraints, for each query either no m-cute sequence exists, or there exists one with at most 50 terms.
If there are multiple possible sequences, you may print any of them.
Example
Input
2
5 26 2
3 9 1
Output
4 5 6 13 26
-1
Note
Consider the sample. In the first query, the sequence 5, 6, 13, 26 is valid since 6 = 5 + \bf{\color{blue} 1}, 13 = 6 + 5 + {\bf\color{blue} 2} and 26 = 13 + 6 + 5 + {\bf\color{blue} 2} have the bold values all between 1 and 2, so the sequence is 2-cute. Other valid sequences, such as 5, 7, 13, 26 are also accepted.
In the second query, the only possible 1-cute sequence starting at 3 is 3, 4, 8, 16, ..., which does not contain 9.
|
for _ in range(int(input())):
a,b,m=map(int,input().split())
if a==b:
print(1,a)
continue
for k in range(2,51):
pw=1<<(k-2)
mn=pw*(a+1)
mx=pw*(a+m)
if mn<=b<=mx:
r=[0]*(k+1)
add=b-mn
r[1]=a
for i in range(2,k):
r[i]=min(m-1,add//(1<<(k-i-1)))
add-=r[i]*(1<<(k-i-1))
r[i]+=1
r[k]=add+1
x=[0]*(k+1)
s=0
for i in range(1,k+1):
x[i]=s+r[i]
s+=x[i]
print(k,*(x[1:]),sep=' ')
break
else:
print(-1)
|
Methodius received an email from his friend Polycarp. However, Polycarp's keyboard is broken, so pressing a key on it once may cause the corresponding symbol to appear more than once (if you press a key on a regular keyboard, it prints exactly one symbol).
For example, as a result of typing the word "hello", the following words could be printed: "hello", "hhhhello", "hheeeellllooo", but the following could not be printed: "hell", "helo", "hhllllooo".
Note, that when you press a key, the corresponding symbol must appear (possibly, more than once). The keyboard is broken in a random manner, it means that pressing the same key you can get the different number of letters in the result.
For each word in the letter, Methodius has guessed what word Polycarp actually wanted to write, but he is not sure about it, so he asks you to help him.
You are given a list of pairs of words. For each pair, determine if the second word could be printed by typing the first one on Polycarp's keyboard.
Input
The first line of the input contains one integer n (1 β€ n β€ 10^5) β the number of pairs to check. Further input contains n descriptions of pairs.
The first line of each description contains a single non-empty word s consisting of lowercase Latin letters. The second line of the description contains a single non-empty word t consisting of lowercase Latin letters. The lengths of both strings are not greater than 10^6.
It is guaranteed that the total length of all words s in the input is not greater than 10^6. Also, it is guaranteed that the total length of all words t in the input is not greater than 10^6.
Output
Output n lines. In the i-th line for the i-th pair of words s and t print YES if the word t could be printed by typing the word s. Otherwise, print NO.
Examples
Input
4
hello
hello
hello
helloo
hello
hlllloo
hello
helo
Output
YES
YES
NO
NO
Input
5
aa
bb
codeforces
codeforce
polycarp
poolycarpp
aaaa
aaaab
abcdefghijklmnopqrstuvwxyz
zabcdefghijklmnopqrstuvwxyz
Output
NO
NO
YES
NO
NO
|
def f():
a=input()
i=0
p=a[i]
l=[]
while(i<len(a)):
temp=1
t=[p]
i+=1
while(i<len(a)):
if a[i]!=p:
p=a[i]
break
p=a[i]
t.append(p)
i+=1
if i==len(a):
temp=0
break
l.append(t)
if temp==0:
break
a=input()
i=0
p=a[i]
l1=[]
while(i<len(a)):
temp=1
t=[p]
i+=1
while(i<len(a)):
if a[i]!=p:
p=a[i]
break
p=a[i]
t.append(p)
i+=1
if i==len(a):
temp=0
break
l1.append(t)
if temp==0:
break
if len(l)!=len(l1):
return 0
for i in range(0,len(l)):
if l[i][0]!=l1[i][0] or len(l[i])>len(l1[i]):
return 0
return 1
for i in range(int(input())):
if f():
print ("YES")
else:
print("NO")
|
The only difference between easy and hard versions is that you should complete all the projects in easy version but this is not necessary in hard version.
Polycarp is a very famous freelancer. His current rating is r units.
Some very rich customers asked him to complete some projects for their companies. To complete the i-th project, Polycarp needs to have at least a_i units of rating; after he completes this project, his rating will change by b_i (his rating will increase or decrease by b_i) (b_i can be positive or negative). Polycarp's rating should not fall below zero because then people won't trust such a low rated freelancer.
Is it possible to complete all the projects? Formally, write a program to check if such an order of the projects exists, that Polycarp has enough rating before starting each project, and he has non-negative rating after completing each project.
In other words, you have to check that there exists such an order of projects in which Polycarp will complete them, so he has enough rating before starting each project, and has non-negative rating after completing each project.
Input
The first line of the input contains two integers n and r (1 β€ n β€ 100, 1 β€ r β€ 30000) β the number of projects and the initial rating of Polycarp, respectively.
The next n lines contain projects, one per line. The i-th project is represented as a pair of integers a_i and b_i (1 β€ a_i β€ 30000, -300 β€ b_i β€ 300) β the rating required to complete the i-th project and the rating change after the project completion.
Output
Print "YES" or "NO".
Examples
Input
3 4
4 6
10 -2
8 -1
Output
YES
Input
3 5
4 -5
4 -2
1 3
Output
YES
Input
4 4
5 2
5 -3
2 1
4 -2
Output
YES
Input
3 10
10 0
10 -10
30 0
Output
NO
Note
In the first example, the possible order is: 1, 2, 3.
In the second example, the possible order is: 2, 3, 1.
In the third example, the possible order is: 3, 1, 4, 2.
|
n,r = map(int,(input().split()))
plus=[]
minn=[]
for i in range (0,n):
temp = list(map(int,input().split()))
if temp[1] <=0:
temp.append(temp[0]+temp[1])
minn.append(temp)
else:
plus.append(temp)
plus.sort()
minn.sort(reverse=True,key = lambda x: x[2])
flag = True
for i in plus:
if i[0] <= r:
r+= i[1]
#print(r)
else:
flag=False
break
#print("GANTI")
if flag:
for i in minn:
if i[0] <= r:
r +=i[1]
#print(r)
else:
flag=False
break
if flag and r>=0:
print("YES")
else:
print("NO")
|
Boy Dima gave Julian a birthday present β set B consisting of positive integers. However, he didn't know, that Julian hates sets, but enjoys bipartite graphs more than anything else!
Julian was almost upset, but her friend Alex said, that he can build an undirected graph using this set in such a way: let all integer numbers be vertices, then connect any two i and j with an edge if |i - j| belongs to B.
Unfortunately, Julian doesn't like the graph, that was built using B. Alex decided to rectify the situation, so he wants to erase some numbers from B, so that graph built using the new set is bipartite. The difficulty of this task is that the graph, Alex has to work with, has an infinite number of vertices and edges! It is impossible to solve this task alone, so Alex asks you for help. Write a program that erases a subset of minimum size from B so that graph constructed on the new set is bipartite.
Recall, that graph is bipartite if all its vertices can be divided into two disjoint sets such that every edge connects a vertex from different sets.
Input
First line contains an integer n ~ (1 β©½ n β©½ 200 000) β size of B
Second line contains n integers b_1, b_2, β¦, b_n ~ (1 β©½ b_i β©½ 10^{18}) β numbers of B, all b_i are unique
Output
In the first line print single integer k β the number of erased elements. In the second line print k integers β values of erased elements.
If there are multiple answers, print any of them.
Examples
Input
3
1 2 3
Output
1
2
Input
2
2 6
Output
0
|
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
const int N = 2e5 + 10, E = 65;
int n, cnt[E];
ll a[N];
int main() {
scanf("%d", &n);
for (auto i = 0, _end = n - 1; i <= _end; ++i) {
scanf("%lld", a + i);
cnt[__builtin_ctzll(a[i])]++;
}
int ans = max_element(cnt, cnt + E) - cnt;
printf("%d\n", n - cnt[ans]);
for (auto i = 0, _end = n - 1; i <= _end; ++i)
if (__builtin_ctzll(a[i]) != ans) printf("%lld ", a[i]);
puts("");
}
|
While doing some spring cleaning, Daniel found an old calculator that he loves so much. However, it seems like it is broken. When he tries to compute 1 + 3 using the calculator, he gets 2 instead of 4. But when he tries computing 1 + 4, he gets the correct answer, 5. Puzzled by this mystery, he opened up his calculator and found the answer to the riddle: the full adders became half adders!
So, when he tries to compute the sum a + b using the calculator, he instead gets the xorsum a β b (read the definition by the link: <https://en.wikipedia.org/wiki/Exclusive_or>).
As he saw earlier, the calculator sometimes gives the correct answer. And so, he wonders, given integers l and r, how many pairs of integers (a, b) satisfy the following conditions: $$$a + b = a β b l β€ a β€ r l β€ b β€ r$$$
However, Daniel the Barman is going to the bar and will return in two hours. He tells you to solve the problem before he returns, or else you will have to enjoy being blocked.
Input
The first line contains a single integer t (1 β€ t β€ 100) β the number of testcases.
Then, t lines follow, each containing two space-separated integers l and r (0 β€ l β€ r β€ 10^9).
Output
Print t integers, the i-th integer should be the answer to the i-th testcase.
Example
Input
3
1 4
323 323
1 1000000
Output
8
0
3439863766
Note
a β b denotes the bitwise XOR of a and b.
For the first testcase, the pairs are: (1, 2), (1, 4), (2, 1), (2, 4), (3, 4), (4, 1), (4, 2), and (4, 3).
|
#include <bits/stdc++.h>
using namespace std;
long long dp[40][2][2];
int digA[40], digB[40];
long long dfs(int pos, bool limA, bool limB) {
if (!pos) return 1;
long long &val = dp[pos][limA][limB];
if (val != -1) return val;
int mxA = limA ? digA[pos] : 1;
int mxB = limB ? digB[pos] : 1;
val = 0;
for (int i = 0; i <= mxA; i++) {
for (int j = 0; j <= mxB; j++) {
if (i == 1 && j == 1) continue;
val += dfs(pos - 1, limA && i == mxA, limB && j == mxB);
}
}
return val;
}
long long solve(int a, int b) {
if (a < 0 || b < 0) return 0;
memset(dp, -1, sizeof(dp));
if (a < b) swap(a, b);
int cnt = 0;
while (a > 0) {
digA[++cnt] = a & 1;
a >>= 1;
}
for (int i = 0; i < cnt; i++) {
digB[i + 1] = b & 1;
b >>= 1;
}
return dfs(cnt, true, true);
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
long long l, r;
scanf("%lld%lld", &l, &r);
long long ans = solve(r, r) - (solve(r, l - 1)) * 2 + solve(l - 1, l - 1);
printf("%lld\n", ans);
}
return 0;
}
|
An integer sequence is called beautiful if the difference between any two consecutive numbers is equal to 1. More formally, a sequence s_1, s_2, β¦, s_{n} is beautiful if |s_i - s_{i+1}| = 1 for all 1 β€ i β€ n - 1.
Trans has a numbers 0, b numbers 1, c numbers 2 and d numbers 3. He wants to construct a beautiful sequence using all of these a + b + c + d numbers.
However, it turns out to be a non-trivial task, and Trans was not able to do it. Could you please help Trans?
Input
The only input line contains four non-negative integers a, b, c and d (0 < a+b+c+d β€ 10^5).
Output
If it is impossible to construct a beautiful sequence satisfying the above constraints, print "NO" (without quotes) in one line.
Otherwise, print "YES" (without quotes) in the first line. Then in the second line print a + b + c + d integers, separated by spaces β a beautiful sequence. There should be a numbers equal to 0, b numbers equal to 1, c numbers equal to 2 and d numbers equal to 3.
If there are multiple answers, you can print any of them.
Examples
Input
2 2 2 1
Output
YES
0 1 0 1 2 3 2
Input
1 2 3 4
Output
NO
Input
2 2 2 3
Output
NO
Note
In the first test, it is easy to see, that the sequence is beautiful because the difference between any two consecutive numbers is equal to 1. Also, there are exactly two numbers, equal to 0, 1, 2 and exactly one number, equal to 3.
It can be proved, that it is impossible to construct beautiful sequences in the second and third tests.
|
_count = list(map(int, input().split()))
num = '0 1 2 3'.split()
for pos in range(4):
count = _count[:]
ans = []
for i in range(sum(count)):
ans.append(num[pos])
count[pos] -= 1
if pos == 1:
if count[0] > 0:
pos = 0
else:
pos = 2
elif pos == 2:
if count[3] > 0:
pos = 3
else:
pos = 1
elif pos == 0:
pos = 1
elif pos == 3:
pos = 2
if max(count) == min(count) == 0:
print('YES')
print(*ans)
exit()
else:
print('NO')
|
To defeat Lord Voldemort, Harry needs to destroy all horcruxes first. The last horcrux is an array a of n integers, which also needs to be destroyed. The array is considered destroyed if all its elements are zeroes. To destroy the array, Harry can perform two types of operations:
1. choose an index i (1 β€ i β€ n), an integer x, and subtract x from a_i.
2. choose two indices i and j (1 β€ i, j β€ n; i β j), an integer x, and subtract x from a_i and x + 1 from a_j.
Note that x does not have to be positive.
<image>
Harry is in a hurry, please help him to find the minimum number of operations required to destroy the array and exterminate Lord Voldemort.
Input
The first line contains a single integer n β the size of the array a (1 β€ n β€ 20).
The following line contains n integers a_1, a_2, β¦, a_n β array elements (-10^{15} β€ a_i β€ 10^{15}).
Output
Output a single integer β the minimum number of operations required to destroy the array a.
Examples
Input
3
1 10 100
Output
3
Input
3
5 3 -2
Output
2
Input
1
0
Output
0
Note
In the first example one can just apply the operation of the first kind three times.
In the second example, one can apply the operation of the second kind two times: first, choose i = 2, j = 1, x = 4, it transforms the array into (0, -1, -2), and then choose i = 3, j = 2, x = -2 to destroy the array.
In the third example, there is nothing to be done, since the array is already destroyed.
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 25;
const int maxs = 1 << 20;
template <typename T>
void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
int n, u, dp[maxs];
long long a[maxn];
int bit[maxn], cnt[maxs];
long long sum[maxs];
bool check(int s) {
if (cnt[s] == 1) return sum[s] == 0;
if ((sum[s] + cnt[s]) % 2 == 0) return false;
int tmp = s;
for (int i = 1; i <= n; i++)
if (bit[i] & s) tmp = s ^ bit[i];
for (int t = tmp; t != 0; t = (t - 1) & s) {
long long tmp = sum[t] * 2 - sum[s];
if (tmp >= -cnt[s] + 1 && tmp <= cnt[s] - 1) return true;
}
return false;
}
int main() {
read(n), u = (1 << n) - 1;
for (int i = 1; i <= n; i++) read(a[i]), bit[i] = 1 << (i - 1);
for (int s = 0; s <= u; s++)
for (int i = 1; i <= n; i++)
if (bit[i] & s) {
cnt[s]++;
sum[s] += a[i];
}
for (int s = 1; s <= u; s++) dp[s] = check(s);
for (int s = 1; s <= u; s++)
for (int t = (s - 1) & s; t != 0; t = (t - 1) & s)
chkmax(dp[s], dp[t] + dp[s ^ t]);
cout << n - dp[u] << endl;
}
|
As a professional private tutor, Kuroni has to gather statistics of an exam. Kuroni has appointed you to complete this important task. You must not disappoint him.
The exam consists of n questions, and m students have taken the exam. Each question was worth 1 point. Question i was solved by at least l_i and at most r_i students. Additionally, you know that the total score of all students is t.
Furthermore, you took a glance at the final ranklist of the quiz. The students were ranked from 1 to m, where rank 1 has the highest score and rank m has the lowest score. Ties were broken arbitrarily.
You know that the student at rank p_i had a score of s_i for 1 β€ i β€ q.
You wonder if there could have been a huge tie for first place. Help Kuroni determine the maximum number of students who could have gotten as many points as the student with rank 1, and the maximum possible score for rank 1 achieving this maximum number of students.
Input
The first line of input contains two integers (1 β€ n, m β€ 10^{5}), denoting the number of questions of the exam and the number of students respectively.
The next n lines contain two integers each, with the i-th line containing l_{i} and r_{i} (0 β€ l_{i} β€ r_{i} β€ m).
The next line contains a single integer q (0 β€ q β€ m).
The next q lines contain two integers each, denoting p_{i} and s_{i} (1 β€ p_{i} β€ m, 0 β€ s_{i} β€ n). It is guaranteed that all p_{i} are distinct and if p_{i} β€ p_{j}, then s_{i} β₯ s_{j}.
The last line contains a single integer t (0 β€ t β€ nm), denoting the total score of all students.
Output
Output two integers: the maximum number of students who could have gotten as many points as the student with rank 1, and the maximum possible score for rank 1 achieving this maximum number of students. If there is no valid arrangement that fits the given data, output -1 -1.
Examples
Input
5 4
2 4
2 3
1 1
0 1
0 0
1
4 1
7
Output
3 2
Input
5 6
0 6
0 6
2 5
6 6
4 6
1
3 3
30
Output
-1 -1
Note
For the first sample, here is one possible arrangement that fits the data:
Students 1 and 2 both solved problems 1 and 2.
Student 3 solved problems 2 and 3.
Student 4 solved problem 4.
The total score of all students is T = 7. Note that the scores of the students are 2, 2, 2 and 1 respectively, which satisfies the condition that the student at rank 4 gets exactly 1 point. Finally, 3 students tied for first with a maximum score of 2, and it can be proven that we cannot do better with any other arrangement.
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class t, class u>
void chmax(t& first, u second) {
if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using pi = pair<ll, ll>;
using vi = vc<ll>;
template <class t, class u>
ostream& operator<<(ostream& os, const pair<t, u>& p) {
return os << "{" << p.first << "," << p.second << "}";
}
template <class t>
ostream& operator<<(ostream& os, const vc<t>& v) {
os << "{";
for (auto e : v) os << e << ",";
return os << "}";
}
using uint = unsigned;
using ull = unsigned long long;
template <class t, size_t n>
ostream& operator<<(ostream& os, const array<t, n>& first) {
return os << vc<t>(first.begin(), first.end());
}
template <ll i, class T>
void print_tuple(ostream&, const T&) {}
template <ll i, class T, class H, class... Args>
void print_tuple(ostream& os, const T& t) {
if (i) os << ",";
os << get<i>(t);
print_tuple<i + 1, T, Args...>(os, t);
}
template <class... Args>
ostream& operator<<(ostream& os, const tuple<Args...>& t) {
os << "{";
print_tuple<0, tuple<Args...>, Args...>(os, t);
return os << "}";
}
template <class t>
void print(t x, ll suc = 1) {
cout << x;
if (suc == 1) cout << "\n";
if (suc == 2) cout << " ";
}
ll read() {
ll i;
cin >> i;
return i;
}
vi readvi(ll n, ll off = 0) {
vi v(n);
for (ll i = ll(0); i < ll(n); i++) v[i] = read() + off;
return v;
}
template <class T>
void print(const vector<T>& v, ll suc = 1) {
for (ll i = ll(0); i < ll(v.size()); i++)
print(v[i], i == ll(v.size()) - 1 ? suc : 2);
}
string readString() {
string s;
cin >> s;
return s;
}
template <class T>
T sq(const T& t) {
return t * t;
}
void yes(bool ex = true) {
cout << "Yes"
<< "\n";
if (ex) exit(0);
}
void no(bool ex = true) {
cout << "No"
<< "\n";
if (ex) exit(0);
}
void possible(bool ex = true) {
cout << "Possible"
<< "\n";
if (ex) exit(0);
}
void impossible(bool ex = true) {
cout << "Impossible"
<< "\n";
if (ex) exit(0);
}
constexpr ll ten(ll n) { return n == 0 ? 1 : ten(n - 1) * 10; }
const ll infLL = LLONG_MAX / 3;
const ll inf = infLL;
ll topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
ll topbit(ll t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
ll botbit(signed first) { return first == 0 ? 32 : __builtin_ctz(first); }
ll botbit(ll first) { return first == 0 ? 64 : __builtin_ctzll(first); }
ll popcount(signed t) { return __builtin_popcount(t); }
ll popcount(ll t) { return __builtin_popcountll(t); }
bool ispow2(ll i) { return i && (i & -i) == i; }
ll mask(ll i) { return (ll(1) << i) - 1; }
template <class t>
bool inc(t first, t second, t c) {
return first <= second && second <= c;
}
template <class t>
void mkuni(vc<t>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
ll rand_int(ll l, ll r) {
static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<ll>(l, r)(gen);
}
template <class t>
ll lwb(const vc<t>& v, const t& first) {
return lower_bound(v.begin(), v.end(), first) - v.begin();
}
void muri() {
cout << "-1 -1" << endl;
exit(0);
}
ll ganbaruzoi(vi first, vi lw, vi up, ll z) {
for (ll i = ll(0); i < ll(z); i++) chmin(up[i], up[z - 1]);
for (ll i = ll(0); i < ll(z); i++) chmax(lw[i], lw[0]);
for (ll i = ll(0); i < ll(z); i++)
if (lw[i] > up[i]) return -1;
ll n = ll(first.size());
ll zorg = z;
while (z < n && up[z] == inf) z++;
ll need = 0, sum = 0, lim = 0;
ll aff = 0;
for (ll i = ll(n) - 1; i >= ll(0); i--) {
if (first[i] < lw[i]) {
need += lw[i] - first[i];
} else {
ll u = first[i] - lw[i];
{
ll w = min(u, need);
u -= w;
need -= w;
sum += w;
assert(sum <= lim);
}
if (need == 0 && u > up[i] - lw[i]) {
ll w = min(u - (up[i] - lw[i]), lim - sum);
assert(w >= 0);
u -= w;
sum += w;
assert(sum <= lim);
}
first[i] = lw[i] + u;
if (first[i] > up[i]) return -1;
}
sum += first[i];
lim += up[i];
chmin(lim, inf);
if (i == z) aff = lim - (sum + need);
}
if (need > 0) return -1;
if (up[0] == inf) {
for (ll i = ll(0); i < ll(z); i++) chmax(first[i], lw[i]);
ll s = accumulate(first.begin(), first.begin() + zorg, ll(0));
ll p = s / zorg, q = s % zorg;
assert(p >= lw[0]);
for (ll i = ll(zorg); i < ll(z); i++) aff += p - first[i];
if (q <= aff)
return p;
else
return -1;
} else {
assert(lw[0] == up[0]);
assert(lw[0] == first[0]);
return first[0];
}
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
ll n, m;
cin >> n >> m;
vi first(m + 1), second(m + 1);
for (ll i = ll(0); i < ll(n); i++) {
ll l, r;
cin >> l >> r;
first[0]++;
first[l]--;
second[l]++;
second[r]--;
}
for (ll i = ll(0); i < ll(m); i++) first[i + 1] += first[i];
for (ll i = ll(0); i < ll(m); i++) second[i + 1] += second[i];
first.pop_back();
second.pop_back();
vi lw(m, 0), up(m, inf);
{
ll q;
cin >> q;
for (ll _ = ll(0); _ < ll(q); _++) {
ll p, s;
cin >> p >> s;
p--;
chmax(lw[p], s);
chmin(up[p], s);
}
for (ll i = ll(0); i < ll(m - 1); i++) chmin(up[i + 1], up[i]);
for (ll i = ll(m - 1) - 1; i >= ll(0); i--) chmax(lw[i], lw[i + 1]);
}
{
ll t;
cin >> t;
for (ll i = ll(0); i < ll(m); i++) t -= first[i];
if (t < 0) muri();
for (ll i = ll(0); i < ll(m); i++) {
ll u = min(t, second[i]);
first[i] += u;
t -= u;
}
if (t > 0) muri();
for (ll i = ll(0); i < ll(m - 1); i++) assert(first[i] >= first[i + 1]);
}
void(0);
ll ok = 0, ng = m + 1;
while (ng - ok > 1) {
const ll mid = (ok + ng) / 2;
ll w = ganbaruzoi(first, lw, up, mid);
if (w != -1)
ok = mid;
else
ng = mid;
}
if (ok == 0) muri();
ll w = ganbaruzoi(first, lw, up, ok);
cout << ok << " " << w << endl;
}
|
Another feature of Shakespeare language is that the variables are named after characters of plays by Shakespeare, and all operations on them (value assignment, output etc.) look like a dialog with other characters. New values of variables are defined in a rather lengthy way, so a programmer should try to minimize their usage.
You have to print the given sequence of n integers. To do this, you have m variables and two types of operations on them:
* variable=integer
* print(variable)
Any of the m variables can be used as variable. Variables are denoted by lowercase letters between "a" and "z", inclusive. Any integer number can be used as integer.
Let's say that the penalty for using first type of operations equals to the number of set bits in the number integer. There is no penalty on using second type of operations. Find and output the program which minimizes the penalty for printing the given sequence of numbers.
Input
The first line of input contains integers n and m (1 β€ n β€ 250, 1 β€ m β€ 26). The second line contains the sequence to be printed. Each element of the sequence is an integer between 1 and 109, inclusive. The sequence has to be printed in the given order (from left to right).
Output
Output the number of lines in the optimal program and the optimal penalty. Next, output the program itself, one command per line. If there are several programs with minimal penalty, output any of them (you have only to minimize the penalty).
Examples
Input
7 2
1 2 2 4 2 1 2
Output
11 4
b=1
print(b)
a=2
print(a)
print(a)
b=4
print(b)
print(a)
b=1
print(b)
print(a)
Input
6 3
1 2 3 1 2 3
Output
9 4
c=1
print(c)
b=2
print(b)
a=3
print(a)
print(c)
print(b)
print(a)
|
#include <bits/stdc++.h>
using namespace std;
const int MAXV = 600, MAXE = 70000, inf = 1000000000;
int N, Count;
int G[MAXV], Queue[MAXV], Dist[MAXV], Pre[MAXV], Last[MAXV];
int Data[MAXE], Weight[MAXE], Cost[MAXE], Next[MAXE];
bool Flag[MAXV];
int Calc(int X) {
if (!X) return 0;
return Calc(X / 2) + X % 2;
}
void Add(int Number, int V1, int V2, int W, int C) {
Data[Number] = V2;
Weight[Number] = W;
Cost[Number] = C;
Next[Number] = G[V1];
G[V1] = Number;
}
void Connect(int V1, int V2, int W, int C) {
Add(Count++, V1, V2, W, C);
Add(Count++, V2, V1, 0, -C);
}
int SPFA(int S, int T) {
for (int i = 0; i <= T; i++) Dist[i] = inf;
Dist[S] = 0;
memset(Flag, 0, sizeof(Flag));
Queue[0] = S;
int F = 0, R = 1;
while (F != R) {
int V = Queue[F++];
if (F == MAXV) F = 0;
int P = G[V];
Flag[V] = false;
while (P != -1) {
int U = Data[P];
if (Weight[P] && Dist[V] + Cost[P] < Dist[U]) {
Dist[U] = Dist[V] + Cost[P];
Pre[U] = P;
if (!Flag[U]) Flag[Queue[R++] = U] = true;
if (R == MAXV) R = 0;
}
P = Next[P];
}
}
if (Dist[T] == inf) return -1;
int V = T;
while (V != S) {
Weight[Pre[V]]--;
Weight[Pre[V] ^ 1]++;
int U = Data[Pre[V] ^ 1];
if (U <= N && V > N) Last[V - N - 1] = U;
V = U;
}
return Dist[T];
}
int main() {
int M;
cin >> N >> M;
int A[250];
for (int i = 0; i < N; i++) cin >> A[i];
int S = N * 2 + 1, T = N * 2 + 2;
Count = 0;
for (int i = 0; i <= T; i++) G[i] = -1;
for (int i = 0; i < N; i++) Connect(S, i, 1, 0);
Connect(S, N, M, 0);
for (int i = 0; i < N; i++)
for (int j = i + 1; j < N; j++)
if (A[i] == A[j])
Connect(i, N + j + 1, 1, 0);
else
Connect(i, N + j + 1, 1, Calc(A[j]));
for (int i = 0; i < N; i++) Connect(N, N + i + 1, 1, Calc(A[i]));
for (int i = 1; i <= N; i++) Connect(N + i, T, 1, 0);
int Ans = 0, Tmp;
while (Tmp = SPFA(S, T), Tmp != -1) Ans += Tmp;
int Total = N;
for (int i = 0; i < N; i++)
if (Last[i] == N || A[Last[i]] != A[i]) Total++;
cout << Total << ' ' << Ans << endl;
int Number = 0, Var[250];
for (int i = 0; i < N; i++)
if (Last[i] == N) {
Var[i] = Number++;
printf("%c=%d\nprint(%c)\n", Var[i] + 97, A[i], Var[i] + 97);
} else if (A[i] == A[Last[i]]) {
Var[i] = Var[Last[i]];
printf("print(%c)\n", Var[i] + 97);
} else {
Var[i] = Var[Last[i]];
printf("%c=%d\nprint(%c)\n", Var[i] + 97, A[i], Var[i] + 97);
}
return 0;
}
|
There are n players sitting at a round table. All of them have s cards of n colors in total. Besides, initially the first person had cards of only the first color, the second one had cards of only the second color and so on. They can swap the cards by the following rules:
* as the players swap, a player can give a card of his color only;
* a player can't accept a card of a color he already has (particularly, he can't take cards of his color, no matter whether he has given out all of them or not);
* during one swap a pair of people swaps cards (each person gives one card and takes one card).
The aim of all n people is as follows: each of them should give out all the cards he had initially (that is, all cards of his color). Your task is to denote whether such sequence of swaps is possible. If the answer is positive, you should list all the swaps.
Input
The first line contains integers n (1 β€ n β€ 200000) and s (1 β€ s β€ 200000). The second line contains n numbers, the i-th number stands for how many cards the i-th player has by the moment the game starts. It is possible that a player has no cards initially.
Output
On the first line print "No" if such sequence of swaps is impossible. Otherwise, print "Yes". If the answer is positive, next print number k β the number of the swaps. Then on k lines describe the swaps by pairs of indices of the swapping players. Print the swaps and the numbers of the swaps in any order.
Examples
Input
4 8
2 2 2 2
Output
Yes
4
4 3
4 2
1 3
1 2
Input
6 12
1 1 2 2 3 3
Output
Yes
6
6 5
6 4
6 3
5 4
5 3
2 1
Input
5 5
0 0 0 0 5
Output
No
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200001;
struct DIY {
int x, y;
};
DIY a[maxn], h[maxn], ans[maxn], t;
int n, s, m, len = 0;
void down(int x) {
int y;
while ((x * 2 <= m) && (h[x * 2].x > h[x].x) ||
(x * 2 + 1 <= m) && (h[x * 2 + 1].x > h[x].x)) {
y = x * 2;
if ((y + 1 <= m) && (h[y + 1].x > h[y].x)) y = y + 1;
h[0] = h[x];
h[x] = h[y];
h[y] = h[0];
x = y;
}
}
void up(int x) {
int y;
while ((x > 1) && (h[x / 2].x < h[x].x)) {
y = x / 2;
h[0] = h[x];
h[x] = h[y];
h[y] = h[0];
x = y;
}
}
int main() {
cin >> n >> s;
m = 0;
for (int i = 1; i <= n; i++) {
m = m + 1;
cin >> h[m].x;
if (h[m].x != 0) {
h[m].y = i;
up(m);
} else
m = m - 1;
}
while (m > 0) {
if (h[1].x > (m - 1)) {
cout << "No";
return 0;
}
t = h[1];
h[1] = h[m];
m = m - 1;
down(1);
for (int i = 1; i <= t.x; i++) {
a[i] = h[1];
h[1] = h[m];
m = m - 1;
down(1);
}
for (int i = 1; i <= t.x; i++) {
len = len + 1;
ans[len].x = t.y;
ans[len].y = a[i].y;
a[i].x = a[i].x - 1;
if (a[i].x != 0) {
m = m + 1;
h[m] = a[i];
up(m);
}
}
}
cout << "Yes" << endl << len << endl;
for (int i = 1; i <= len; i++) cout << ans[i].x << " " << ans[i].y << endl;
return 0;
}
|
Ashishgup and FastestFinger play a game.
They start with a number n and play in turns. In each turn, a player can make any one of the following moves:
* Divide n by any of its odd divisors greater than 1.
* Subtract 1 from n if n is greater than 1.
Divisors of a number include the number itself.
The player who is unable to make a move loses the game.
Ashishgup moves first. Determine the winner of the game if both of them play optimally.
Input
The first line contains a single integer t (1 β€ t β€ 100) β the number of test cases. The description of the test cases follows.
The only line of each test case contains a single integer β n (1 β€ n β€ 10^9).
Output
For each test case, print "Ashishgup" if he wins, and "FastestFinger" otherwise (without quotes).
Example
Input
7
1
2
3
4
5
6
12
Output
FastestFinger
Ashishgup
Ashishgup
FastestFinger
Ashishgup
FastestFinger
Ashishgup
Note
In the first test case, n = 1, Ashishgup cannot make a move. He loses.
In the second test case, n = 2, Ashishgup subtracts 1 on the first move. Now n = 1, FastestFinger cannot make a move, so he loses.
In the third test case, n = 3, Ashishgup divides by 3 on the first move. Now n = 1, FastestFinger cannot make a move, so he loses.
In the last test case, n = 12, Ashishgup divides it by 3. Now n = 4, FastestFinger is forced to subtract 1, and Ashishgup gets 3, so he wins by dividing it by 3.
|
import java.util.Scanner;
public class NumberGame {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int t = in.nextInt();
while (t > 0) {
int n = in.nextInt();
if (n == 2)
System.out.println("Ashishgup");
else if (n == 1 || (n & (n - 1)) == 0)
System.out.println("FastestFinger");
else if ((n & 1) == 1)
System.out.println("Ashishgup");
else if (n % 4 == 0 || !isPrime(n / 2))
System.out.println("Ashishgup");
else
System.out.println("FastestFinger");
t--;
}
}
private static boolean isPrime(int n) {
if ((n & 1) != 1)
return false;
for (long i = 3; i * i <= n; i += 2) {
if (n % i == 0)
return false;
}
return true;
}
}
|
zscoder has a deck of n+m custom-made cards, which consists of n cards labelled from 1 to n and m jokers. Since zscoder is lonely, he wants to play a game with himself using those cards.
Initially, the deck is shuffled uniformly randomly and placed on the table. zscoder has a set S which is initially empty.
Every second, zscoder draws the top card from the deck.
* If the card has a number x written on it, zscoder removes the card and adds x to the set S.
* If the card drawn is a joker, zscoder places all the cards back into the deck and reshuffles (uniformly randomly) the n+m cards to form a new deck (hence the new deck now contains all cards from 1 to n and the m jokers). Then, if S currently contains all the elements from 1 to n, the game ends. Shuffling the deck doesn't take time at all.
What is the expected number of seconds before the game ends? We can show that the answer can be written in the form P/Q where P, Q are relatively prime integers and Q β 0 mod 998244353. Output the value of (P β
Q^{-1}) modulo 998244353.
Input
The only line of the input contains two integers n and m (1 β€ n, m β€ 2 β
10^{6}).
Output
Output a single integer, the value of (P β
Q^{-1}) modulo 998244353.
Examples
Input
2 1
Output
5
Input
3 2
Output
332748127
Input
14 9
Output
969862773
Note
For the first sample, it can be proven that the expected time before the game ends is 5 seconds.
For the second sample, it can be proven that the expected time before the game ends is 28/3 seconds.
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
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);
HZSShufflesCards solver = new HZSShufflesCards();
solver.solve(1, in, out);
out.close();
}
static class HZSShufflesCards {
NumberTheory.Mod998 mod = new NumberTheory.Mod998();
int n;
int m;
public void solve(int testNumber, InputReader in, PrintWriter out) {
n = in.nextInt();
m = in.nextInt();
mod.fInv(n + m);
long phaseSize = 1;
long p = 1;
for (int i = 0; p != 0; i++) {
p = mod.mult(p, n - i, mod.smallInv(n + m - i));
phaseSize = mod.add(phaseSize, p);
}
long answer = 0;
for (int k = 1; k <= n; k++) {
long numPhases = mod.mult(m + k, mod.smallInv(k));
long term = mod.mult(mod.ncr(n, k), numPhases, phaseSize);
if (k % 2 == 1)
answer = mod.add(answer, term);
else
answer = mod.subtract(answer, term);
}
out.println(answer);
}
}
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 ASSERT(boolean assertion) {
if (!assertion)
throw new AssertionError();
}
private Util() {
}
}
static class IntStack {
int[] array;
int size = 0;
public IntStack() {
this(8);
}
public IntStack(int capacity) {
array = new int[capacity];
}
public void push(int item) {
if (size >= array.length)
array = resize(array);
array[size++] = item;
}
public int size() {
return size;
}
public int get(int i) {
Util.ASSERT(i < size);
return array[i];
}
private static int[] resize(int[] array) {
int[] newArray = new int[array.length << 1];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
public String toString() {
int[] trimmed = new int[size];
System.arraycopy(array, 0, trimmed, 0, size);
return Arrays.toString(trimmed);
}
}
static class NumberTheory {
private static void ASSERT(boolean assertion) {
if (!assertion)
throw new AssertionError();
}
public abstract static class Modulus<M extends NumberTheory.Modulus<M>> {
final IntStack factorial = new IntStack();
final IntStack invFactorial = new IntStack();
public abstract long modulus();
public Modulus() {
super();
factorial.push(1);
invFactorial.push(1);
}
public long fact(int n) {
while (factorial.size() <= n) {
factorial.push((int) mult(factorial.get(factorial.size() - 1), factorial.size()));
}
return factorial.get(n);
}
public long fInv(int n) {
int lastKnown = invFactorial.size() - 1;
if (lastKnown < n) {
long[] fInv = new long[n - lastKnown];
fInv[0] = inv(fact(n));
for (int i = 1; i < fInv.length; i++) {
fInv[i] = mult(fInv[i - 1], n - i + 1);
}
for (int i = fInv.length - 1; i >= 0; i--) {
invFactorial.push((int) fInv[i]);
}
}
return invFactorial.get(n);
}
public long ncr(int n, int r) {
ASSERT(n >= 0);
if (r < 0 || n < r)
return 0;
return mult(fact(n), mult(fInv(r), fInv(n - r)));
}
public long smallInv(int n) {
return mult(fInv(n), fact(n - 1));
}
public long normalize(long x) {
x %= modulus();
if (x < 0)
x += modulus();
return x;
}
public long add(long a, long b) {
long v = a + b;
return v < modulus() ? v : v - modulus();
}
public long subtract(long a, long b) {
long v = a - b;
return v < 0 ? v + modulus() : v;
}
public long mult(long... x) {
long r = 1;
for (long i : x)
r = mult(r, i);
return r;
}
public long mult(long a, long b) {
return (a * b) % modulus();
}
public long inv(long value) {
long g = modulus(), x = 0, y = 1;
for (long r = value; r != 0; ) {
long q = g / r;
g %= r;
long temp = g;
g = r;
r = temp;
x -= q * y;
temp = x;
x = y;
y = temp;
}
ASSERT(g == 1);
ASSERT(y == modulus() || y == -modulus());
return normalize(x);
}
}
public static class Mod998 extends NumberTheory.Modulus<NumberTheory.Mod998> {
public long modulus() {
return 998_244_353L;
}
}
}
}
|
You are given an array a consisting of n positive integers, numbered from 1 to n. You can perform the following operation no more than 3n times:
1. choose three integers i, j and x (1 β€ i, j β€ n; 0 β€ x β€ 10^9);
2. assign a_i := a_i - x β
i, a_j := a_j + x β
i.
After each operation, all elements of the array should be non-negative.
Can you find a sequence of no more than 3n operations after which all elements of the array are equal?
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 β€ n β€ 10^4) β the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^5) β the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^4.
Output
For each test case print the answer to it as follows:
* if there is no suitable sequence of operations, print -1;
* otherwise, print one integer k (0 β€ k β€ 3n) β the number of operations in the sequence. Then print k lines, the m-th of which should contain three integers i, j and x (1 β€ i, j β€ n; 0 β€ x β€ 10^9) for the m-th operation.
If there are multiple suitable sequences of operations, print any of them. Note that you don't have to minimize k.
Example
Input
3
4
2 16 4 18
6
1 2 3 4 5 6
5
11 19 1 1 3
Output
2
4 1 2
2 3 3
-1
4
1 2 4
2 4 5
2 3 3
4 5 1
|
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
from math import gcd, ceil
def pre(s):
n = len(s)
pi = [0] * n
for i in range(1, n):
j = pi[i - 1]
while j and s[i] != s[j]:
j = pi[j - 1]
if s[i] == s[j]:
j += 1
pi[i] = j
return pi
def prod(a):
ans = 1
for each in a:
ans = (ans * each)
return ans
def lcm(a, b): return a * b // gcd(a, b)
def binary(x, length=16):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
for _ in range(int(input()) if True else 1):
n = int(input())
#n, k = map(int, input().split())
#a, b = map(int, input().split())
#c, d = map(int, input().split())
a = list(map(int, input().split()))
#b = list(map(int, input().split()))
#s = input()
req = sum(a) / n
if req != int(req):
print(-1)
continue
req = int(req)
print((n-1)*3)
for i in range(1, n):
next = (i + 1 - a[i]) % (i+1)
print(1, i+1, next)
a[0] -= next
a[i] += next
print(i+1, 1, a[i]//(i+1))
a[0] += a[i]
a[i] = 0
for i in range(1, n):
print(1, i+1, req)
|
Tenten runs a weapon shop for ninjas. Today she is willing to sell n shurikens which cost 1, 2, ..., n ryo (local currency). During a day, Tenten will place the shurikens onto the showcase, which is empty at the beginning of the day. Her job is fairly simple: sometimes Tenten places another shuriken (from the available shurikens) on the showcase, and sometimes a ninja comes in and buys a shuriken from the showcase. Since ninjas are thrifty, they always buy the cheapest shuriken from the showcase.
Tenten keeps a record for all events, and she ends up with a list of the following types of records:
* + means that she placed another shuriken on the showcase;
* - x means that the shuriken of price x was bought.
Today was a lucky day, and all shurikens were bought. Now Tenten wonders if her list is consistent, and what could be a possible order of placing the shurikens on the showcase. Help her to find this out!
Input
The first line contains the only integer n (1β€ nβ€ 10^5) standing for the number of shurikens.
The following 2n lines describe the events in the format described above. It's guaranteed that there are exactly n events of the first type, and each price from 1 to n occurs exactly once in the events of the second type.
Output
If the list is consistent, print "YES". Otherwise (that is, if the list is contradictory and there is no valid order of shurikens placement), print "NO".
In the first case the second line must contain n space-separated integers denoting the prices of shurikens in order they were placed. If there are multiple answers, print any.
Examples
Input
4
+
+
- 2
+
- 3
+
- 1
- 4
Output
YES
4 2 3 1
Input
1
- 1
+
Output
NO
Input
3
+
+
+
- 2
- 1
- 3
Output
NO
Note
In the first example Tenten first placed shurikens with prices 4 and 2. After this a customer came in and bought the cheapest shuriken which costed 2. Next, Tenten added a shuriken with price 3 on the showcase to the already placed 4-ryo. Then a new customer bought this 3-ryo shuriken. After this she added a 1-ryo shuriken. Finally, the last two customers bought shurikens 1 and 4, respectively. Note that the order [2, 4, 3, 1] is also valid.
In the second example the first customer bought a shuriken before anything was placed, which is clearly impossible.
In the third example Tenten put all her shurikens onto the showcase, after which a customer came in and bought a shuriken with price 2. This is impossible since the shuriken was not the cheapest, we know that the 1-ryo shuriken was also there.
|
#include <bits/stdc++.h>
using namespace std;
int n, x;
char s[100086];
int id[100086], tag[100086], cnt;
int sk[100086], top;
int main() {
scanf("%d", &n);
for (int i = 1; i <= 2 * n; i++) {
scanf("%s", s);
if (s[0] == '+') {
sk[++top] = ++cnt;
} else {
scanf("%d", &x);
if (!top || tag[sk[top]] > x) return printf("NO"), 0;
id[sk[top--]] = x;
if (top) tag[sk[top]] = max(tag[sk[top]], x);
}
}
puts("YES");
for (int i = 1; i <= n; i++) printf("%d ", id[i]);
}
|
A robot is standing at the origin of the infinite two-dimensional plane. Each second the robot moves exactly 1 meter in one of the four cardinal directions: north, south, west, and east. For the first step the robot can choose any of the four directions, but then at the end of every second it has to turn 90 degrees left or right with respect to the direction it just moved in. For example, if the robot has just moved north or south, the next step it takes has to be either west or east, and vice versa.
The robot makes exactly n steps from its starting position according to the rules above. How many different points can the robot arrive to at the end? The final orientation of the robot can be ignored.
Input
The only line contains a single integer n (1 β€ n β€ 1000) β the number of steps the robot makes.
Output
Print a single integer β the number of different possible locations after exactly n steps.
Examples
Input
1
Output
4
Input
2
Output
4
Input
3
Output
12
Note
In the first sample case, the robot will end up 1 meter north, south, west, or east depending on its initial direction.
In the second sample case, the robot will always end up β{2} meters north-west, north-east, south-west, or south-east.
|
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.io.*;
import java.math.*;
public class Main7{
static public void main(String args[])throws IOException{
int tt=1;
StringBuilder sb=new StringBuilder();
for(int ttt=1;ttt<=tt;ttt++){
int n=i();
if(n%2==0){
int num=n/2+1;
int num1=0;
int rows=n+1;
int ans=0;
while(rows>0){
if(rows%2==0){
ans+=0;
}else{
ans+=num;
}
rows--;
}
sb.append(ans+"\n");
}else{
int num = n/2+1;
int num1=num+1;
int rows=n+2;
int ans=0;
while(rows>0){
if(rows%2==1){
ans+=num;
}else{
ans+=num1;
}
rows--;
}
sb.append(ans+"\n");
}
}
System.out.print(sb.toString());
}
static InputReader in=new InputReader(System.in);
static OutputWriter out=new OutputWriter(System.out);
static ArrayList<ArrayList<Integer>> graph;
static int mod=998244353;
static class Pair{
int x;
int y;
int z;
int dir;
Pair(int x,int y,int z,int dir){
this.x=x;
this.y=y;
this.z=z;
this.dir=dir;
}
/*@Override
public int hashCode()
{
final int temp = 14;
int ans = 1;
ans =x*31+y*13;
return (int)ans;
}
@Override
public boolean equals(Object o)
{
if (this == o) {
return true;
}
if (o == null) {
return false;
}
if (this.getClass() != o.getClass()) {
return false;
}
Pair other = (Pair)o;
if (this.x != other.x || this.y!=other.y) {
return false;
}
return true;
}*/
}
public static int[] sort(int[] a){
int n=a.length;
ArrayList<Integer> ar=new ArrayList<>();
for(int i=0;i<a.length;i++){
ar.add(a[i]);
}
Collections.sort(ar);
for(int i=0;i<n;i++){
a[i]=ar.get(i);
}
return a;
}
public static long pow(long a, long b){
long result=1;
while(b>0){
if (b % 2 != 0){
result=(result*a)%mod;
b--;
}
a=(a*a)%mod;
b /= 2;
}
return result;
}
public static long gcd(long a, long b){
if (a == 0){
return b;
}
return gcd(b%a, a);
}
public static long lcm(long a, long b){
return a*(b/gcd(a,b));
}
public static long l(){
String s=in.String();
return Long.parseLong(s);
}
public static void pln(String value){
System.out.println(value);
}
public static int i(){
return in.Int();
}
public static String s(){
return in.String();
}
}
class InputReader
{
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
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 Int() {
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 String String() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public String next() {
return String();
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
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();
}
public void flush() {
writer.flush();
}
}
class IOUtils {
public static int[] readIntArray(InputReader in, int size) {
int[] array = new int[size];
for (int i = 0; i < size; i++)
array[i] = in.Int();
return array;
}
}
|
Given a positive integer k, two arrays are called k-similar if:
* they are strictly increasing;
* they have the same length;
* all their elements are positive integers between 1 and k (inclusive);
* they differ in exactly one position.
You are given an integer k, a strictly increasing array a and q queries. For each query, you are given two integers l_i β€ r_i. Your task is to find how many arrays b exist, such that b is k-similar to array [a_{l_i},a_{l_i+1}β¦,a_{r_i}].
Input
The first line contains three integers n, q and k (1β€ n, q β€ 10^5, nβ€ k β€ 10^9) β the length of array a, the number of queries and number k.
The second line contains n integers a_1, a_2, β¦,a_n (1 β€ a_i β€ k). This array is strictly increasing β a_1 < a_2 < β¦ < a_n.
Each of the following q lines contains two integers l_i, r_i (1 β€ l_i β€ r_i β€ n).
Output
Print q lines. The i-th of them should contain the answer to the i-th query.
Examples
Input
4 2 5
1 2 4 5
2 3
3 4
Output
4
3
Input
6 5 10
2 4 6 7 8 9
1 4
1 2
3 5
1 6
5 5
Output
8
9
7
6
9
Note
In the first example:
In the first query there are 4 arrays that are 5-similar to [2,4]: [1,4],[3,4],[2,3],[2,5].
In the second query there are 3 arrays that are 5-similar to [4,5]: [1,5],[2,5],[3,5].
|
import javax.swing.event.ListDataEvent;
import javax.swing.plaf.FontUIResource;
import java.lang.reflect.Array;
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
static class Pair {
int tokens;
int index;
Pair(int tokens, int index) {
this.tokens = tokens;
this.index = index;
}
}
public static void main(String[] args) throws java.lang.Exception {
out = new PrintWriter(new BufferedOutputStream(System.out));
sc = new FastReader();
int test = 1;
for (int t = 0; t < test; t++) {
int n = sc.nextInt();
int q = sc.nextInt();
int k = sc.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = sc.nextInt();
}
for (int i = 0; i < q; i++) {
int l = sc.nextInt();
int r = sc.nextInt();
out.println(k + (arr[r - 1] - arr[l - 1] + 1) - 2 * (r - l + 1));
}
}
out.close();
}
public static FastReader sc;
public static PrintWriter out;
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
}
|
The student council is preparing for the relay race at the sports festival.
The council consists of n members. They will run one after the other in the race, the speed of member i is s_i. The discrepancy d_i of the i-th stage is the difference between the maximum and the minimum running speed among the first i members who ran. Formally, if a_i denotes the speed of the i-th member who participated in the race, then d_i = max(a_1, a_2, ..., a_i) - min(a_1, a_2, ..., a_i).
You want to minimize the sum of the discrepancies d_1 + d_2 + ... + d_n. To do this, you are allowed to change the order in which the members run. What is the minimum possible sum that can be achieved?
Input
The first line contains a single integer n (1 β€ n β€ 2000) β the number of members of the student council.
The second line contains n integers s_1, s_2, ..., s_n (1 β€ s_i β€ 10^9) β the running speeds of the members.
Output
Print a single integer β the minimum possible value of d_1 + d_2 + ... + d_n after choosing the order of the members.
Examples
Input
3
3 1 2
Output
3
Input
1
5
Output
0
Input
6
1 6 3 3 6 3
Output
11
Input
6
104 943872923 6589 889921234 1000000000 69
Output
2833800505
Note
In the first test case, we may choose to make the third member run first, followed by the first member, and finally the second. Thus a_1 = 2, a_2 = 3, and a_3 = 1. We have:
* d_1 = max(2) - min(2) = 2 - 2 = 0.
* d_2 = max(2, 3) - min(2, 3) = 3 - 2 = 1.
* d_3 = max(2, 3, 1) - min(2, 3, 1) = 3 - 1 = 2.
The resulting sum is d_1 + d_2 + d_3 = 0 + 1 + 2 = 3. It can be shown that it is impossible to achieve a smaller value.
In the second test case, the only possible rearrangement gives d_1 = 0, so the minimum possible result is 0.
|
n = int(input())
s = list(map(int, input().split()))
s.sort()
dp = [0]*n
for i in range(1, n):
for j in range(n-i):
dp[j] = s[i+j] - s[j] + min(dp[j], dp[j+1])
print(dp[0])
|
2^k teams participate in a playoff tournament. The tournament consists of 2^k - 1 games. They are held as follows: first of all, the teams are split into pairs: team 1 plays against team 2, team 3 plays against team 4 (exactly in this order), and so on (so, 2^{k-1} games are played in that phase). When a team loses a game, it is eliminated, and each game results in elimination of one team (there are no ties). After that, only 2^{k-1} teams remain. If only one team remains, it is declared the champion; otherwise, 2^{k-2} games are played: in the first one of them, the winner of the game "1 vs 2" plays against the winner of the game "3 vs 4", then the winner of the game "5 vs 6" plays against the winner of the game "7 vs 8", and so on. This process repeats until only one team remains.
For example, this picture describes the chronological order of games with k = 3:
<image>
Let the string s consisting of 2^k - 1 characters describe the results of the games in chronological order as follows:
* if s_i is 0, then the team with lower index wins the i-th game;
* if s_i is 1, then the team with greater index wins the i-th game;
* if s_i is ?, then the result of the i-th game is unknown (any team could win this game).
Let f(s) be the number of possible winners of the tournament described by the string s. A team i is a possible winner of the tournament if it is possible to replace every ? with either 1 or 0 in such a way that team i is the champion.
You are given the initial state of the string s. You have to process q queries of the following form:
* p c β replace s_p with character c, and print f(s) as the result of the query.
Input
The first line contains one integer k (1 β€ k β€ 18).
The second line contains a string consisting of 2^k - 1 characters β the initial state of the string s. Each character is either ?, 0, or 1.
The third line contains one integer q (1 β€ q β€ 2 β
10^5) β the number of queries.
Then q lines follow, the i-th line contains an integer p and a character c (1 β€ p β€ 2^k - 1; c is either ?, 0, or 1), describing the i-th query.
Output
For each query, print one integer β f(s).
Example
Input
3
0110?11
6
5 1
6 ?
7 ?
1 ?
5 ?
1 1
Output
1
2
3
3
5
4
|
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
import sys
from io import BytesIO, IOBase
def solve(z, dp, s):
n = len(dp)
while 1:
dp[z] = 0
if s[z] == '?':
if 2 * z + 1 < n:
dp[z] += dp[2 * z + 1]
else:
dp[z] += 1
if 2 * z + 2 < n:
dp[z] += dp[2 * z + 2]
else:
dp[z] += 1
elif s[z] == "1":
if 2 * z + 1 < n:
dp[z] += dp[2 * z + 1]
else:
dp[z] += 1
else:
if 2 * z + 2 < n:
dp[z] += dp[2 * z + 2]
else:
dp[z] += 1
if not z:
return
z = (z - 1) // 2
def main():
input()
s = list(input().rstrip())
s.reverse()
n = len(s)
dp = [0] * n
for i in range(n - 1, -1, -1):
if s[i] == "?":
if 2 * i + 1 < n:
dp[i] += dp[2 * i + 1]
else:
dp[i] += 1
if 2 * i + 2 < n:
dp[i] += dp[2 * i + 2]
else:
dp[i] += 1
elif s[i] == "1":
if 2 * i + 1 < n:
dp[i] += dp[2 * i + 1]
else:
dp[i] = 1
else:
if 2 * i + 2 < n:
dp[i] += dp[2 * i + 2]
else:
dp[i] = 1
for i in range(int(input())):
x, y = input().split()
x = n - int(x)
s[x] = y
solve(x, dp, s)
print(dp[0])
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
|
And here goes another problem on arrays. You are given positive integer len and array a which consists of n integers a1, a2, ..., an. Let's introduce two characteristics for the given array.
* Let's consider an arbitrary interval of the array with length len, starting in position i. Value <image>, is the modular sum on the chosen interval. In other words, the modular sum is the sum of integers on the chosen interval with length len, taken in its absolute value.
* Value <image> is the optimal sum of the array. In other words, the optimal sum of an array is the maximum of all modular sums on various intervals of array with length len.
Your task is to calculate the optimal sum of the given array a. However, before you do the calculations, you are allowed to produce no more than k consecutive operations of the following form with this array: one operation means taking an arbitrary number from array ai and multiply it by -1. In other words, no more than k times you are allowed to take an arbitrary number ai from the array and replace it with - ai. Each number of the array is allowed to choose an arbitrary number of times.
Your task is to calculate the maximum possible optimal sum of the array after at most k operations described above are completed.
Input
The first line contains two integers n, len (1 β€ len β€ n β€ 105) β the number of elements in the array and the length of the chosen subinterval of the array, correspondingly.
The second line contains a sequence consisting of n integers a1, a2, ..., an (|ai| β€ 109) β the original array.
The third line contains a single integer k (0 β€ k β€ n) β the maximum allowed number of operations.
All numbers in lines are separated by a single space.
Output
In a single line print the maximum possible optimal sum after no more than k acceptable operations are fulfilled.
Please do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
5 3
0 -2 3 -5 1
2
Output
10
Input
5 2
1 -3 -10 4 1
3
Output
14
Input
3 3
-2 -5 4
1
Output
11
|
#include <bits/stdc++.h>
using namespace std;
long long int a[100005];
long long int n, len, k;
class data {
public:
set<pair<long long int, long long int> > mx, mn;
long long int sum1, ksum;
data() { ksum = 0, sum1 = 0; }
void ins(long long int v, long long int index) {
sum1 += v;
ksum += v;
mx.insert(make_pair(v, index));
if (int((mx).size()) > k) {
pair<long long int, long long int> p = *(mx.begin());
mx.erase(p);
ksum -= p.first;
p.first = -p.first;
mn.insert(p);
}
}
void rem(long long int v, long long int index) {
sum1 -= v;
if (mx.count(make_pair(v, index))) {
ksum -= v;
mx.erase(make_pair(v, index));
if (int((mn).size()) > 0) {
pair<long long int, long long int> p = *(mn.begin());
mn.erase(p);
p.first = -p.first;
mx.insert(p);
ksum += p.first;
}
} else if (mn.count(make_pair(-v, index))) {
mn.erase(make_pair(-v, index));
}
}
};
data ap, an;
void ADD(long long int v, long long int index) {
if (v < 0)
an.ins(-v, index);
else
ap.ins(v, index);
}
void REMOVE(long long int v, long long int index) {
if (v < 0)
an.rem(-v, index);
else
ap.rem(v, index);
}
int main() {
long long int ans = 0;
cin >> n >> len;
for (long long int i = 0; i < n; i++) cin >> a[i];
cin >> k;
for (long long int i = 0; i < n; i++) {
ADD(a[i], i);
if (i >= len) REMOVE(a[i - len], i - len);
if (i >= len - 1)
ans = max(ans, max(ap.sum1 - an.sum1 + 2 * an.ksum,
an.sum1 + 2 * ap.ksum - ap.sum1));
}
cout << ans << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.