input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
You generate real numbers s1, s2, ..., sn as follows:
* s0 = 0;
* si = si - 1 + ti, where ti is a real number chosen independently uniformly at random between 0 and 1, inclusive.
You are given real numbers x1, x2, ..., xn. You are interested in the probability that si ≤ xi is true for all i simultaneously.
It can be shown that this can be represented as <image>, where P and Q are coprime integers, and <image>. Print the value of P·Q - 1 modulo 998244353.
Input
The first line contains integer n (1 ≤ n ≤ 30).
The next n lines contain real numbers x1, x2, ..., xn, given with at most six digits after the decimal point (0 < xi ≤ n).
Output
Print a single integer, the answer to the problem.
Examples
Input
4
1.00
2
3.000000
4.0
Output
1
Input
1
0.50216
Output
342677322
Input
2
0.5
1.0
Output
623902721
Input
6
0.77
1.234567
2.1
1.890
2.9999
3.77
Output
859831967
Note
In the first example, the sought probability is 1 since the sum of i real numbers which don't exceed 1 doesn't exceed i.
In the second example, the probability is x1 itself.
In the third example, the sought probability is 3 / 8.
|
#include <bits/stdc++.h>
using namespace std;
const int md = 998244353;
inline void add(int &a, int b) {
a += b;
if (a >= md) a -= md;
}
inline void sub(int &a, int b) {
a -= b;
if (a < 0) a += md;
}
inline int mul(int a, int b) { return (int)((long long)a * b % md); }
inline int power(int a, long long b) {
int res = 1;
while (b > 0) {
if (b & 1) {
res = mul(res, a);
}
a = mul(a, a);
b >>= 1;
}
return res;
}
inline int inv(int a) { return power(a, md - 2); }
vector<int> integrate(vector<int> a) {
vector<int> b = {0};
for (int i = 0; i < (int)a.size(); i++) {
b.push_back(mul(a[i], inv(i + 1)));
}
return b;
}
void sub(vector<int> &a, vector<int> b) {
while (a.size() < b.size()) {
a.push_back(0);
}
for (int i = 0; i < (int)b.size(); i++) {
sub(a[i], b[i]);
}
}
int eval(vector<int> a, int x) {
int res = 0;
for (int i = (int)a.size() - 1; i >= 0; i--) {
res = mul(res, x);
add(res, a[i]);
}
return res;
}
const int COEFF = 1000000;
int main() {
int n;
cin >> n;
vector<int> x(n), fracs;
for (int i = 0; i < n; i++) {
double foo;
cin >> foo;
x[i] = (int)(foo * COEFF + 0.5);
fracs.push_back(x[i] % COEFF);
}
fracs.push_back(0);
sort(fracs.begin(), fracs.end());
fracs.resize(unique(fracs.begin(), fracs.end()) - fracs.begin());
int cnt = (int)fracs.size();
vector<int> point(n * cnt + 1);
for (int i = 0; i <= n * cnt; i++) {
point[i] = i / cnt * COEFF + fracs[i % cnt];
}
vector<int> cut(n);
for (int i = 0; i < n; i++) {
cut[i] = (int)(find(point.begin(), point.end(), x[i]) - point.begin());
}
vector<int> sz(n * cnt);
for (int i = 0; i < n * cnt; i++) {
sz[i] = mul((point[i + 1] - point[i] + md) % md, inv(COEFF));
}
vector<vector<int> > a(n * cnt);
vector<int> sum(n * cnt);
for (int i = 0; i < n * cnt; i++) {
a[i] = i < min(cnt, cut[0]) ? vector<int>{0, 1} : vector<int>{0};
sum[i] = a[i].size() == 1 ? 0 : sz[i];
}
for (int id = 1; id < n; id++) {
for (int i = n * cnt - 1; i >= 0; i--) {
if (i >= cut[id]) {
a[i] = {0};
sum[i] = 0;
} else {
for (int j = i - 1; j >= i - cnt && j >= 0; j--) {
add(a[i][0], sum[j]);
}
if (i - cnt >= 0) {
sub(a[i], a[i - cnt]);
}
a[i] = integrate(a[i]);
sum[i] = eval(a[i], sz[i]);
}
}
}
int ans = 0;
for (int i = 0; i < n * cnt; i++) {
add(ans, sum[i]);
}
printf("%d\n", ans);
return 0;
}
|
Petya and Vasya arranged a game. The game runs by the following rules. Players have a directed graph consisting of n vertices and m edges. One of the vertices contains a chip. Initially the chip is located at vertex s. Players take turns moving the chip along some edge of the graph. Petya goes first. Player who can't move the chip loses. If the game lasts for 106 turns the draw is announced.
Vasya was performing big laboratory work in "Spelling and parts of speech" at night before the game, so he fell asleep at the very beginning of the game. Petya decided to take the advantage of this situation and make both Petya's and Vasya's moves.
Your task is to help Petya find out if he can win the game or at least draw a tie.
Input
The first line of input contain two integers n and m — the number of vertices and the number of edges in the graph (2 ≤ n ≤ 105, 0 ≤ m ≤ 2·105).
The next n lines contain the information about edges of the graph. i-th line (1 ≤ i ≤ n) contains nonnegative integer ci — number of vertices such that there is an edge from i to these vertices and ci distinct integers ai, j — indices of these vertices (1 ≤ ai, j ≤ n, ai, j ≠ i).
It is guaranteed that the total sum of ci equals to m.
The next line contains index of vertex s — the initial position of the chip (1 ≤ s ≤ n).
Output
If Petya can win print «Win» in the first line. In the next line print numbers v1, v2, ..., vk (1 ≤ k ≤ 106) — the sequence of vertices Petya should visit for the winning. Vertex v1 should coincide with s. For i = 1... k - 1 there should be an edge from vi to vi + 1 in the graph. There must be no possible move from vertex vk. The sequence should be such that Petya wins the game.
If Petya can't win but can draw a tie, print «Draw» in the only line. Otherwise print «Lose».
Examples
Input
5 6
2 2 3
2 4 5
1 4
1 5
0
1
Output
Win
1 2 4 5
Input
3 2
1 3
1 1
0
2
Output
Lose
Input
2 2
1 2
1 1
1
Output
Draw
Note
In the first example the graph is the following:
<image>
Initially the chip is located at vertex 1. In the first move Petya moves the chip to vertex 2, after that he moves it to vertex 4 for Vasya. After that he moves to vertex 5. Now it is Vasya's turn and there is no possible move, so Petya wins.
In the second example the graph is the following:
<image>
Initially the chip is located at vertex 2. The only possible Petya's move is to go to vertex 1. After that he has to go to 3 for Vasya. Now it's Petya's turn but he has no possible move, so Petya loses.
In the third example the graph is the following:
<image>
Petya can't win, but he can move along the cycle, so the players will draw a tie.
|
#include <bits/stdc++.h>
using namespace std;
enum estados { INDEF = 0, GANA = 1, PIERDE = 2 };
const int N = 1e5 + 1;
int main() {
int n;
scanf("%d %*d", &n);
int sig[2 * N] = {};
int siguientes[2 * N] = {};
vector<int> anteriores[2 * N];
vector<estados> estado(2 * n + 1, INDEF);
for (int i = 1; i <= n; ++i) {
int c;
scanf("%d", &c);
siguientes[i] = siguientes[i + n] = c;
while (c--) {
int j;
scanf("%d", &j);
anteriores[j].push_back(i + n);
anteriores[j + n].push_back(i);
}
}
int s;
scanf("%d", &s);
queue<int> cola;
for (int i = 1; i <= 2 * n; ++i) {
if (siguientes[i] == 0) {
estado[i] = PIERDE;
cola.push(i);
}
}
while (!cola.empty()) {
int u = cola.front();
cola.pop();
for (int v : anteriores[u]) {
if (estado[v] == INDEF) {
if (u <= n) {
if (estado[u] == GANA) {
estado[v] = PIERDE;
sig[v] = u;
cola.push(v);
continue;
}
--siguientes[v];
if (siguientes[v] == 0) {
estado[v] = GANA;
sig[v] = u;
cola.push(v);
}
} else {
if (estado[u] == PIERDE) {
estado[v] = GANA;
sig[v] = u;
cola.push(v);
continue;
}
--siguientes[v];
if (siguientes[v] == 0) {
estado[v] = PIERDE;
sig[v] = u;
cola.push(v);
}
}
}
}
}
if (estado[s] == PIERDE) {
printf("Lose\n");
return 0;
}
if (estado[s] == INDEF) {
printf("Draw\n");
return 0;
}
printf("Win\n");
printf("%d", s);
for (s = sig[s]; s != 0; s = sig[s]) {
int t = (s > n ? s - n : s);
printf(" %d", t);
}
printf("\n");
}
|
You are given a set of n elements indexed from 1 to n. The weight of i-th element is wi. The weight of some subset of a given set is denoted as <image>. The weight of some partition R of a given set into k subsets is <image> (recall that a partition of a given set is a set of its subsets such that every element of the given set belongs to exactly one subset in partition).
Calculate the sum of weights of all partitions of a given set into exactly k non-empty subsets, and print it modulo 109 + 7. Two partitions are considered different iff there exist two elements x and y such that they belong to the same set in one of the partitions, and to different sets in another partition.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 2·105) — the number of elements and the number of subsets in each partition, respectively.
The second line contains n integers wi (1 ≤ wi ≤ 109)— weights of elements of the set.
Output
Print one integer — the sum of weights of all partitions of a given set into k non-empty subsets, taken modulo 109 + 7.
Examples
Input
4 2
2 3 2 3
Output
160
Input
5 2
1 2 3 4 5
Output
645
Note
Possible partitions in the first sample:
1. {{1, 2, 3}, {4}}, W(R) = 3·(w1 + w2 + w3) + 1·w4 = 24;
2. {{1, 2, 4}, {3}}, W(R) = 26;
3. {{1, 3, 4}, {2}}, W(R) = 24;
4. {{1, 2}, {3, 4}}, W(R) = 2·(w1 + w2) + 2·(w3 + w4) = 20;
5. {{1, 3}, {2, 4}}, W(R) = 20;
6. {{1, 4}, {2, 3}}, W(R) = 20;
7. {{1}, {2, 3, 4}}, W(R) = 26;
Possible partitions in the second sample:
1. {{1, 2, 3, 4}, {5}}, W(R) = 45;
2. {{1, 2, 3, 5}, {4}}, W(R) = 48;
3. {{1, 2, 4, 5}, {3}}, W(R) = 51;
4. {{1, 3, 4, 5}, {2}}, W(R) = 54;
5. {{2, 3, 4, 5}, {1}}, W(R) = 57;
6. {{1, 2, 3}, {4, 5}}, W(R) = 36;
7. {{1, 2, 4}, {3, 5}}, W(R) = 37;
8. {{1, 2, 5}, {3, 4}}, W(R) = 38;
9. {{1, 3, 4}, {2, 5}}, W(R) = 38;
10. {{1, 3, 5}, {2, 4}}, W(R) = 39;
11. {{1, 4, 5}, {2, 3}}, W(R) = 40;
12. {{2, 3, 4}, {1, 5}}, W(R) = 39;
13. {{2, 3, 5}, {1, 4}}, W(R) = 40;
14. {{2, 4, 5}, {1, 3}}, W(R) = 41;
15. {{3, 4, 5}, {1, 2}}, W(R) = 42.
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 202020;
const int mod = 1000000007;
int a[maxn], s;
int fac[maxn], ifac[maxn];
int qpow(int a, int n) {
int ans = 1;
for (; n; n >>= 1, a = (long long)a * a % mod)
if (n & 1) ans = (long long)ans * a % mod;
return ans;
}
int gets(int n, int m) {
if (m > n) return 0;
int ans = 0;
for (int i = 0; i <= m; i++) {
if (i % 2 == 0)
ans = (ans + (long long)fac[m] * ifac[i] % mod * ifac[m - i] % mod *
qpow(m - i, n) % mod) %
mod;
else
ans = (ans -
(long long)fac[m] * ifac[i] % mod * ifac[m - i] % mod *
qpow(m - i, n) % mod +
mod) %
mod;
}
return ans * (long long)ifac[m] % mod;
}
int main(void) {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), s = (s + a[i]) % mod;
fac[0] = 1;
for (int i = 1; i <= k; i++) fac[i] = fac[i - 1] * (long long)i % mod;
ifac[k] = qpow(fac[k], mod - 2);
for (int i = k - 1; i >= 0; i--)
ifac[i] = ifac[i + 1] * (long long)(i + 1) % mod;
int ans = (gets(n, k) + (long long)gets(n - 1, k) * (n - 1)) % mod;
printf("%I64d\n", ans * (long long)s % mod);
return 0;
}
|
Vasilisa the Wise from a far away kingdom got a present from her friend Helga the Wise from a farther away kingdom. The present is a surprise box, yet Vasilisa the Wise doesn't know yet what the surprise actually is because she cannot open the box. She hopes that you can help her in that.
The box's lock is constructed like that. The box itself is represented by an absolutely perfect black cube with the identical deepening on each face (those are some foreign nanotechnologies that the far away kingdom scientists haven't dreamt of). The box is accompanied by six gems whose form matches the deepenings in the box's faces. The box can only be opened after it is correctly decorated by the gems, that is, when each deepening contains exactly one gem. Two ways of decorating the box are considered the same if they can be obtained one from the other one by arbitrarily rotating the box (note that the box is represented by a perfect nanotechnological cube)
Now Vasilisa the Wise wants to know by the given set of colors the following: in how many ways would she decorate the box in the worst case to open it? To answer this question it is useful to know that two gems of one color are indistinguishable from each other. Help Vasilisa to solve this challenging problem.
Input
The first line contains exactly 6 characters without spaces from the set {R, O, Y, G, B, V} — they are the colors of gems with which the box should be decorated.
Output
Print the required number of different ways to decorate the box.
Examples
Input
YYYYYY
Output
1
Input
BOOOOB
Output
2
Input
ROYGBV
Output
30
|
#include <bits/stdc++.h>
using namespace std;
struct neighbours {
char face;
char mas[4];
};
struct answer {
neighbours mas[6];
};
vector<answer> answers;
answer currentAnswer;
char colors[6];
char faces[6];
bool used[6];
int matrix[6][4];
void mySort(char mas[4]) {
char var[4];
for (int i = 0; i < 4; i++) var[i] = mas[i];
for (int i = 0; i < 4; i++) {
char tmp = mas[0];
for (int j = 0; j < 4; j++) mas[j] = mas[j + 1];
mas[3] = tmp;
for (int j = 0; j < 4; j++)
if (mas[j] < var[j]) {
for (int k = 0; k < 4; k++) var[k] = mas[k];
break;
} else if (mas[j] > var[j])
break;
}
for (int i = 0; i < 4; i++) mas[i] = var[i];
}
void createAnswer() {
for (int i = 0; i < 6; i++) {
currentAnswer.mas[i].face = faces[i];
int _count = 0;
for (int j = 0; j < 4; j++) {
currentAnswer.mas[i].mas[_count] = faces[matrix[i][j]];
_count++;
}
mySort(currentAnswer.mas[i].mas);
}
}
bool same(int ind) {
bool watched[6];
for (int i = 0; i < 6; i++) watched[i] = 0;
for (int i = 0; i < 6; i++)
for (int j = 0; j < 6; j++)
if (!watched[j] &&
answers[ind].mas[i].face == currentAnswer.mas[j].face) {
bool flag = true;
for (int k = 0; k < 4; k++)
if (answers[ind].mas[i].mas[k] != currentAnswer.mas[j].mas[k]) {
flag = false;
break;
}
if (flag) watched[j] = true;
}
for (int i = 0; i < 6; i++)
if (!watched[i]) return false;
return true;
}
bool check() {
for (int i = 0; i < answers.size(); i++)
if (same(i)) return 0;
return 1;
}
void addAnswer() { answers.push_back(currentAnswer); }
void solve(int p) {
if (p == 6) {
createAnswer();
if (check()) addAnswer();
return;
}
for (int i = 0; i < 6; i++)
if (!used[i]) {
faces[p] = colors[i];
used[i] = 1;
solve(p + 1);
used[i] = 0;
}
}
int main() {
matrix[0][0] = 1;
matrix[0][1] = 2;
matrix[0][2] = 3;
matrix[0][3] = 4;
matrix[1][0] = 0;
matrix[1][1] = 4;
matrix[1][2] = 5;
matrix[1][3] = 2;
matrix[2][0] = 0;
matrix[2][1] = 1;
matrix[2][2] = 5;
matrix[2][3] = 3;
matrix[3][0] = 0;
matrix[3][1] = 2;
matrix[3][2] = 5;
matrix[3][3] = 4;
matrix[4][0] = 1;
matrix[4][1] = 0;
matrix[4][2] = 3;
matrix[4][3] = 5;
matrix[5][0] = 4;
matrix[5][1] = 3;
matrix[5][2] = 2;
matrix[5][3] = 1;
for (int i = 0; i < 6; i++) cin >> colors[i];
solve(0);
cout << answers.size();
return 0;
}
|
Arnab is a robber and he has managed to rob N different strings from Akash. Now he decides to sell these strings in the market to make some profit. But, of all the strings he has, he wants to find the size of the largest anagram group so that he can easily sell that one first and make maximum profit initially. Help him find the largest size of groups of anagrams.
An anagram of a string is another string that contains same characters, only the order of characters can be different. For example, “abcd” and “dabc” are anagram of each other.
Input:
First line of input contains an integer N, number of total strings. Next N lines contains a single string S.
Output:
Print the largest size of group of anagrams possible.
Constraints:
1≤ N ≤ 100000
1 ≤ |S| ≤ 50
SAMPLE INPUT
5
ab
ba
cab
bca
cba
SAMPLE OUTPUT
3
Explanation
Groups of anagrams that can be formed are :
{ab,ba}
{cab, bca, cba}
So the answer is 3 as largest size of group of anagram is 3.
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
n = int(raw_input())
d = dict()
for i in range(n):
s = raw_input()
x = ''.join(sorted(s))
if not d.has_key(x):
d[x]=1
else:
d[x]+=1
max = -1
for j in d.values():
if j > max:
max = j
print max
|
You are studying a swarm of N fireflies. Each firefly is moving in a straight line at a constant speed. You are standing at the center of the universe, at position (0, 0, 0). Each firefly has the same mass, and you want to know how close the center of the swarm will get to your location (the origin).
You know the position and velocity of each firefly at t = 0, and are only interested in t ≥ 0. The fireflies have constant velocity, and may pass freely through all of space, including each other and you. Let M(t) be the location of the center of mass of the N fireflies at time t. Let d(t) be the distance between your position and M(t) at time t. Find the minimum value of d(t), dmin, and the earliest time when d(t) = dmin, tmin.
INPUT
The first line of input contains a single integer T, the number of test cases. Each test case starts with a line that contains an integer N, the number of fireflies, followed by N lines of the form
x y z vx vy vz
Each of these lines describes one firefly: (x, y, z) is its initial position at time t = 0, and (vx, vy, vz) is its velocity.
OUTPUT
For each test case, output
Case #X: dmin tmin
where X is the test case number, starting from 1. Any answer with absolute or relative error of at most 10-5 will be accepted.
CONSTRAINTS
All the numbers in the input will be integers.
1 ≤ T ≤ 100
The values of x, y, z, vx, vy and vz will be between -5000 and 5000, inclusive.
3 ≤ N ≤ 500
SAMPLE INPUT
1
3
3 0 -4 0 0 3
-3 -2 -1 3 0 0
-3 -1 2 0 3 0
SAMPLE OUTPUT
Case #1: 0.00000000 1.00000000
Explanation
NOTE
Given N points (xi, yi, zi), their center of the mass is the point (xc, yc, zc), where:
xc = (x1 + x2 + ... + xN) / N
yc = (y1 + y2 + ... + yN) / N
zc = (z1 + z2 + ... + zN) / N
|
import math
def cross(a, b):
c = [float(a[1])*float(b[2]) - float(a[2])*float(b[1]),
float(a[2])*float(b[0]) - float(a[0])*float(b[2]),
float(a[0])*float(b[1]) - float(a[1])*float(b[0])]
return c
def modulo(a):
b=float(a[0])*float(a[0])+float(a[1])*float(a[1])+float(a[2])*float(a[2])
b=math.sqrt(b)
return b
t=int(raw_input())
for i in range(0,t):
n=int(raw_input());
x=0;y=0;z=0;vx=0;vy=0;vz=0;
for j in range(0,n):
q=raw_input()
q=q.split()
x=x+float(q[0])
y=y+float(q[1])
z=z+float(q[2])
vx=vx+float(q[3])
vy=vy+float(q[4])
vz=vz+float(q[5])
x=x/n;y=y/n;z=z/n;vx=vx/n;vy=vy/n;vz=vz/n;
zn=[]
zn.append(x);zn.append(y);zn.append(z);
vn=[]
vn.append(vx);vn.append(vy);vn.append(vz);
c=cross(zn,vn)
c=modulo(c);
vn=modulo(vn);
dist=c/float(vn)
distfromorigin=modulo(zn)
pointdist=math.sqrt((distfromorigin*distfromorigin)-(dist*dist))
finaltime=pointdist/float(vn)
dist=format(dist, '.8f')
finaltime=format(finaltime, '.8f')
print "Case #"+str(i+1)+": "+str(dist)+" "+str(finaltime)
|
You have an unbiased dice which you want to keep rolling until you get N consecutive even numbers. You've rolled the dice M times and surprisingly, all rolls resulted in even numbers. What is the expected number of additional rolls needed until you get N consecutive even numbers?
Input:
The first line contains the number of cases T. Each of the next T lines contains two numbers N and M.
Output:
Output T lines containing the answer for the corresponding test case. Print the answer rounded to exactly 2 decimal places.
Constraints:
1 ≤ T ≤ 100
1 ≤ N ≤ 1000
0 ≤ M ≤ N
SAMPLE INPUT
4
2 0
2 1
3 3
3 2
SAMPLE OUTPUT
6.00
4.00
0.00
8.00
Explanation
If N = 2 and M = 0, you need to keep rolling the dice until you get 2 consecutive even numbers. It is not hard to show that on average, 6 dice rolls are needed.
If N = 2 and M = 1, you need 2 consecutive even numbers and already have 1. You need to roll once more no matter what. In that first roll, if you get an even number, you are done. Otherwise, you need to start over, as the consecutive counter resets, and you need to keep rolling the dice until you get N=2 consecutive even numbers. The expected number of dice rolls is thus 1 + (0.5 * 0 + 0.5 * 6) = 4.0
If N = 3 and M = 3, you already have got 3 even numbers, so you do not need any more rolls.
|
t = input()
while t > 0:
a = raw_input()
c,d = a.split()
ans = 0
c = int(c)
d = int(d)
y = 1
z = 1
for i in range (c):
y = y*2
for i in range (d):
z = z*2
ans=y-z
ans=2*ans
print(str(ans)+'.00')
t = t-1
|
Anmol likes gems very much.
He has N packets of gems, here the ith packet contains Pi gems. You need to find the minimal number of packets Anmol needs to take to his trip to Market, if he wants to eat there at least M gems. Note that gems are already packed, i.e. he cannot change the amount of gems in any packet.
Input format:
The first line of the input contains an integer t, denoting the number of test cases. Next t lines test cases follows: The first line of each test case contains two space-separated integers N and M. The second line contains N space-separated integers P1, P2, ..., PN.
Output format:
For each test case, output an integer, denoting the minimum number of plates. If it's impossible to take at least M gems, print -1.
Constraints:
1 ≤ T ≤ 5000
1 ≤ N ≤ 7
1 ≤ M, Pi ≤ 10^11SAMPLE INPUT
2
4 8
2 1 7 3
6 12
4 3 1 5 6 2
SAMPLE OUTPUT
2
3
Explanation
Case 1:We want to get 8 in minimum possible way from given 4 numbers. So, at least 2 numbers to be selected(1 and 7) to get sum as 8. Therefore its output would be 2.
Case 2:Here we want to get 12 in minimum possible way from given 6 numbers. So, at least 3 numbers are to be selected to get sum as 12. Therefore its output would be 3.
Problem Setter: Amit Tiwari
|
def find_min(t,sum1,items):
items.sort()
i = t-1
sumz = 0
m = sum1
count = 0
while i>=0:
sumz += items[i]
count += 1
if(sumz>=m):
return (count)
break
i -= 1
if i == -1:
return (-1)
if __name__=='__main__':
T = int(raw_input())
for i in range(0,T):
tol = raw_input().split()
takein = list(map(int,raw_input().split()))
print find_min(int(tol[0]),int(tol[1]),takein)
|
Verma has got 2 arrays of integer numbers. He wished to find the sum of product of all numbers in first array with all the
numbers in second array.
i.e suppose 1st array A[] contains N numbers and 2nd array B[] contains m numbers.
He wished to calculate for all 1 ≤ i ≤ N and for all 1 ≤ j ≤ M.. sum(Ai*Bi).
As he is busy watching NARUTO. He seeks your help in finding this.
Input Format
1^st line contains 2 space separated integers N and M.
2^nd line contains N space separated integers Ai.
3^rd line contains M space separated integers Bi.
Output Format
1 single line containing only the required answer.
Constraints
1 ≤ N,M ≤ 10^5
-1000 ≤ Ai, Bi ≤ 1000
Problem Setter : Sanchit Bhushan
Problem Tester : Pranjul Dubey
SAMPLE INPUT
2 2
1 2
3 4
SAMPLE OUTPUT
21
Explanation
Here answer is
31 + 32 + 41 + 42
|
line=raw_input().split(' ')
a=int(line[0])
b=int(line[1])
line1 = raw_input().split(' ')
line2 = raw_input().split(' ')
sum1=0
sum2=0
for i in range(0,a):
sum1 = sum1 + int( line1[i])
for j in range(0,b):
sum2 += int(line2[j])
print sum1*sum2
|
Our Code Monk recently learnt about Graphs and is very excited!
He went over to the Graph-making factory to watch some freshly prepared graphs. Incidentally, one of the workers at the factory was ill today, so Monk decided to step in and do her job.
The Monk's Job is to Identify whether the incoming graph is a tree or not. He is given N, the number of vertices in the graph and the degree of each vertex.
Find if the graph is a tree or not.
Input:
First line contains an integer N, the number of vertices.
Second line contains N space-separated integers, the degrees of the N vertices.
Output:
Print "Yes" (without the quotes) if the graph is a tree or "No" (without the quotes) otherwise.
Constraints:
1 ≤ N ≤ 100
1 ≤ Degreei ≤ 1000
References:
Graphs and Trees
SAMPLE INPUT
3
1 2 1
SAMPLE OUTPUT
Yes
|
print "Yes" if (2*(input()-1)-sum(list(map(int,raw_input().split())))==0) else "No"
|
Kevin has a permutation P of N integers 1, 2, ..., N, but he doesn't like it. Kevin wants to get a permutation Q.
Also he believes that there are M good pairs of integers (ai , bi). Kevin can perform following operation with his permutation:
Swap Px and Py only if (x, y) is a good pair.
Help him and tell if Kevin can obtain permutation Q using such operations.
Input format:
The first line of input will contain an integer T, denoting the number of test cases.
Each test case starts with two space-separated integers N and M. The next line contains N space-separated integers Pi. The next line contains N space-separated integers Qi. Each of the next M lines contains two space-separated integers ai and bi.
Output format:
For every test case output "YES" (without quotes) if Kevin can obtain permutation Q and "NO" otherwise.
Constraints:
1 ≤ T ≤ 10
2 ≤ N ≤ 10^5
1 ≤ M ≤ 10^5
1 ≤ Pi, Qi ≤ N. Pi and Qi are all distinct.
1 ≤ ai < bi ≤ N
N, M ≤ 100 in test data worth 20% of all points
SAMPLE INPUT
2
4 1
1 3 2 4
1 4 2 3
3 4
4 1
1 3 2 4
1 4 2 3
2 4
SAMPLE OUTPUT
NO
YES
|
def dfs(v):
global mark,c_c
q=[]
q.append(v)
while q:
top=q.pop()
mark[top]=c_c
for j in G[top]:
if mark[j]==-1:
q.append(j)
mark[j]=mark[top]
#d[c_c]=s
t=input()
while t!=0:
n,m=map(int,raw_input().split())
G=[[] for i in xrange(n+1)]
P=map(int,raw_input().split())
Q=map(int,raw_input().split())
for k in xrange(m):
x,y=map(int,raw_input().split())
G[x].append(y)
G[y].append(x)
mark=[-1]*(n+1)
#d=[-1]*(n+1)
c_c=1
#dfs(1)
t_p={}
#t_q={}
for v in xrange(1,n+1):
t_p[P[v-1]]=v-1
#t_q[Q[v-1]]=v-1
if G[v]:
if mark[v]==-1:
dfs(v)
c_c+=1
else:
#c_c+=1
mark[v]=c_c
c_c+=1
k=True
#print t_p,t_q
#print mark
for i in xrange(n):
if P[i]!=Q[i]:
#print "i",i,P[i],Q[i]
#print t_p[P[i]],t_q[Q[i]]
#print mark[t_p[P[i]]],mark[t_p[Q[i]]]
if (mark[t_p[P[i]]+1]!=mark[t_p[Q[i]]+1]) :
k=False
break
if k==False:
print "NO"
else:
print "YES"
t-=1
|
Its Diwali time and little Roy thought of an interesting design for Rangoli.
He created an N x N grid. Roy fills some of the cells of grid with red color.
Cell located at ith row and jth column is colored if i+j is prime. Consider Zero-based numbering of grid. (See Sample Test Case Explanation for clarification)
Roy wants to know how many cells he will have to color given the size of grid N.
Input:
One integer indicating size of grid N
Output:
Print a single integer, number of cells Roy will have to color. Since answer can be very large output it modulo 1000000007
Constraints:
1 ≤ N ≤1000000
Sample Test Case Explanation:SAMPLE INPUT
3
SAMPLE OUTPUT
5
Explanation
As shown in the image above, five cells (0,2), (1,1), (1,2), (2,0), (2,1) are colored red because for (i,j) i+j for these cells results into a prime number.
|
def sieve(n):
is_prime = [True] * (n+1)
is_prime[0] = is_prime[1] = False
for i in range(2, n+1):
if is_prime[i]:
for j in range(i+i, n+1, i):
is_prime[j] = False
return is_prime
n = int(raw_input())
is_prime = sieve(n+n)
total = 0
for i in range(n):
if is_prime[i]:
total += i+1
nn1 = n+n-1
for i in range(n, nn1):
if is_prime[i]:
total += nn1 - i
print total % 1000000007
|
Subly found a set of Numbers in his Dad's table. Subly examines that set and wants to know how many numbers in that set are not divisible by his favourite number.
He asked his brother for help. His brother told him that the numbers were in some row of the Pascals Triangle. But since he was busy, he couldn't solve Subly's problem.
Subly wants you to answer his question. You are given two integers N and M.
The set of Numbers are in the Nth row of the Pascals Triangle and The Set contains Exactly N+1 numbers.
Second Integer denotes Subly's Number. It is guaranteed that M is a Prime number.
Input:
N And M are in a Single Line, Seperated by a single space.
Constraints:
1 ≤ N ≤ 10000000
1 ≤ M ≤ 1000
Examples:
Input:
7 5
Output:
6
Input:
8 2
Output:
2
Input:
5 3
Output:
6
SAMPLE INPUT
7 5
SAMPLE OUTPUT
6
|
from sys import stdin
n,m = map(int,stdin.readline().split())
tot = 0
cur = n
ans = 0
while cur:
tot += cur/m
cur/=m
for i in xrange(n+1):
fir = n-i
sec = i
u = 0
v = 0
while fir:
u += fir/m
fir/=m
while sec:
v += sec/m
sec/=m
#print i,n-i,u,v
if u+v >= tot:
ans+=1
print ans
|
Vivek and Sita are in a relationship. Both of them love playing with numbers and treat each other with puzzles every now and then.
When Sita visits her class she comes to see that there is a gift packed in a wooden box which has a lock in it which can only be unlocked by solving the puzzle written on the paper note which is pasted on the top of the box by Vivek.
Sita is stuck with this puzzle, help her in solving it.
The puzzle description is as follows:
R(n) is a function as follows,
R(0) = 1, R(1) = 1, R(2) = 1
R(n) = product of all odd primes less than or equal to n (for n≤10)
R(n) = (2^(n/4) × R(n/5) × R(n/10)) *mod (10^9+7) (for n>10)*
NOTE: For every fraction, the ceiling value is taken for evaluation. (eg: ceil(4.05) = 5, and ceil(4.9) = 5)
Consider an example:
R(15) = 2^⌈15/4⌉ × R(⌈15/5⌉) × R(⌈15/10⌉) = 2^4 × R(3) × R(2) = 48
Now the puzzle is that you are given n and you have to find out the maximum value of x^y mod (10^9 + 7) such that non negative integers x and y satisfy the relation gcd(x,y) = R(n), where x, y ≤ 5 × R(n)
Here, gcd is the greatest common divisor. Where gcd(0,0) = 0, 0^0 = 0.
Input Format
First line contains an integer T, the number of test cases
T lines will follow, each having an integer N, for which the result needs to be calculated.
Output Format
For each test case, print the desired value on a new line
Constraints
1 ≤ *T ≤ 25*
0 ≤ *N ≤ 30*
Input Example
2
1
2
Output Example
1024
1024
Example Explanation
x & y for both the inputs (1&2) can be 1 to 5, and the max value for x^y is when x = 4 and y = 5
SAMPLE INPUT
1
14
SAMPLE OUTPUT
996023990
Explanation
R(14) = 48, x & y can be from 1 to 48×5 (=240). the maximum value of (x^y) mod (10^9 + 7) is when x = 240 and y = 96.
|
import math
def powmod(x, y, md):
if x==0:
return 0
if y==0:
return 1
ans = powmod(x, y//2, md)
ans = (ans*ans)%md
if y%2==1:
ans = (x*ans)%md
return ans
def Rn(N):
if N<=10:
return R[N]
n4 = int(math.ceil(N/4.0))
n5 = int(math.ceil(N/5.0))
n10= int(math.ceil(N/10.0))
calc = (2**n4)%1000000007
calc = calc*((Rn(n5))%1000000007)%1000000007
calc = calc*((Rn(n10))%1000000007)%1000000007
return calc
R = [1, 1, 1, 3, 3, 15, 15, 105, 105, 105, 105]
T = int(input())
for t in range(T):
N = int(input())
rn = Rn(N)
rn2 = rn*2
rn3 = rn*3
rn4 = rn2*2
rn5 = rn*5
max_so_far = 0
combos = [[rn,rn], [rn, rn2], [rn, rn3], [rn, rn4], [rn, rn5], [rn2, rn3], [rn2, rn5], [rn3, rn4], [rn3, rn5], [rn4, rn5]]
for x in combos:
now = powmod(x[0],x[1], 1000000007)
#print x[0], x[1], now
max_so_far = max(max_so_far, now)
now = powmod(x[1],x[0], 1000000007)
#print x[0], x[1], now
max_so_far = max(max_so_far, now)
print max_so_far
|
New AtCoder City has an infinite grid of streets, as follows:
* At the center of the city stands a clock tower. Let (0, 0) be the coordinates of this point.
* A straight street, which we will call East-West Main Street, runs east-west and passes the clock tower. It corresponds to the x-axis in the two-dimensional coordinate plane.
* There are also other infinitely many streets parallel to East-West Main Street, with a distance of 1 between them. They correspond to the lines \ldots, y = -2, y = -1, y = 1, y = 2, \ldots in the two-dimensional coordinate plane.
* A straight street, which we will call North-South Main Street, runs north-south and passes the clock tower. It corresponds to the y-axis in the two-dimensional coordinate plane.
* There are also other infinitely many streets parallel to North-South Main Street, with a distance of 1 between them. They correspond to the lines \ldots, x = -2, x = -1, x = 1, x = 2, \ldots in the two-dimensional coordinate plane.
There are N residential areas in New AtCoder City. The i-th area is located at the intersection with the coordinates (X_i, Y_i) and has a population of P_i. Each citizen in the city lives in one of these areas.
The city currently has only two railroads, stretching infinitely, one along East-West Main Street and the other along North-South Main Street.
M-kun, the mayor, thinks that they are not enough for the commuters, so he decides to choose K streets and build a railroad stretching infinitely along each of those streets.
Let the walking distance of each citizen be the distance from his/her residential area to the nearest railroad.
M-kun wants to build railroads so that the sum of the walking distances of all citizens, S, is minimized.
For each K = 0, 1, 2, \dots, N, what is the minimum possible value of S after building railroads?
Constraints
* 1 \leq N \leq 15
* -10 \ 000 \leq X_i \leq 10 \ 000
* -10 \ 000 \leq Y_i \leq 10 \ 000
* 1 \leq P_i \leq 1 \ 000 \ 000
* The locations of the N residential areas, (X_i, Y_i), are all distinct.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 Y_1 P_1
X_2 Y_2 P_2
: : :
X_N Y_N P_N
Output
Print the answer in N+1 lines.
The i-th line (i = 1, \ldots, N+1) should contain the minimum possible value of S after building railroads for the case K = i-1.
Examples
Input
3
1 2 300
3 3 600
1 4 800
Output
2900
900
0
0
Input
5
3 5 400
5 3 700
5 5 1000
5 7 700
7 5 400
Output
13800
1600
0
0
0
0
Input
6
2 5 1000
5 2 1100
5 5 1700
-2 -5 900
-5 -2 600
-5 -5 2200
Output
26700
13900
3200
1200
0
0
0
Input
8
2 2 286017
3 1 262355
2 -2 213815
1 -3 224435
-2 -2 136860
-3 -1 239338
-2 2 217647
-1 3 141903
Output
2576709
1569381
868031
605676
366338
141903
0
0
0
|
import sys
input = sys.stdin.readline
def main():
n = int(input())
l = [list(map(int,input().split())) for i in range(n)]
xcal = [[0]*n for i in range(1<<n)]
ycal = [[0]*n for i in range(1<<n)]
for i in range(1<<n):
for j in range(n):
xcal[i][j] = abs(l[j][0])
ycal[i][j] = abs(l[j][1])
for k in range(n):
if (i>>k) & 1:
xcal[i][j] = min(xcal[i][j],abs(l[j][0]-l[k][0]))
ycal[i][j] = min(ycal[i][j],abs(l[j][1]-l[k][1]))
xcal[i][j] *= l[j][2]
ycal[i][j] *= l[j][2]
ans = [float("INF")]*(n+1)
for i in range(1<<n):
count = 0
for j in range(n):
if i >> j & 1:
count += 1
j = i
while j >= 0:
j &= i
cost = 0
for k in range(n):
if not (i>>k & 1):
cost += min(xcal[j][k],ycal[i-j][k])
if cost > ans[count]:
break
ans[count] = min(ans[count],cost)
j -= 1
for i in ans:
print(i)
if __name__ == "__main__":
main()
|
Consider a grid with H rows and W columns of squares. Let (r, c) denote the square at the r-th row from the top and the c-th column from the left. Each square is painted black or white.
The grid is said to be good if and only if the following condition is satisfied:
* From (1, 1), we can reach (H, W) by moving one square right or down repeatedly, while always being on a white square.
Note that (1, 1) and (H, W) must be white if the grid is good.
Your task is to make the grid good by repeating the operation below. Find the minimum number of operations needed to complete the task. It can be proved that you can always complete the task in a finite number of operations.
* Choose four integers r_0, c_0, r_1, c_1(1 \leq r_0 \leq r_1 \leq H, 1 \leq c_0 \leq c_1 \leq W). For each pair r, c (r_0 \leq r \leq r_1, c_0 \leq c \leq c_1), invert the color of (r, c) - that is, from white to black and vice versa.
Constraints
* 2 \leq H, W \leq 100
Input
Input is given from Standard Input in the following format:
H W
s_{11} s_{12} \cdots s_{1W}
s_{21} s_{22} \cdots s_{2W}
\vdots
s_{H1} s_{H2} \cdots s_{HW}
Here s_{rc} represents the color of (r, c) - `#` stands for black, and `.` stands for white.
Output
Print the minimum number of operations needed.
Examples
Input
3 3
.##
.#.
##.
Output
1
Input
3 3
.##
.#.
.
Output
1
Input
2 2
.
.#
Output
2
Input
4 4
..##
...
.
.
Output
0
Input
5 5
.#.#.
.#.#
.#.#.
.#.#
.#.#.
Output
4
|
h, w = map(int, input().split())
s = [list(input()) for _ in range(h)]
dp = [[h * w] * w for _ in range(h)]
dp[0][0] = 0 if s[0][0] == "." else 1
for x0 in range(w):
for y0 in range(h):
for i, j in [(0, 1), (1, 0)]:
x = x0 + i
y = y0 + j
if x < w and y < h:
n = 1 if s[y0][x0] == "." and s[y][x] == "#" else 0
dp[y][x] = min(dp[y0][x0] + n, dp[y][x])
print(dp[-1][-1])
|
Given are positive integers N and K.
Determine if the 3N integers K, K+1, ..., K+3N-1 can be partitioned into N triples (a_1,b_1,c_1), ..., (a_N,b_N,c_N) so that the condition below is satisfied. Any of the integers K, K+1, ..., K+3N-1 must appear in exactly one of those triples.
* For every integer i from 1 to N, a_i + b_i \leq c_i holds.
If the answer is yes, construct one such partition.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq K \leq 10^9
Input
Input is given from Standard Input in the following format:
N K
Output
If it is impossible to partition the integers satisfying the condition, print `-1`. If it is possible, print N triples in the following format:
a_1 b_1 c_1
:
a_N b_N c_N
Output
If it is impossible to partition the integers satisfying the condition, print `-1`. If it is possible, print N triples in the following format:
a_1 b_1 c_1
:
a_N b_N c_N
Examples
Input
1 1
Output
1 2 3
Input
3 3
Output
-1
|
#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#include<vector>
#include<queue>
#define ll long long
#define maxn 200010
inline ll read()
{
ll x=0; char c=getchar(),f=1;
for(;c<'0'||'9'<c;c=getchar())if(c=='-')f=-1;
for(;'0'<=c&&c<='9';c=getchar())x=x*10+c-'0';
return x*f;
}
inline void write(ll x)
{
static int buf[20],len; len=0;
if(x<0)x=-x,putchar('-');
for(;x;x/=10)buf[len++]=x%10;
if(!len)putchar('0');
else while(len)putchar(buf[--len]+'0');
}
inline void writeln(ll x){write(x); putchar('\n');}
inline void writesp(ll x){write(x); putchar(' ');}
int a[maxn],b[maxn],c[maxn];
int n,k;
int main()
{
n=read(); k=read();
if(n<2*k-1){
puts("-1"); return 0;
}
for(int i=0;i<n;i+=2){
int t=i/2;
a[i]=t; b[i]=2*n-(n+1)/2+t; c[i]=2*n+i;
}
for(int i=1;i<n;i+=2){
int t=i/2;
a[i]=(n+1)/2+t; b[i]=n+t; c[i]=2*n+i;
}
for(int i=0;i<n;i++)
writesp(a[i]+k),writesp(b[i]+k),writeln(c[i]+k);
return 0;
}
|
There are N points in a two-dimensional plane. The initial coordinates of the i-th point are (x_i, y_i). Now, each point starts moving at a speed of 1 per second, in a direction parallel to the x- or y- axis. You are given a character d_i that represents the specific direction in which the i-th point moves, as follows:
* If d_i = `R`, the i-th point moves in the positive x direction;
* If d_i = `L`, the i-th point moves in the negative x direction;
* If d_i = `U`, the i-th point moves in the positive y direction;
* If d_i = `D`, the i-th point moves in the negative y direction.
You can stop all the points at some moment of your choice after they start moving (including the moment they start moving). Then, let x_{max} and x_{min} be the maximum and minimum among the x-coordinates of the N points, respectively. Similarly, let y_{max} and y_{min} be the maximum and minimum among the y-coordinates of the N points, respectively.
Find the minimum possible value of (x_{max} - x_{min}) \times (y_{max} - y_{min}) and print it.
Constraints
* 1 \leq N \leq 10^5
* -10^8 \leq x_i,\ y_i \leq 10^8
* x_i and y_i are integers.
* d_i is `R`, `L`, `U`, or `D`.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1 d_1
x_2 y_2 d_2
.
.
.
x_N y_N d_N
Output
Print the minimum possible value of (x_{max} - x_{min}) \times (y_{max} - y_{min}).
The output will be considered correct when its absolute or relative error from the judge's output is at most 10^{-9}.
Examples
Input
2
0 3 D
3 0 L
Output
0
Input
5
-7 -10 U
7 -6 U
-8 7 D
-3 3 D
0 -6 R
Output
97.5
Input
20
6 -10 R
-4 -9 U
9 6 D
-3 -2 R
0 7 D
4 5 D
10 -10 U
-1 -8 U
10 -6 D
8 -5 U
6 4 D
0 3 D
7 9 R
9 -4 R
3 10 D
1 9 U
1 -6 U
9 -8 R
6 7 D
7 -3 D
Output
273
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e5 + 5, mod = 1e9 + 7;
const double inf = 1e18;
struct e{
int x, y;
double nx, ny;
char p;
}a[maxn];
int n;
double F(double mid)
{
double maxx = -inf, minx = inf, maxy = -inf, miny = inf;
for (int i = 0; i < n; ++i){
a[i].nx = a[i].x, a[i].ny = a[i].y;
if(a[i].p == 'L') a[i].nx = (double)a[i].x - mid;
else if(a[i].p == 'R') a[i].nx = (double)a[i].x + mid;
else if(a[i].p == 'U') a[i].ny = (double)a[i].y + mid;
else a[i].ny = (double)a[i].y - mid;
minx = min(minx, a[i].nx);
maxx = max(maxx, a[i].nx);
miny = min(miny, a[i].ny);
maxy = max(maxy, a[i].ny);
}
return (maxx - minx) * (maxy - miny);
}
int main()
{
ios::sync_with_stdio(0); cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i){
cin >> a[i].x >> a[i].y >> a[i].p;
}
double l = 0, r = 1e8;
for (int i = 0; i < 100; ++i){
double len = (r - l) / 3;
double lmid = l + len, rmid = l + 2 * len;
if (F(lmid) < F(rmid)) r = rmid;
else l = lmid;
}
cout << fixed << F((l + r) / 2) << endl;
return 0;
}
|
There are N jewels, numbered 1 to N. The color of these jewels are represented by integers between 1 and K (inclusive), and the color of Jewel i is C_i. Also, these jewels have specified values, and the value of Jewel i is V_i.
Snuke would like to choose some of these jewels to exhibit. Here, the set of the chosen jewels must satisfy the following condition:
* For each chosen jewel, there is at least one more jewel of the same color that is chosen.
For each integer x such that 1 \leq x \leq N, determine if it is possible to choose exactly x jewels, and if it is possible, find the maximum possible sum of the values of chosen jewels in that case.
Constraints
* 1 \leq N \leq 2 \times 10^5
* 1 \leq K \leq \lfloor N/2 \rfloor
* 1 \leq C_i \leq K
* 1 \leq V_i \leq 10^9
* For each of the colors, there are at least two jewels of that color.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
C_1 V_1
C_2 V_2
:
C_N V_N
Output
Print N lines. In the i-th line, if it is possible to choose exactly i jewels, print the maximum possible sum of the values of chosen jewels in that case, and print -1 otherwise.
Examples
Input
5 2
1 1
1 2
1 3
2 4
2 5
Output
-1
9
6
14
15
Input
5 2
1 1
1 2
2 3
2 4
2 5
Output
-1
9
12
12
15
Input
8 4
3 2
2 3
4 5
1 7
3 11
4 13
1 17
2 19
Output
-1
24
-1
46
-1
64
-1
77
Input
15 5
3 87
1 25
1 27
3 58
2 85
5 19
5 39
1 58
3 12
4 13
5 54
4 100
2 33
5 13
2 55
Output
-1
145
173
285
318
398
431
491
524
576
609
634
653
666
678
|
//https://atcoder.jp/contests/nikkei2019-qual/tasks/nikkei2019_qual_f
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
#ifdef BTK
#define DEBUG if(1)
#else
#define CIN_ONLY if(1)
struct cww {cww() {CIN_ONLY{ios::sync_with_stdio(false); cin.tie(0);}}}star;
#define DEBUG if(0)
#endif
#define ALL(v) (v).begin(),(v).end()
#define REC(ret, ...) std::function<ret (__VA_ARGS__)>
template <typename T>inline bool chmin(T &l, T r){bool a = l>r; if (a)l = r; return a;}
template <typename T>inline bool chmax(T &l, T r){bool a = l<r; if (a)l = r; return a;}
template <typename T>istream& operator>>(istream &is, vector<T> &v){for (auto &it : v)is >> it;return is;}
class reverse_range {private:struct I {int x;int operator*() {return x-1;}bool operator!=(I& lhs) {return x>lhs.x;}void operator++() {--x;}};I i, n;public:reverse_range(int n) :i({ 0 }), n({ n }){}reverse_range(int i, int n) :i({ i }), n({ n }){}I& begin() {return n;}I& end() {return i;}};
class range {private: struct I { int x; int operator*() { return x; }bool operator!=(I& lhs) { return x<lhs.x; }void operator++() { ++x; } }; I i, n;public:range(int n) :i({ 0 }), n({ n }) {}range(int i, int n) :i({ i }), n({ n }) {}I& begin() { return i; }I& end() { return n; }reverse_range operator!(){return reverse_range(*i,*n);}};
constexpr LL INF=1e12;
int N,K;
int used[112345];
vector<LL> col[112345];
LL ret[212345];
vector<pair<LL,int>> stone;
void solve(){
int invalid=0;
LL sum = 0;
set<pair<LL,int>> P,Q,R,S,T;
for(int i:range(N)){
const int color = stone[i].second/2;
invalid ^= stone[i].second%2;
if(stone[i].second%2==1&&invalid==0){
S.insert({stone[i].first*2,i});
if(col[color].size()>=3){
T.insert({stone[i].first*2+col[color][2],i});
}
}
}
for(int i:range(N)){
const int color = stone[i].second/2;
invalid ^= stone[i].second%2;
//cerr<<i+1<<"th stone is "<< color <<" "<<stone[i].first << " " << stone[i].second%2<<endl;
if(invalid){
ret[i+1]=-2;
LL q=-2,ps=-2,rt=-2;
if(Q.size())q=sum+Q.rbegin()->first;
if(P.size()&&S.size())ps=sum-P.begin()->first+S.rbegin()->first;
if(R.size()&&T.size()){
//cerr << "r_first= " << R.begin()->first << " ";
//cerr << "t_last= " << T.rbegin()->first << " ";
rt=sum-R.begin()->first+T.rbegin()->first;
}
ret[i+1]=max({q,ps,rt});
//cerr << "sum= " << sum << " ";
//cerr << "q= " << q << " ";
//cerr << "ps= "<< ps << " ";
//cerr << "rt= "<< rt << " ";
//cerr<<endl;
sum+=stone[i].first;
}
else{
sum+=stone[i].first;
ret[i+1]=sum;
}
used[color]++;
if(stone[i].second%2==0){
P.insert({stone[i].first,i});
Q.erase({col[color][used[color]-1],color});
}
if(used[color]>=2&&used[color]<col[color].size()){
Q.insert({col[color][used[color]],color});
}
if(used[color]==2){
R.insert({stone[i].first*2,i});
S.erase({stone[i].first*2,i});
if(col[color].size()>=3){
T.erase({stone[i].first*2+col[color][2],i});
}
}
}
}
int main(){
cin>>N>>K;
for(int i:range(N)){
int c;
LL v;
cin>>c>>v;
c--;
col[c].push_back(v*2);
}
for(int i:range(K)){
sort(ALL(col[i]));
LL x=0;
x+=col[i].back();col[i].pop_back();
x+=col[i].back();col[i].pop_back();
stone.push_back({x/2,2*i+1});
stone.push_back({x/2,2*i+1});
for(LL v:col[i]){
stone.push_back({v,2*i});
}
col[i].push_back(x/2);
col[i].push_back(x/2);
reverse(ALL(col[i]));
}
sort(ALL(stone));
reverse(ALL(stone));
solve();
for(int i:range(1,N+1)){
cout<<ret[i]/2<<endl;
}
return 0;
}
|
A programming competition site AtCode regularly holds programming contests.
The next contest on AtCode is called ABC, which is rated for contestants with ratings less than 1200.
The contest after the ABC is called ARC, which is rated for contestants with ratings less than 2800.
The contest after the ARC is called AGC, which is rated for all contestants.
Takahashi's rating on AtCode is R. What is the next contest rated for him?
Constraints
* 0 ≤ R ≤ 4208
* R is an integer.
Input
Input is given from Standard Input in the following format:
R
Output
Print the name of the next contest rated for Takahashi (`ABC`, `ARC` or `AGC`).
Examples
Input
1199
Output
ABC
Input
1200
Output
ARC
Input
4208
Output
AGC
|
#include <iostream>
using namespace std;
int main(){
int a;
cin>>a;
if (a>=0&&a<1200){cout<<"ABC";}
else if(a>=1200&&a<2800){cout<<"ARC";}
else {cout<<"AGC";}
}
|
You are given a rooted tree with N vertices. The vertices are numbered 0, 1, ..., N-1. The root is Vertex 0, and the parent of Vertex i (i = 1, 2, ..., N-1) is Vertex p_i.
Initially, an integer a_i is written in Vertex i. Here, (a_0, a_1, ..., a_{N-1}) is a permutation of (0, 1, ..., N-1).
You can execute the following operation at most 25 000 times. Do it so that the value written in Vertex i becomes i.
* Choose a vertex and call it v. Consider the path connecting Vertex 0 and v.
* Rotate the values written on the path. That is, For each edge (i, p_i) along the path, replace the value written in Vertex p_i with the value written in Vertex i (just before this operation), and replace the value of v with the value written in Vertex 0 (just before this operation).
* You may choose Vertex 0, in which case the operation does nothing.
Constraints
* 2 \leq N \leq 2000
* 0 \leq p_i \leq i-1
* (a_0, a_1, ..., a_{N-1}) is a permutation of (0, 1, ..., N-1).
Input
Input is given from Standard Input in the following format:
N
p_1 p_2 ... p_{N-1}
a_0 a_1 ... a_{N-1}
Output
In the first line, print the number of operations, Q. In the second through (Q+1)-th lines, print the chosen vertices in order.
Examples
Input
5
0 1 2 3
2 4 0 1 3
Output
2
3
4
Input
5
0 1 2 2
4 3 1 2 0
Output
3
4
3
1
|
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef complex<double> point;
#define xx real()
#define yy imag()
#define REP(i, a, b) for(int i = (a); i < (int)(b); i++)
#define REPN(i, a, b) for(int i = (a); i <= (int)(b); i++)
#define FA(it, x) for(__typeof((x).begin()) it = (x).begin(); it != (x).end(); it++)
#define SZ(x) (int)(x).size()
#define BE(x) (x).begin(), (x).end()
#define SORT(x) sort(BE(x))
#define _1 first
#define _2 second
#define x1 gray_cat_x1
#define y1 gray_cat_y1
template<class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define file "I1"
const double EPS = 1e-9;
const double PI = acos(-1.);
const int INF = 1e9;
const ll MOD = 1e9 + 7;
const int MAXN = 2e3 + 5;
int par[MAXN], per[MAXN];
int used[MAXN];
int leaf[MAXN];
int ind_l[MAXN], ind_r[MAXN];
int good[MAXN];
vi ans;
int n;
void move(int pos) {
if (pos <= 0) {
return;
}
/*REP(i, 0, n) {
printf("%d ", per[i]);
}
printf("\n%d\n", pos);*/
ans.pb(pos);
int tmp = per[0];
for(int i = pos; i >= 0; i = par[i]) {
int tmp2 = per[i];
per[i] = tmp;
tmp = tmp2;
}
}
void solve(){
scanf("%d", &n);
par[0] = -1;
REP(i, 1, n) {
scanf("%d", &par[i]);
}
REP(i, 0, n) {
scanf("%d", &per[i]);
}
while(1) {
REP(i, 0, n) {
leaf[i] = -1;
good[i] = 0;
}
for(int i = n - 1; i >= 0; i--) {
if (!used[i]) {
if (leaf[i] == -1) {
leaf[i] = i;
}
if (i > 0) {
if (leaf[par[i]] == -1) {
leaf[par[i]] = leaf[i];
} else {
leaf[par[i]] = -2;
}
}
}
}
int cnt_good = 0, cnt_all = 0;
REP(i, 0, n) {
if (leaf[i] >= 0) {
cnt_all++;
}
}
for(int i = n - 1; i >= 0; i--) {
if (leaf[i] == i) {
int last = INF;
ind_l[i] = INF;
ind_r[i] = i;
for(int j = i; j >= 0 && leaf[j] == i; j = par[j]) {
int val = per[j];
if (leaf[val] != i || val > last) {
break;
}
cnt_good++;
last = val;
ind_l[i] = j;
good[val] = 1;
}
}
}
int rr = n - 1;
for(; cnt_good < cnt_all; ) {
int val = per[0];
/*if (good[val]) {
if (val == 0) {
break;
}
REP(i, 0, n) {
printf("%d ", per[i]);
}
putchar('\n');
exit(0);
}*/
if (leaf[val] >= 0) {
int cur_leaf = leaf[val];
int pos;
for(pos = ind_r[cur_leaf]; pos >= ind_l[cur_leaf] && val < per[pos]; pos = par[pos]);
//printf("%d\n", pos);
move(pos);
cnt_good++;
good[val] = 1;
if (ind_l[cur_leaf] > ind_r[cur_leaf]) {
ind_l[cur_leaf] = ind_r[cur_leaf];
} else {
ind_l[cur_leaf] = par[ind_l[cur_leaf]];
}
continue;
}
for(; rr >= 0; rr--) {
if (!good[per[rr]] && leaf[per[rr]] >= 0) {
move(rr);
break;
}
}
}
if (leaf[0] >= 0) {
break;
}
REP(i, 0, n) {
if (leaf[i] >= 0) {
used[i] = 1;
}
}
}
assert(SZ(ans) <= 25000);
printf("%d\n", SZ(ans));
REP(i, 0, SZ(ans)) {
printf("%d\n", ans[i]);
}
//putchar('\n');
}
int main(){
//freopen(file".in", "r", stdin); freopen(file".out", "w", stdout);
int t = 1;
//cin >> t;
while(t--){
solve();
}
}
|
There are 2N balls in the xy-plane. The coordinates of the i-th of them is (x_i, y_i). Here, x_i and y_i are integers between 1 and N (inclusive) for all i, and no two balls occupy the same coordinates.
In order to collect these balls, Snuke prepared 2N robots, N of type A and N of type B. Then, he placed the type-A robots at coordinates (1, 0), (2, 0), ..., (N, 0), and the type-B robots at coordinates (0, 1), (0, 2), ..., (0, N), one at each position.
When activated, each type of robot will operate as follows.
* When a type-A robot is activated at coordinates (a, 0), it will move to the position of the ball with the lowest y-coordinate among the balls on the line x = a, collect the ball and deactivate itself. If there is no such ball, it will just deactivate itself without doing anything.
* When a type-B robot is activated at coordinates (0, b), it will move to the position of the ball with the lowest x-coordinate among the balls on the line y = b, collect the ball and deactivate itself. If there is no such ball, it will just deactivate itself without doing anything.
Once deactivated, a robot cannot be activated again. Also, while a robot is operating, no new robot can be activated until the operating robot is deactivated.
When Snuke was about to activate a robot, he noticed that he may fail to collect all the balls, depending on the order of activating the robots.
Among the (2N)! possible orders of activating the robots, find the number of the ones such that all the balls can be collected, modulo 1 000 000 007.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq x_i \leq N
* 1 \leq y_i \leq N
* If i ≠ j, either x_i ≠ x_j or y_i ≠ y_j.
Inputs
Input is given from Standard Input in the following format:
N
x_1 y_1
...
x_{2N} y_{2N}
Outputs
Print the number of the orders of activating the robots such that all the balls can be collected, modulo 1 000 000 007.
Examples
Input
2
1 1
1 2
2 1
2 2
Output
8
Input
4
3 2
1 2
4 1
4 2
2 2
4 4
2 1
1 3
Output
7392
Input
4
1 1
2 2
3 3
4 4
1 2
2 1
3 4
4 3
Output
4480
Input
8
6 2
5 1
6 8
7 8
6 5
5 7
4 3
1 4
7 6
8 3
2 8
3 6
3 2
8 5
1 5
5 8
Output
82060779
Input
3
1 1
1 2
1 3
2 1
2 2
2 3
Output
0
|
//little jump frog txdy
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#define rep(i,l,r) for(int i=(l);i<=(r);++i)
#define per(i,r,l) for(int i=(r);i>=(l);--i)
#define pb push_back
using namespace std;
const int N=2e5+10,P=1e9+7;
vector<int> F[N],G[N];
int vis[N],s[N],tp,x,y,n,u,v,fac[N],inv[N],ifac[N],sz[N],dsy[N],tot;
void dfs(int u,int fa=0){
vis[u]=1;s[++tp]=u;tot+=G[u].size();
for(int v:G[u]) if(v^fa){
if(!vis[v]) dfs(v,u);
else x=u,y=v;
}
}
void DFS(int u,int fa){for(int v:G[u]) if((v^fa)&&(v^x)) DFS(v,u),dsy[v]=u;}
void cmz(int u){
sz[u]=1;
for(int v:F[u]) cmz(v),sz[u]+=sz[v];
}
int QFJ(){
dsy[x]=y;DFS(x,y);
rep(i,1,tp) vis[s[i]]=0,F[s[i]].clear();
rep(i,1,tp) for(int v:G[s[i]]) if(v<dsy[s[i]]) vis[v]=1,F[s[i]].pb(v);
rep(i,1,tp) if(!vis[s[i]]) cmz(s[i]);
int ans=fac[tp];
rep(i,1,tp) ans=1ll*ans*inv[sz[s[i]]]%P;
rep(i,1,tp) vis[s[i]]=1;
return ans;
}
int main(){
scanf("%d",&n);
rep(i,1,(n<<1)) scanf("%d%d",&u,&v),G[u].pb(v+n),G[v+n].pb(u);
fac[0]=inv[1]=ifac[0]=1;
rep(i,2,(n<<1)) inv[i]=1ll*(P-P/i)*inv[P%i]%P;
rep(i,1,(n<<1)) fac[i]=1ll*fac[i-1]*i%P,ifac[i]=1ll*ifac[i-1]*inv[i]%P;
int qfj=0,ans=fac[n<<1];
rep(i,1,(n<<1)) if(!vis[i]){
tp=tot=0,dfs(i);if(tot^(tp<<1)) return puts("0"),0;
qfj=QFJ(),swap(x,y),qfj=(qfj+QFJ())%P,ans=1ll*ans*ifac[tp]%P*qfj%P;
}
printf("%d\n",ans);
return 0;
}
|
Let us consider the following operations on a string consisting of `A` and `B`:
1. Select a character in a string. If it is `A`, replace it with `BB`. If it is `B`, replace with `AA`.
2. Select a substring that is equal to either `AAA` or `BBB`, and delete it from the string.
For example, if the first operation is performed on `ABA` and the first character is selected, the string becomes `BBBA`. If the second operation is performed on `BBBAAAA` and the fourth through sixth characters are selected, the string becomes `BBBA`.
These operations can be performed any number of times, in any order.
You are given two string S and T, and q queries a_i, b_i, c_i, d_i. For each query, determine whether S_{a_i} S_{{a_i}+1} ... S_{b_i}, a substring of S, can be made into T_{c_i} T_{{c_i}+1} ... T_{d_i}, a substring of T.
Constraints
* 1 \leq |S|, |T| \leq 10^5
* S and T consist of letters `A` and `B`.
* 1 \leq q \leq 10^5
* 1 \leq a_i \leq b_i \leq |S|
* 1 \leq c_i \leq d_i \leq |T|
Input
Input is given from Standard Input in the following format:
S
T
q
a_1 b_1 c_1 d_1
...
a_q b_q c_q d_q
Output
Print q lines. The i-th line should contain the response to the i-th query. If S_{a_i} S_{{a_i}+1} ... S_{b_i} can be made into T_{c_i} T_{{c_i}+1} ... T_{d_i}, print `YES`. Otherwise, print `NO`.
Examples
Input
BBBAAAABA
BBBBA
4
7 9 2 5
7 9 1 4
1 7 2 5
1 7 2 4
Output
YES
NO
YES
NO
Input
AAAAABBBBAAABBBBAAAA
BBBBAAABBBBBBAAAAABB
10
2 15 2 13
2 13 6 16
1 13 2 20
4 20 3 20
1 18 9 19
2 14 1 11
3 20 3 15
6 16 1 17
4 18 8 20
7 20 3 14
Output
YES
YES
YES
YES
YES
YES
NO
NO
NO
NO
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int) 1e5 + 5;
char s[N], t[N];
int q;
int sus[N], sut[N];
int main() {
ios_base :: sync_with_stdio(false); cin.tie(NULL);
cin >> s + 1;
cin >> t + 1;
int ls = strlen(s + 1), lt = strlen(t + 1);
for (int i = 1; i <= ls; i++) sus[i] = sus[i - 1] + s[i] - 'A' + 1;
for (int i = 1; i <= lt; i++) sut[i] = sut[i - 1] + t[i] - 'A' + 1;
cin >> q;
while (q--) {
int a, b, c, d; cin >> a >> b >> c >> d;
if (abs(sus[b] - sus[a - 1] - (sut[d] - sut[c - 1])) % 3 == 0) cout << "YES\n";
else cout << "NO\n";
}
return 0;
}
|
Input
The input is given from Standard Input in the following format:
> $N \ K$
Output
* Please output the $K$-th triangle area.
* Print a floating number denoting the answer. The relative or absolute error of your answer should not be higher than $10^{−9}$.
Constraints
* $3 \le N \le 200,000$
* $1 \le K \le \frac{N(N-1)(N-2)}{6}$
Subtasks
Subtask 1 [ $160$ points ]
* $N \le 100$
Subtask 2 [ $240$ points ]
* $N \le 1000$
Subtask 3 [ $450$ points ]
* $N \le 200,000$
Output
* Please output the $K$-th triangle area.
* Print a floating number denoting the answer. The relative or absolute error of your answer should not be higher than $10^{−9}$.
Constraints
* $3 \le N \le 200,000$
* $1 \le K \le \frac{N(N-1)(N-2)}{6}$
Subtasks
Subtask 1 [ $160$ points ]
* $N \le 100$
Subtask 2 [ $240$ points ]
* $N \le 1000$
Subtask 3 [ $450$ points ]
* $N \le 200,000$
Input
The input is given from Standard Input in the following format:
> $N \ K$
Examples
Input
4 3
Output
1.0000000000000
Input
6 9
Output
0.86602540378
Input
12 220
Output
1.29903810568
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
using lint=long long;
const double PI=acos(-1);
double SIN[200000];
double area(int i,int j){if(j-i<0) printf("!! i = %d, j = %d\n",i,j); return 2*SIN[i]*SIN[j]*SIN[j-i]; }
int main(){
int n;
lint k; scanf("%d%lld",&n,&k);
rep(i,n) SIN[i]=sin(PI*i/n);
double lo=0,hi=1.3;
rep(_,35){
double mi=(lo+hi)/2;
lint cnt=0;
for(int i=1;i<n-1;i++){
int lo2=i,hi2=(n+i)/2+1;
while(hi2-lo2>1){
int mi2=(lo2+hi2)/2;
if(area(i,mi2)<mi) lo2=mi2;
else hi2=mi2;
}
int l=lo2;
int r=n-(l-i);
cnt+=(l-i)+(n-r)-(l==r?1:0);
}
cnt=cnt*n/3;
if(cnt<k) lo=mi;
else hi=mi;
}
printf("%.15f\n",lo);
return 0;
}
|
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (x, y) coordinate system.
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
<image>
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells. For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
<image>
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
Your task is to write a program which reads a sequence of points of fall (x, y) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
You may assume that the paper always consists of 10 × 10, and 0 ≤ x < 10, 0 ≤ y < 10.
Input
x1,y1,s1
x2,y2,s2
:
:
(xi, yi) represents the position of the i-th drop and si denotes its size. The number of drops is less than or equal to 50.
Output
Print the number of cells whose density value is 0 in first line.
Print the maximum value of density in the second line.
Example
Input
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
Output
77
5
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[][][] ink =
{
{
{0,0,0,0,0},
{0,0,1,0,0},
{0,1,1,1,0},
{0,0,1,0,0},
{0,0,0,0,0}
},
{
{0,0,0,0,0},
{0,1,1,1,0},
{0,1,1,1,0},
{0,1,1,1,0},
{0,0,0,0,0}
},
{
{0,0,1,0,0},
{0,1,1,1,0},
{1,1,1,1,1},
{0,1,1,1,0},
{0,0,1,0,0}
}
};
int[][] paper = new int[14][14];
while(sc.hasNext()) {
String s = sc.next();
String[] sp = s.split(",");
int x = Integer.valueOf(sp[0]);
int y = Integer.valueOf(sp[1]);
int size = Integer.valueOf(sp[2])-1;
for(int i=0;i<5;i++) {
for(int j=0;j<5;j++) {
paper[x+i][y+j]+=ink[size][i][j];
}
}
}
int empty = 0;
int max = 0;
for(int i=2;i<12;i++) {
for(int j=2;j<12;j++) {
if (paper[i][j] == 0) {
empty++;
}
max = Math.max(max,paper[i][j]);
}
}
System.out.println(empty + "\n" + max);
}
}
|
<image>
Matryoshka is a wooden doll in the shape of a female figure and is a typical Russian folk craft. Matryoshka has a nested structure in which smaller dolls are contained inside a large doll, and is composed of multiple dolls of different sizes. In order to have such a nested structure, the body of each doll has a tubular structure that can be divided into upper and lower parts. Matryoshka dolls are handmade by craftsmen, so each doll is unique and extremely valuable in the world.
Brothers Ichiro and Jiro loved to play with matryoshka dolls, and each had a pair of matryoshka dolls. Ichiro's matryoshka is made up of n dolls, and Jiro's matryoshka is made up of m dolls.
One day, curious Ichiro wondered if he could combine the dolls contained in these two pairs of matryoshka dolls to create a new matryoshka doll containing more dolls. In other words, I tried to make a pair of matryoshka dolls consisting of k dolls using n + m dolls. If k can be made larger than the larger of n and m, Ichiro's purpose will be achieved.
The two brothers got along well and wondered how to combine the dolls to maximize the value of k. But for the two younger ones, the problem is so difficult that you, older, decided to program to help your brothers.
Create a program that inputs the information of the matryoshka dolls of Ichiro and Jiro and outputs the number k of the dolls that the new matryoshka contains. No doll of the same size exists. Also, if we consider a doll to be a cylinder with a height h and a radius r, a doll with a height h and a radius r can contain a doll with a height x radius y that satisfies x <h and y <r.
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
h1 r1
h2 r2
::
hn rn
m
h1 r1
h2 r2
::
hm rm
The first line gives the number of matryoshka dolls of Ichiro n (n ≤ 100), and the following n lines give the height hi and radius ri (hi, ri <1000) of the ith doll of Ichiro. ..
The following line gives the number of Jiro's matryoshka dolls m (m ≤ 100), and the following m lines give the height hi and radius ri (hi, ri <1000) of Jiro's i-th doll.
The number of datasets does not exceed 20.
Output
Outputs the number k of dolls that the new matryoshka contains for each input dataset.
Example
Input
6
1 1
4 3
6 5
8 6
10 10
14 14
5
2 2
5 4
6 6
9 8
15 10
4
1 1
4 3
6 5
8 6
3
2 2
5 4
6 6
4
1 1
4 3
6 5
8 6
4
10 10
12 11
18 15
24 20
0
Output
9
6
8
|
import java.util.*;
public class Main{
void solve(){
Scanner sc = new Scanner(System.in);
while(true){
int n = sc.nextInt();
if(n==0) break;
ArrayList<int[]> hr = new ArrayList<int[]>();
for(int i=0; i<n; i++)
hr.add(new int[]{sc.nextInt(), sc.nextInt()});
int m = sc.nextInt();
for(int i=0; i<m; i++)
hr.add(new int[]{sc.nextInt(), sc.nextInt()});
Collections.sort(hr, new Comparator<int[]>(){
public int compare(int[] a, int[] b){
if(a[0]<b[0]) return -1;
if(a[0]>b[0]) return 1;
if(a[1]<b[1]) return -1;
if(a[1]>b[1]) return 1;
return 0;
}
});
int[] dp = new int[n+m];
Arrays.fill(dp,1);
for(int i=0; i<n+m; i++){
for(int j=0; j<i; j++){
if(hr.get(i)[0]<=hr.get(j)[0]) continue;
if(hr.get(i)[1]<=hr.get(j)[1]) continue;
dp[i] = Math.max(dp[i],dp[j]+1);
}
}
int ans = 0;
for(int i=0; i<n+m; i++) ans = Math.max(ans, dp[i]);
System.out.println(ans);
}
}
public static void main(String[] args){
new Main().solve();
}
}
|
A programming contest will be held at White Tiger University this year as well. There are several questions in the contest, each of which is assigned a score according to the difficulty level.
The executive committee decided to calculate the score for each team based on the following rules, taking into account both the number of questions solved and their scores.
"Of the questions answered correctly by a team, the maximum A that satisfies the fact that there are A or more questions with a score of A or higher is the score of that team."
Create a program that calculates a team's score from the number of questions that a team answered correctly and the scores of those questions.
Input
The input is given in the following format.
N
p1 p2 ... pN
The first line gives the number of questions the team answered correctly N (1 ≤ N ≤ 100). The score pi (1 ≤ pi ≤ 100) for each question answered correctly on the second line is given.
Output
Output the team score on one line.
Examples
Input
7
5 4 3 10 2 4 1
Output
4
Input
3
1 1 100
Output
1
Input
4
11 15 58 1
Output
3
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
#include <sstream>
#include <complex>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <iomanip>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n,m=0;
cin >> n;
vector<int> a(101, 0);
for (int i = 0; i < n; i++) {
int b; cin >> b;
a[b]++;
}
for (int i = 100; i >= 1; i--) {
a[i-1]+= a[i];
}
for (int i = 1; i <=100; i++) {
if (a[i] >= i) {
m = i;
}
}
cout << m << endl;
}
|
There is a long-established secondhand bookstore called JOI secondhand bookstore in your town, and you often use the JOI secondhand bookstore. Each book has a standard price, and you can buy it at that price if you go to the JOI secondhand bookstore.
At the JOI secondhand bookstore, books are classified into 10 genres such as novels, manga, and magazines. Genres are numbered from 1 to 10. The JOI secondhand bookstore has a service that if you buy books of the same genre in bulk, they will buy them at a high price. Specifically, when books of the same genre are purchased together in T books, the purchase price per book of that genre is T -1 yen higher than the standard price. For example, if books of the same genre with standard prices of 100 yen, 120 yen, and 150 yen are sold together at the JOI secondhand bookstore, the purchase prices will be 102 yen, 122 yen, and 152 yen, respectively.
By the way, you have to move in a hurry due to personal reasons. You have N books, but it is difficult to bring all the books to your new home, so I decided to sell K of the N books to the JOI secondhand bookstore.
input
Read the following input from standard input.
* The integers N and K are written on the first line, separated by blanks, indicating that the number of books you have is N, of which K books will be sold to JOI secondhand bookstores.
* The following N lines contain information about your book. On the first line of i + (1 ≤ i ≤ N), the integers Ci and Gi are written separated by blanks, indicating that the base price of the i-th book is Ci and the genre number is Gi. ..
output
Output an integer representing the maximum value of the total purchase price to the standard output on one line.
Example
Input
7 4
14 1
13 2
12 3
14 2
8 2
16 3
11 2
Output
60
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,k,c,g;
vector<int> book[11];
cin >> n >> k;
for(int i=0;i<n;i++){
cin >> c >> g;
book[g].push_back(c);
}
int dp[11][2001]={};
for(int i=1;i<=10;i++){
sort(book[i].begin(),book[i].end(),greater<int>());
for(int j=1;j<book[i].size();j++) book[i][j] += book[i][j-1];
for(int j=1;j<=k;j++){
dp[i][j] = max(dp[i][j],dp[i-1][j]);
for(int l=0;l<book[i].size();l++){
int sum = l+1;
if(j >= sum) dp[i][j] = max(dp[i][j],dp[i-1][j-sum]+book[i][l]+(sum)*l);
}
}
}
cout << dp[10][k] << endl;
return (0);
}
|
There are n wizards. They are numbered from 1 to n, and the i-th wizard has the magical power ri (1 ≤ i ≤ n). Now they are confronting a powerful wizard, whose enemy's magical power is S. n Wizards are good at fighting together, especially two people. When two wizards cooperate, the magical power is simply the sum, and you can use powerful magic to beat enemies that are strong to some extent. Your job is to output the total number of wizard pairs (i, j) (i ≠ j and 1 ≤ i ≤ n and 1 ≤ j ≤ n) that can win against enemies with magical power S. However, (i, j) and (j, i) are counted as the same pair. When one magical power is greater than the other, the side with the greater magical power wins. If they are equal, it does not mean that they have won by trade-off.
Constraints
* All inputs are integers
* 1 ≤ n ≤ 20,000
* 1 ≤ ri ≤ 100 (1 ≤ i ≤ n)
* 1 ≤ S ≤ 100
* The number of test cases does not exceed 100.
Input
The input consists of multiple test cases. Each test case follows the format below.
n S
r1
r2
...
rn
The meaning of each variable is as in the problem statement. The end of the input is indicated by a line where two 0s are separated by a single space.
Output
Output the total number of pairs (i, j) (i ≠ j) that satisfy the conditions on one line for each case.
Example
Input
3 7
1
3
10
0 0
Output
2
|
#include <iostream>
using namespace std;
int main () {
int n, s;
while (cin >> n >> s, n || s) {
int r[n];
for (int i = 0; i < n; i++) {
cin >> r[i];
}
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (r[i] + r[j] > s) {
count++;
}
}
}
cout << count << endl;
}
return 0;
}
|
Following FIFA World Cup, a larger competition called ``GIGA Universe Cup'' is taking place somewhere in our universe. Both FIFA World Cup and GIGA Universe Cup are two rounds competitions that consist of the first round, also known as ``group league,'' and the second called ``final tournament.'' In the first round, participating teams are divided into groups of four teams each. Each team in a group plays a match against each of the other teams in the same group. For example, let's say we have a group of the following four teams, ``Engband, Swedon, Argontina, and Nigerua.'' They play the following six matches: Engband - Swedon, Engband - Argontina, Engband - Nigerua, Swedon - Argontina, Swedon - Nigerua, and Argontina - Nigerua.
The result of a single match is shown by the number of goals scored by each team, like ``Engband 1 - 0 Argontina,'' which says Engband scored one goal whereas Argontina zero. Based on the result of a match, points are given to the two teams as follows and used to rank teams. If a team wins a match (i.e., scores more goals than the other), three points are given to it and zero to the other. If a match draws (i.e., the two teams score the same number of goals), one point is given to each.
The goal difference of a team in given matches is the total number of goals it scored minus the total number of goals its opponents scored in these matches. For example, if we have three matches ``Swedon 1 - 2 Engband,'' ``Swedon 3 - 4 Nigerua,'' and ``Swedon 5 - 6 Argontina,'' then the goal difference of Swedon in these three matches is (1 + 3 + 5) - (2 + 4+ 6) = -3.
Given the results of all the six matches in a group, teams are ranked by the following criteria, listed in the order of priority (that is, we first apply (a) to determine the ranking, with ties broken by (b), with ties broken by (c), and so on).
(a) greater number of points in all the group matches;
(b) greater goal difference in all the group matches;
(c) greater number of goals scored in all the group matches.
If two or more teams are equal on the basis of the above three criteria, their place shall be determined by the following criteria, applied in this order:
(d) greater number of points obtained in the group matches between the teams concerned;
(e) greater goal difference resulting from the group matches between the teams concerned;
(f) greater number of goals scored in the group matches between the teams concerned;
If two or more teams are stiIl equal, apply (d), (e), and (f) as necessary to each such group. Repeat this until those three rules to equal teams do not make any further resolution. Finally, teams that still remain equal are ordered by:
(g) drawing lots by the Organizing Committee for the GIGA Universe Cup.
The two teams coming first and second in each group qualify for the second round.
Your job is to write a program which, given the results of matches played so far in a group and one team specified in the group, calculates the probability that the specified team will qualify for the second round. You may assume each team has played exactly two matches and has one match to play. In total, four matches have been played and two matches are to be played.
Assume the probability that any team scores (exactly) p goals in any match is:
<image>
for p ≤ 8, and zero for p > 8 . Assume the lot in the step (g) is fair.
Input
The first line of the input is an integer, less than 1000, that indicates the number of subsequent records.
The rest of the input is the indicated number of records. A single record has the following format:
<image>
In the above, <_> is a single underscore (_) and <empty> a sequence of exactly four underscores (____). Each of <team>1, ... , <team>4 is either an asterisk character (*) followed by exactly three uppercase letters (e.g., *ENG), or an underscore followed by exactly three uppercase letters (e.g., _SWE). The former indicates that it is the team you are asked to calculate the probability of the second round qualification for. You may assume exactly one of <team>1, ... , <team>4 is marked with an asterisk. Each <m>ij(1 ≤ i < j ≤ 4) is a match result between the <team>i and <team>j. Each match result is either __-_ (i.e., two underscores, hyphen, and another underscore) or of the form _x-y where each of x and y is a single digit (≤ 8) . The former indicates that the corresponding match has not been played, whereas the latter that the result of the match was x goals by <team>i and y goals by <team>j. Since each team has played exactly two matches, exactly two match results are in the former format.
Output
The output should consist of n lines where n is the number of records in the input. The ith line should show the probability that the designated team (marked with an asterisk) will qualify for the second round in the ith record.
Numbers should be printed with exactly seven digits after the decimal point. Each number should not contain an error greater than 10-7.
Example
Input
5
_____*AAA__BBB__CCC__DDD
*AAA_______0-0__0-0___-_
_BBB_____________-___0-0
_CCC_________________0-0
_DDD____________________
______CHN__CRC__TUR_*BRA
_CHN_______0-2___-___0-4
_CRC____________1-1___-_
_TUR_________________1-2
*BRA____________________
______CMR_*KSA__GER__IRL
_CMR_______1-0___-___1-1
*KSA____________0-8___-_
_GER_________________1-1
_IRL____________________
______TUN__JPN_*BEL__RUS
_TUN________-___1-1__0-2
_JPN____________2-2__1-0
*BEL__________________-_
_RUS____________________
______MEX__CRO_*ECU__ITA
_MEX_______1-0__2-1___-_
_CRO_____________-___2-1
*ECU_________________0-2
_ITA____________________
Output
0.5000000
1.0000000
0.0000000
0.3852746
0.0353304
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < n; i++)
#define MAX_N 40
#define INF 1000000
#define MOD 1000000007
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int p[4][4];
int pp[4][4];
int me;
bool y[4];
int po[4], gd[4], go[4];
string str;
int comp(int z){
if(po[me] > po[z]) return 0;
if(po[me] < po[z]) return 1;
if(gd[me] > gd[z]) return 0;
if(gd[me] < gd[z]) return 1;
if(go[me] > go[z]) return 0;
if(go[me] < go[z]) return 1;
return 2;
}
double func(int st, int en){
rep(i,4){
if(y[i]) continue;
po[i] = 0; gd[i] = 0; go[i] = 0;
}
rep(i,4){
for(int j = i+1; j < 4; j++){
if(y[i] == true || y[j] == true) continue;
if(pp[i][j] > pp[j][i]){
po[i] += 3;
} else if(pp[i][j] < pp[j][i]){
po[j] += 3;
} else{
po[i] += 1; po[j] += 1;
}
gd[i] += pp[i][j]-pp[j][i];
gd[j] += pp[j][i]-pp[i][j];
go[i] += pp[i][j];
go[j] += pp[j][i];
}
}
int sst = st, een = en;
rep(i,4){
if(y[i]) continue;
if(i == me) continue;
int co = comp(i);
if(co == 0){
een--;
y[i] = true;
} else if(co == 1){
sst++;
y[i] = true;
}
}
if(een <= 2) return 1.0;
if(sst >= 3) return 0.0;
if(sst == st && een == en) return 1.0*(3-sst)/(een-sst+1);
return func(sst,een);
}
double kaku(int x){
double ret = 1.0;
for(int i = 1; i <= 8; i++) ret *= i;
for(int i = 1; i <= x; i++) ret /= i;
for(int i = 1; i <= 8-x; i++) ret /= i;
ret *= pow(0.25,x);
ret *= pow(0.25*3,8-x);
return ret;
}
void solve(){
cin >> str;
rep(i,4){
cin >> str;
if(str[0] == '*') me = i;
if(i == 0){
if(str[11] == '_'){
p[0][1] = -1;
p[1][0] = -1;
} else{
p[0][1] = str[11]-'0';
p[1][0] = str[13]-'0';
}
if(str[16] == '_'){
p[0][2] = -1;
p[2][0] = -1;
} else{
p[0][2] = str[16]-'0';
p[2][0] = str[18]-'0';
}
if(str[21] == '_'){
p[0][3] = -1;
p[3][0] = -1;
} else{
p[0][3] = str[21]-'0';
p[3][0] = str[23]-'0';
}
} else if(i == 1){
if(str[16] == '_'){
p[1][2] = -1;
p[2][1] = -1;
} else{
p[1][2] = str[16]-'0';
p[2][1] = str[18]-'0';
}
if(str[21] == '_'){
p[1][3] = -1;
p[3][1] = -1;
} else{
p[1][3] = str[21]-'0';
p[3][1] = str[23]-'0';
}
} else if(i == 2){
if(str[21] == '_'){
p[2][3] = -1;
p[3][2] = -1;
} else{
p[2][3] = str[21]-'0';
p[3][2] = str[23]-'0';
}
}
}
double ans = 0.0;
rep(i,9) rep(j,9) rep(k,9) rep(l,9){
rep(ii,4) rep(jj,4) pp[ii][jj] = p[ii][jj];
int counter = 0;
rep(ii,4) rep(jj,4){
if(pp[ii][jj] == -1){
if(counter == 0) pp[ii][jj] = i;
if(counter == 1) pp[ii][jj] = j;
if(counter == 2) pp[ii][jj] = k;
if(counter == 3) pp[ii][jj] = l;
counter++;
}
}
double now = kaku(i)*kaku(j)*kaku(k)*kaku(l);
memset(y,0,sizeof(y));
ans += now*func(1,4);
}
printf("%.9f\n",ans);
}
int main(){
int T;
cin >> T;
rep(i,T){
solve();
}
}
|
Example
Input
8 8
1 2
1 3
2 4
2 5
2 8
3 5
3 6
4 7
1000
100
100
10
10
10
1
1
3
2 8 6
2 4 7
2 7 8
Output
1000
10
100
|
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <cassert>
#include <cctype>
#include <stack>
#include <queue>
using namespace std;
typedef long long LL;
const int N = 50005;
const int M = 405;
typedef unsigned long long ULL;
int cnt, n;
bool times;
struct Bitset {
ULL a[M];
Bitset () {
memset(a , 0 , sizeof(a));
}
Bitset operator & (const Bitset &R) const {
Bitset res = *this;
for (int i = 0 ; i < M ; ++ i)
res.a[i] &= R.a[i];
return res;
}
void set(int x) {
if (!times) {
if (x >= 25000)
return;
} else {
if (x < 25000)
return;
x -= 25000;
}
a[x >> 6] |= 1ULL << (x & 63);
}
void Sset() {
for (int i = 0; i < M; ++i)
a[i] |= ~0ULL;
}
int operator == (const Bitset &A) const {
for (int i = 0; i < M; ++i)
if (a[i] != A.a[i]) return 0;
return 1;
}
int low() {
for (int i = 0; i < M; ++i) {
if (a[i] != 0) {
for (int j = 0; j < 64; ++j)
if (a[i] >> j & 1) return (i << 6) | j;
}
}
return 1 << 30;
}
void print() {
for (int i = 0; i < n; ++i)
printf("%llu ", a[i >> 6] >> (i & 63) & 1);
puts("");
}
} bit[N];
int m , pre[N] , mcnt;
struct Edge {
int y, nex;
}edge[N * 20];
int mark[N], dfn[N], color[N];
stack<int> sta;
vector<int> top[N];
vector<int> query[N];
bool u[N];
void dfs(int x) {
static int sum = 0;
mark[x] = dfn[x] = ++sum;
sta.push(x); u[x] = 1;
for (int k = pre[x]; k != -1; k = edge[k].nex){
int y = edge[k].y;
if (!dfn[y]) {
dfs(y);
mark[x] = min(mark[x], mark[y]);
} else if (u[y]) {
mark[x] = min(mark[x], dfn[y]);
}
}
if (mark[x] == dfn[x]) {
int y = -1;
++cnt;
while (y != x) {
y = sta.top();
sta.pop();
u[y] = 0;
color[y] = cnt;
mark[y] = 1 << 30;
top[cnt].push_back(y);
// printf("!!%d %d\n", cnt, y);
}
}
}
pair<int, int> C[N];
int num[N] , res[N] , Q;
int bo[N];
int m1[N * 10], m2[N * 10];
int main() {
// cout << (sizeof(bit) >> 20) << endl;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i)
scanf("%d%d", m1 + i, m2 + i);
for (int i = 0; i < n; ++i) {
scanf("%d", &C[i].first);
C[i].second = i;
}
sort(C, C + n);
for (int i = 0; i < n; ++i) {
num[C[i].second] = i;
}
memset(pre, -1, sizeof(pre));
for (int i = 0 ; i < m ; ++ i) {
int x = m1[i], y = m2[i];
//scanf("%d%d", &x, &y);
--x;
--y;
x = num[x];
y = num[y];
//printf("%d %d\n", x, y);
edge[mcnt] = (Edge) {y, pre[x]};
pre[x] = mcnt++;
}
for (int i = 0; i < n; ++i)
if (dfn[i] == 0) dfs(i);
scanf("%d" , &Q);
for (int i = 0 ; i < Q ; ++ i) {
int K;
scanf("%d", &K);
query[i].resize(K);
for (int j = 0 ; j < K ; ++ j) {
int x;
scanf("%d" , &x);
query[i][j] = num[x - 1];
}
res[i] = 1 << 30;
}
times = 0;
for (int i = 0; i < n; ++i) {
if (i != num[0]) {
bit[i].Sset();
}
}
bit[num[0]].set(num[0]);
for (int i = cnt; i > 0; --i) {
queue<int> que;
for (int j = 0; j < top[i].size(); ++j) {
que.push((top[i][j]));
}
while (!que.empty()) {
int x = que.front(); que.pop();
bo[x] = 0;
for (int k = pre[x]; k != -1; k = edge[k].nex) {
int y = edge[k].y;
if (color[y] != color[x]) continue;
static Bitset tmp;
tmp = bit[y];
bit[y] = bit[y] & bit[x];
bit[y].set(y);
if (!(tmp == bit[y]) && !bo[y]) {
bo[y] = 1;
que.push(y);
}
}
}
for (int j = 0; j < top[i].size(); ++j) {
int x = top[i][j];
for (int k = pre[x]; k != -1; k = edge[k].nex) {
int y = edge[k].y;
if (color[x] != color[y]) {
bit[y] = bit[y] & bit[x];
bit[y].set(y);
}
}
}
}
for (int i = 0 ; i < Q ; ++ i) {
int K = query[i].size();
static Bitset tmp;
tmp.Sset();
for (int j = 0; j < K; ++ j) {
int x = query[i][j];
tmp = tmp & bit[x];
}
res[i] = min(res[i] , tmp.low());
}
times = 1;
for (int i = 0; i < n; ++i) {
if (i != num[0]) {
bit[i].Sset();
}
}
bit[num[0]].set(num[0]);
for (int i = cnt; i > 0; --i) {
queue<int> que;
for (int j = 0; j < top[i].size(); ++j) {
que.push((top[i][j]));
}
while (!que.empty()) {
int x = que.front(); que.pop();
bo[x] = 0;
for (int k = pre[x]; k != -1; k = edge[k].nex) {
int y = edge[k].y;
if (color[y] != color[x]) continue;
static Bitset tmp;
tmp = bit[y];
bit[y] = bit[y] & bit[x];
bit[y].set(y);
if (!(tmp == bit[y]) && !bo[y]) {
bo[y] = 1;
que.push(y);
}
}
}
for (int j = 0; j < top[i].size(); ++j) {
int x = top[i][j];
for (int k = pre[x]; k != -1; k = edge[k].nex) {
int y = edge[k].y;
if (color[x] != color[y]) {
bit[y] = bit[y] & bit[x];
bit[y].set(y);
}
}
}
}
for (int i = 0 ; i < Q ; ++ i) {
int K = query[i].size();
static Bitset tmp;
tmp.Sset();
for (int j = 0; j < K; ++ j) {
int x = query[i][j];
tmp = tmp & bit[x];
}
res[i] = min(res[i] , tmp.low() + 25000);
printf("%d\n" , C[res[i]].first);
}
return 0;
}
|
Problem
There is a puzzle game where you move curling stones and stack them exactly on the goal square. The detailed rules are as follows.
The field consists of H × W squares, with stones placed in some squares at the beginning. There is only one goal square, and no stone is placed on the goal square from the beginning. In addition, the field is surrounded by an outer wall, so stones will not jump out of the field on the way.
Players can choose one stone for each move and launch it in either the up, down, left, or right direction to slide it. A slipping stone will continue to slide until it hits another stone or the outer wall of the field. If it hits another stone, the stone on the hit side will be recoiled and will slide in a chain in the same direction as the first shot.
For example, when stone A is launched to the right in the state of FIG. 1, the final state is as shown in FIG.
Figure 1
Figure 1
Figure 2
Figure 2
The condition for clearing this puzzle is to place one of the stones on the field exactly on the goal square. It will not be cleared if you pass the goal square.
Your job is to create a program that takes the initial state of the field as input and outputs whether the puzzle is clear or not.
Constraints
* 1 ≤ H ≤ 16
* 1 ≤ W ≤ 16
* 2 ≤ H x W ≤ 256
* Guaranteed to have only one goal square
* Guaranteed to have at least one square with curling stones on it
Input
The input is given in the following format.
H W
F11 F12 ... F1W
F21 F22 ... F2W
...
FH1 FH2 ... FHW
Fij is either'.',' O', or'@', and each has the following meaning. (1 ≤ i ≤ H, 1 ≤ j ≤ W)
*'.': Blank cell
*'o': The square on which the curling stone is placed
*'@': Goal square
Output
Print "yes" or "no" (not including "") on one line to see if the puzzle is clear.
Examples
Input
1 10
o........@
Output
yes
Input
3 6
......
.o..@.
......
Output
no
Input
6 4
....
.oo.
.oo.
....
.@..
....
Output
yes
|
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
bool solve(vector<string>ini_field,int gx,int gy) {
set<vector<string>>memo;
memo.emplace(ini_field);
queue<vector<string>>que;
que.push(ini_field);
int dx[] = { -1,0,1,0 };
int dy[] = { 0,1,0,-1 };
while (!que.empty()) {
auto field(que.front());
que.pop();
for (int y = 0; y < field.size(); ++y) {
for (int x = 0; x < field[0].size(); ++x) {
if (field[y][x] == 'o') {
if(y==gy&&x==gx)return true;
for (int way = 0; way < 4; ++way) {
auto nextfield(field);
int nx(x);
int ny(y);
while (true) {
const int next_x=nx+dx[way];
const int next_y=ny+dy[way];
if (next_x >= 0 && next_x < field[0].size() &&
next_y >= 0 && next_y < field.size()) {
swap(nextfield[ny][nx],nextfield[next_y][next_x]);
}
else {
break;
}
nx=next_x;
ny=next_y;
}
if (memo.find(nextfield) == memo.end()) {
memo.emplace(nextfield);
que.push(nextfield);
}
}
}
}
}
}
return false;
}
int main() {
int H,W;cin>>H>>W;
vector<string>field;
vector<pair<int,int>>curs;
int gx,gy;
for (int i = 0; i < H; ++i) {
string st;cin>>st;
field.push_back(st);
for (int j = 0; j < W; ++j) {
auto ch(st[j]);
{
if (ch == 'o') {
curs.push_back(make_pair(i,j));
}
else if (ch == '@') {
gx=j;
gy=i;
field[i][j]='.';
}
}
}
}
bool ok=false;
if (curs.size() >= 3&&H>1&&W>1) {
ok=true;
}
else {
ok=solve(field,gx,gy);
}
if(ok)cout<<"yes"<<endl;
else cout<<"no"<<endl;
return 0;
}
|
Some of you might have seen instruments like the figure below.
<image>
Figure 1: Spirograph
There are a fixed circle (indicated by A in the figure) and a smaller interior circle with some pinholes (indicated by B). By putting a pen point through one of the pinholes and then rolling the circle B without slipping around the inside of the circle A, we can draw curves as illustrated below. Such curves are called hypotrochoids.
<image>
Figure 2: An Example Hypotrochoid
Your task is to write a program that calculates the length of hypotrochoid, given the radius of the fixed circle A, the radius of the interior circle B, and the distance between the B’s centroid and the used pinhole.
Input
The input consists of multiple test cases. Each test case is described by a single line in which three integers P, Q and R appear in this order, where P is the radius of the fixed circle A, Q is the radius of the interior circle B, and R is the distance between the centroid of the circle B and the pinhole. You can assume that 0 ≤ R < Q < P ≤ 1000. P, Q, and R are separated by a single space, while no other spaces appear in the input.
The end of input is indicated by a line with P = Q = R = 0.
Output
For each test case, output the length of the hypotrochoid curve. The error must be within 10-2 (= 0.01).
Example
Input
3 2 1
3 2 0
0 0 0
Output
13.36
6.28
|
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
int INF = 1 << 28;
int p, q, r;
final int DIV = 1000000;
double s, t;
void run() {
Scanner sc = new Scanner(System.in);
for(;;) {
p = sc.nextInt();
q = sc.nextInt();
r = sc.nextInt();
if( (p|q|r) == 0 ) break;
s = p - q;
t = (double)( q-p ) / q;
if( r == 0 ) System.out.println((double)2 * ( p - q ) * PI );
else {
double sum = 0;
int loop = q / lcm(q, p-q);
double theta = 2 * PI * loop;
for(int i=0;i<DIV;i++) {
double t1 = theta / DIV * i;
double t2 = theta / DIV * ( i + 1 );
P p = hypotroid( (t1+t2) / 2 ) ;
sum += sqrt(p.x * p.x + p.y * p.y) * (t2-t1);
}
System.out.println(sum);
}
}
}
int lcm( int a, int b ) {
if( b == 0 ) return a;
else return lcm(b, a%b);
}
P hypotroid( double theta ) {
double x = - s * sin(theta) - (double) t * r * sin( theta * t );
double y = s * cos(theta) + (double) t * r * cos( theta * t );
return new P(x, y);
}
class P {
double x, y;
P(double x, double y) {
this.x = x;
this.y = y;
}
}
public static void main(String[] args) {
new Main().run();
}
void debug(Object... os) {
System.err.println(Arrays.deepToString(os));
}
}
|
A video game company called ICPC (International Company for Playing and Competing) is now developing a new arcade game. The new game features a lot of branches. This makes the game enjoyable for everyone, since players can choose their routes in the game depending on their skills. Rookie players can choose an easy route to enjoy the game, and talented players can choose their favorite routes to get high scores.
In the game, there are many checkpoints connected by paths. Each path consists of several stages, and completing stages on a path leads players to the next checkpoint. The game ends when players reach a particular checkpoint. At some checkpoints, players can choose which way to go, so routes diverge at that time. Sometimes different routes join together at a checkpoint. The paths between checkpoints are directed, and there is no loop (otherwise, players can play the game forever). In other words, the structure of the game can be viewed as a DAG (directed acyclic graph), when considering paths between checkpoints as directed edges.
Recently, the development team completed the beta version of the game and received feedbacks from other teams. They were quite positive overall, but there are some comments that should be taken into consideration. Some testers pointed out that some routes were very short compared to the longest ones. Indeed, in the beta version, the number of stages in one play can vary drastically depending on the routes. Game designers complained many brilliant ideas of theirs were unused in the beta version because of the tight development schedule. They wanted to have more stages included in the final product.
However, it’s not easy to add more stages. this is an arcade game – if the playing time was too long, it would bring down the income of the game and owners of arcades would complain. So, the longest route of the final product can’t be longer than that of the beta version. Moreover, the producer of the game didn’t want to change the structure of paths (i.e., how the checkpoints connect to each other), since it would require rewriting the scenario, recording voices, creating new cutscenes, etc.
Considering all together, the producer decided to add as many new stages as possible, while keeping the maximum possible number of stages in one play and the structure of paths unchanged. How many new stages can be added to the game?
Input
N M
x1 y1 s1
.
.
.
xM yM sM
The first line of the input contains two positive integers N and M (2 ≤ N ≤ 100, 1 ≤ M ≤ 1000). N indicates the number of checkpoints, including the opening and ending of the game. M indicates the number of paths between checkpoints.
The following M lines describe the structure of paths in the beta version of the game. The i-th line contains three integers xi , yi and si (0 ≤ xi < yi ≤ N - 1, 1 ≤ si ≤ 1000), which describe that there is a path from checkpoint xi to yi consists of si stages. As for indices of the checkpoints, note that 0 indicates the opening of the game and N - 1 indicates the ending of the game. You can assume that, for every checkpoint i, there exists a route from the opening to the ending which passes through checkpoint i. You can also assume that no two paths connect the same pair of checkpoints.
Output
Output a line containing the maximum number of new stages that can be added to the game under the following constraints:
* You can’t increase the maximum possible number of stages in one play (i.e., the length of the longest route to the ending).
* You can’t change the structure of paths (i.e., how the checkpoints connect to each other).
* You can’t delete any stage that already exists in the beta version.
Examples
Input
3 3
0 1 5
1 2 3
0 2 2
Output
6
Input
2 1
0 1 10
Output
0
Input
4 6
0 1 5
0 2 5
0 3 5
1 2 5
1 3 5
2 3 5
Output
20
|
#include <bits/stdc++.h>
#define ll long long
#define INF 1000000005
#define MOD 1000000007
#define EPS 1e-10
#define rep(i,n) for(int i=0;i<(int)(n);++i)
#define rrep(i,n) for(int i=(int)(n)-1;i>=0;--i)
#define srep(i,s,t) for(int i=(int)(s);i<(int)(t);++i)
#define each(a,b) for(auto& (a): (b))
#define all(v) (v).begin(),(v).end()
#define len(v) (int)(v).size()
#define zip(v) sort(all(v)),v.erase(unique(all(v)),v.end())
#define cmx(x,y) x=max(x,y)
#define cmn(x,y) x=min(x,y)
#define fi first
#define se second
#define pb push_back
#define show(x) cout<<#x<<" = "<<(x)<<endl
#define spair(p) cout<<#p<<": "<<p.fi<<" "<<p.se<<endl
#define sar(a,n) cout<<#a<<":";rep(pachico,n)cout<<" "<<a[pachico];cout<<endl
#define svec(v) cout<<#v<<":";rep(pachico,v.size())cout<<" "<<v[pachico];cout<<endl
#define svecp(v) cout<<#v<<":";each(pachico,v)cout<<" {"<<pachico.first<<":"<<pachico.second<<"}";cout<<endl
#define sset(s) cout<<#s<<":";each(pachico,s)cout<<" "<<pachico;cout<<endl
#define smap(m) cout<<#m<<":";each(pachico,m)cout<<" {"<<pachico.first<<":"<<pachico.second<<"}";cout<<endl
using namespace std;
typedef pair<int,int> P;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<P> vp;
typedef vector<string> vs;
const int MAX_N = 101;
struct edge
{
int to,cost;
};
vector<edge> G[MAX_N];
int d[MAX_N];
// max c * x s.t. A*x <= b, x >= 0
class Simplex {
private:
using Arr = vector<double>;
using Mat = vector<vector<double> >;
int* index;
double** a;
int row, column, L;
void Set(const Mat& A, const Arr& b, const Arr& c){
infinity = none = false;
row = A.size(),column = A[0].size() + 1;
index = new int[row + column];
int i, j;
for(i = 0; i < row + column; i++){
index[i] = i;
}
L = row;
a = new double*[row + 2];
for(i = 0; i < row + 2; i++){
a[i] = new double[column + 4];
}
for(i = 0; i < row; i++){
for(j = 0; j < column - 1; j++){
a[i][j] = -A[i][j];
}
a[i][column-1] = 1;
a[i][column] = b[i];
if(a[L][column] > a[i][column]) L = i;
}
for(j = 0; j < column - 1; j++){
a[row][j] = c[j];
}
a[row+1][column-1] = -1;
}
void solve(){
int E, i, j;
for(E = column - 1;;){
if(L < row){
swap(index[E], index[L + column]);
a[L][E] = 1 / a[L][E];
for(j = 0; j < column + 1; j++){
if(j != E) a[L][j] *= -a[L][E];
}
for(i = 0; i < row + 2; i++){
if(abs(a[i][E]) < EPS || i == L) continue;
for(j = 0; j < column + 1; j += 4){
if(j != E) a[i][j] += a[i][E] * a[L][j];
if(j+1 != E) a[i][j+1] += a[i][E] * a[L][j+1];
if(j+2 != E) a[i][j+2] += a[i][E] * a[L][j+2];
if(j+3 != E) a[i][j+3] += a[i][E] * a[L][j+3];
}
a[i][E] = a[i][E] * a[L][E];
}
}
E = -1;
double pre = EPS, pre2 = EPS;
for(j = 0; j < column; j++){
if(E < 0){
if(abs(a[row + 1][j]) < EPS && a[row][j] > pre2) E = j, pre2 = a[row][j];
else if(a[row + 1][j] > pre) E = j, pre = a[row + 1][j];
}
}
if(E < 0) break;
L = -1;
for(i = 0; i < row; i++){
if(a[i][E] < -EPS){
if(L < 0 || a[L][column] / a[L][E] - a[i][column] / a[i][E] < EPS) L = i;
}
}
if(L < 0){
infinity = true;
return;
}
}
if(a[row + 1][column] < -EPS){
none = true;
return;
}
x.assign(column - 1, 0);
for(i = 0; i < row; i++){
if(index[column + i] < column - 1) x[index[column + i]] = a[i][column];
}
ans = a[row][column];
}
public:
bool infinity, none;
double ans;
Arr x;
Simplex(const Mat& A, const Arr& b, const Arr& c){
Set(A,b,c);
solve();
}
};
struct eda{
int from,to,cost;
};
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n,m;
cin >> n >> m;
vector<eda> es(m);
rep(i,m){
int x,y,s;
cin >> x >> y >> s;
G[x].pb((edge){y,s});
es[i] = (eda){x,y,s};
}
rrep(i,n){
each(e,G[i]){
cmx(d[i],d[e.to]+e.cost);
}
}
int mx = d[0];
vd b(m+1,0.0), c(n+m,0.0);
rep(i,m){
c[n+i] = 1.0;
}
vector<vd> A(m+1,vd(n+m,0.0));
rep(i,m){
A[i][es[i].from] = 1, A[i][es[i].to] = -1, A[i][n+i] = 1;
b[i] = -es[i].cost;
}
A[m][n-1] = 1, b[m] = mx;
Simplex sp(A,b,c);
int ans = round(sp.ans);
cout << ans << "\n";
return 0;
}
|
Problem statement
Mr. K, a student of the magic department of a certain university, lives in a vast mansion. There was a forest behind the mansion, but there were places where no trees were growing. I felt that it would look bad from the mansion as it was, so Mr. K decided to plant a tree in a place where no trees were growing. Mr. K, who is the egg of a witch, can summon a familiar, so I thought about letting the familiar do the work of planting trees.
The forest can be regarded as a rectangular area with H × W cells. Each cell has either one tree or no tree. Mr. K specifies one of these H × W cells and summons a familiar there. However, since Mr. K is still an inexperienced person, he cannot adjust his magical power, and when he summons a familiar, he always summons five. To make matters worse, the familiar that K summons is a twist, and if there is no tree in the cell you visited, you will plant a tree there, but if the cell you visited already has a tree in that cell, It erases the tree. Four of the summoned familiars will start from the designated cell, scatter north, south, east, and west, proceed along a straight line, and visit each cell one by one. These familiars disappear when they go out of the forest. The rest of the familiars visit only the specified cells and then disappear immediately.
To be more precise, when Mr. K summons a familiar to cell (i, j), if there is no tree for H + W-1 cells in the i-th row or j-th column, the tree Is planted, and if the tree is growing, the tree is erased.
Since summoning requires a lot of magical power, I want to cover the forest with trees with as few summons as possible. In which cell can Mr. K summon a familiar to cover the forest with a tree with the minimum number of summons?
Input format
The input is given in the following format.
H W
a1,1 ... a1, W
...
aH, 1 ... aH, W
If ai, j is 1, it means that a tree is growing in cell (i, j), and if it is 0, it means that it is not growing.
Output format
If it is not possible to cover the forest with trees, print `Impossible` on one line. If not, output the summoning procedure that minimizes the number of summons to line H in the following format.
b1,1 ... b1, W
...
bH, 1 ... bH, W
bi, j must be 0 or 1, 1 means summoning familiars to cell (i, j), 0 means not summoning.
Note that there is no point in summoning familiars to the same place twice. If there are multiple summoning procedures that minimize the number of summons, any of them may be output.
Constraint
* 2 ≤ H, W ≤ 1000
* H and W are even numbers
* ai, j ∈ {0, 1}
A group of three test cases is set to judge this problem. In addition to the above constraints, the test cases included in this group also meet the following constraints.
* H × W ≤ 20
Examples
Input
4 4
0 0 0 1
0 1 1 0
0 1 1 0
1 0 0 0
Output
1 0 0 0
0 0 0 0
0 0 0 0
0 0 0 1
Input
None
Output
None
|
#include<iostream>
#include<cstdio>
using namespace std;
int main(){
int h,w,imap[1010][1010],H[1010],W[1010];
for(int i=0;i<1010;i++)H[i] = W[i] = 0;
cin >> h >> w;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
cin >> imap[i][j];
if(imap[i][j] == 0)H[i]++,W[j]++;
}
}
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
(H[i]+W[j]-1+imap[i][j])%2==0?cout << 0:cout << 1;
if(j != w-1)cout << ' ';
}
cout << endl;
}
return 0;
}
|
Problem Statement
You have a rectangular board with square cells arranged in $H$ rows and $W$ columns. The rows are numbered $1$ through $H$ from top to bottom, and the columns are numbered $1$ through $W$ from left to right. The cell at the row $i$ and the column $j$ is denoted by $(i, j)$. Each cell on the board is colored in either Black or White.
You will paint the board as follows:
1. Choose a cell $(i, j)$ and a color $c$, each uniformly at random, where $1 \le i \le H$, $1 \le j \le W$, and $c \in \\{{\rm Black}, {\rm White}\\}$.
2. Paint the cells $(i', j')$ with the color $c$ for any $1 \le i' \le i$ and $1 \le j' \le j$.
Here's an example of the painting operation. You have a $3 \times 4$ board with the coloring depicted in the left side of the figure below. If your random choice is the cell $(2, 3)$ and the color Black, the board will become as shown in the right side of the figure. $6$ cells will be painted with Black as the result of this operation. Note that we count the cells "painted" even if the color is not actually changed by the operation, like the cell $(1, 2)$ in this example.
<image>
Fig: An example of the painting operation
Given the initial coloring of the board and the desired coloring, you are supposed to perform the painting operations repeatedly until the board turns into the desired coloring. Write a program to calculate the expected total number of painted cells in the sequence of operations.
Input
The input consists of several datasets. The number of datasets is at most $100$.
The first line of each dataset contains two integers $H$ and $W$ ($1 \le H, W \le 5$), the numbers of rows and columns of the board respectively. Then given are two coloring configurations of the board, where the former is the initial coloring and the latter is the desired coloring. A coloring configuration is described in $H$ lines, each of which consists of $W$ characters. Each character is either B or W, denoting a Black cell or a White cell, respectively. There is one blank line between two configurations, and also after each dataset. You can assume that the resulting expected value for each dataset will not exceed $10^9$.
The input is terminated by a line with two zeros, and your program should not process this as a dataset.
Output
For each dataset, your program should output the expected value in a line. The absolute error or the relative error in your answer must be less than $10^{-6}$.
Sample Input
1 2
BB
WW
2 1
B
W
B
W
2 2
BW
BW
WW
WW
3 4
BBBB
BBBB
BBBB
WWWW
WWWW
WWWW
5 5
BBBBB
BBBBB
BBBBB
BBBBB
BBBBB
BBBBB
BBBWB
BBBBB
BWBBB
BBBBB
0 0
Output for the Sample Input
6.0000000000
0.0000000000
12.8571428571
120.0000000000
23795493.8449918639
Example
Input
1 2
BB
WW
2 1
B
W
B
W
2 2
BW
BW
WW
WW
3 4
BBBB
BBBB
BBBB
WWWW
WWWW
WWWW
5 5
BBBBB
BBBBB
BBBBB
BBBBB
BBBBB
BBBBB
BBBWB
BBBBB
BWBBB
BBBBB
0 0
Output
6.0000000000
0.0000000000
12.8571428571
120.0000000000
23795493.8449918639
|
#include <cmath>
#include <cstdio>
#include <cstring>
#include <algorithm>
const int MAXN = 555;
const int MAXS = 101111;
const int MAXH = 555;
const int MAXL = 555;
const long double eps = 1e-15;
int n, m, cnt, c[MAXN], l[MAXS], graph[MAXN][MAXN];
char a[MAXN][MAXN], b[MAXN][MAXN];
namespace Gaussian_Elimination{
long double a[MAXH][MAXL + 1], x[MAXL];
void init(int nE, int nV) {
std::fill(x + 1, x + nV + 1, 0);
for (int i = 1; i <= nE; i++)
for (int j = 1; j <= nV + 1; j++)
a[i][j] = 0;
}
int main(int nE, int nV) { // 0:Normal 1:No solution 2:multi-solution
for (int h = 1; h <= nV; h++) {
for (int i = h + 1; i <= nE; i++) {
if (fabs(a[h][h]) > fabs(a[i][h])) continue;
for (int j = 1; j <= nV + 1; j++)
std::swap(a[h][j], a[i][j]);
}
if (fabs(a[h][h]) < eps) continue;
for (int i = h + 1; i <= nE; i++) {
if (fabs(a[i][h]) < eps) continue;
long double t = a[i][h] / a[h][h];
for (int j = h; j <= nV + 1; j++)
a[i][j] -= a[h][j] * t;
}
}
for (int h = nV + 1; h <= nE; h++) {
if (fabs(a[h][nV + 1]) < eps) continue;
return 1;
}
for (int h = nV; h >= 1; h--) {
x[h] = a[h][nV + 1];
for (int i = h + 1; i <= nV; i++)
x[h] -= x[i] * a[h][i];
if (fabs(a[h][h]) < eps) {
if (fabs(x[h]) < eps) return 2;
else return 1;
}
x[h] /= a[h][h];
}
return 0;
}
};
int toInt(char c) {
if (c == 'W') return 0;
else return 1;
}
int getLabel(int *c) {
int ret = 0;
for (int i = 1; i <= n; i++)
ret = ret * 6 + c[i];
return ret;
}
void dfs(int h, int last) {
if (h == n + 1) {
l[getLabel(c)] = ++cnt;
return;
}
for (int i = 0; i <= last; i++) {
c[h] = i;
dfs(h + 1, i);
}
}
void getEquation(int h, int last) {
if (h == n + 1) {
static int tmp[MAXN][MAXN], cur[MAXN][MAXN], next[MAXN], graph[MAXN][MAXN];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
cur[i][j] = toInt(b[i][j]) ^ (j <= c[i]);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int col = 0; col < 2; col++) {
for (int k = 1; k <= n; k++)
for (int l = 1; l <= m; l++) {
tmp[k][l] = cur[k][l];
graph[k][l] = 0;
}
for (int k = 1; k <= i; k++)
for (int l = 1; l <= j; l++) {
tmp[k][l] = col;
}
for (int k = 1; k <= n; k++)
for (int l = 1; l <= m; l++)
if (tmp[k][l] != toInt(b[k][l])) {
for (int p = 1; p <= k; p++)
for (int q = 1; q <= l; q++)
graph[p][q] = 1;
}
for (int k = 1; k <= n; k++) {
next[k] = 0;
for (int l = 1; l <= m; l++)
if (graph[k][l]) next[k] = l;
}
Gaussian_Elimination::a[l[getLabel(c)]][l[getLabel(next)]] -= 1.0 / n / m / 2.0;
Gaussian_Elimination::a[l[getLabel(c)]][cnt + 1] += (long double)i * j / n / m / 2.0;
}
return;
}
for (int i = 0; i <= last; i++) {
c[h] = i;
getEquation(h + 1, i);
}
}
int main() {
while (scanf("%d%d", &n, &m) == 2) {
if (n == 0 && m == 0) break;
for (int i = 1; i <= n; i++) scanf("%s", a[i] + 1);
for (int i = 1; i <= n; i++) scanf("%s", b[i] + 1);
cnt = 0;
dfs(1, m);
Gaussian_Elimination::init(cnt, cnt);
getEquation(1, m);
for (int i = 1; i <= cnt; i++)
Gaussian_Elimination::a[i][i]++;
static int now[MAXN];
for (int i = 1; i <= n; i++) now[i] = 0;
for (int i = 1; i <= cnt + 1; i++) {
Gaussian_Elimination::a[l[getLabel(now)]][i] = 0;
}
Gaussian_Elimination::a[l[getLabel(now)]][l[getLabel(now)]] = 1;
Gaussian_Elimination::main(cnt, cnt);
for (int k = 1; k <= n; k++)
for (int l = 1; l <= m; l++)
graph[k][l] = 0;
for (int k = 1; k <= n; k++)
for (int l = 1; l <= m; l++)
if (a[k][l] != b[k][l]) {
for (int p = 1; p <= k; p++)
for (int q = 1; q <= l; q++)
graph[p][q] = 1;
}
for (int k = 1; k <= n; k++) {
now[k] = 0;
for (int l = 1; l <= m; l++)
if (graph[k][l]) now[k] = l;
}
double answer = Gaussian_Elimination::x[l[getLabel(now)]];
printf("%.10f\n", answer);
//Gaussian_Elimination::print(cnt, cnt);
}
return 0;
}
|
Example
Input
201
Output
701
|
/* -*- coding: utf-8 -*-
*
* 2728.cc: Change a Password
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
using namespace std;
/* constant */
const int MAX_N = 10;
/* typedef */
typedef long long ll;
typedef vector<int> vi;
typedef queue<int> qi;
typedef pair<int,int> pii;
typedef set<ll> sl;
/* global variables */
int ds[MAX_N];
/* subroutines */
/* main */
int main() {
string s;
cin >> s;
int n = s.size();
ll a = atoll(s.c_str());
//printf("%0*lld\n", n, a);
for (int i = 0; i < MAX_N; i++) ds[i] = i;
sl bs;
do {
ll b = 0;
for (int i = 0; i < n; i++) b = b * 10 + ds[i];
bs.insert(b);
} while (next_permutation(ds, ds + MAX_N));
//printf("%lu\n", bs.size());
ll tens = 1;
for (int i = 0; i < n; i++) tens *= 10;
ll maxdf = -1, maxb = -1;
for (sl::iterator sit = bs.begin(); sit != bs.end(); sit++) {
const ll &b = *sit;
ll ab = abs(a - b);
ll df = min(ab, tens - ab);
if (maxdf < df) maxdf = df, maxb = b;
}
printf("%0*lld\n", n, maxb);
return 0;
}
|
Mr. Endo wanted to write the code that performs breadth-first search (BFS), which is a search algorithm to explore all vertices on a directed graph. An example of pseudo code of BFS is as follows:
1: $current \leftarrow \{start\_vertex\}$
2: $visited \leftarrow current$
3: while $visited \ne$ the set of all the vertices
4: $found \leftarrow \{\}$
5: for $u$ in $current$
6: for each $v$ such that there is an edge from $u$ to $v$
7: $found \leftarrow found \cup \{v\}$
8: $current \leftarrow found \setminus visited$
9: $visited \leftarrow visited \cup found$
However, Mr. Endo apparently forgot to manage visited vertices in his code. More precisely, he wrote the following code:
1: $current \leftarrow \{start\_vertex\}$
2: while $current \ne$ the set of all the vertices
3: $found \leftarrow \{\}$
4: for $u$ in $current$
5: for each $v$ such that there is an edge from $u$ to $v$
6: $found \leftarrow found \cup \{v\}$
7: $current \leftarrow found$
You may notice that for some graphs, Mr. Endo's program will not stop because it keeps running infinitely. Notice that it does not necessarily mean the program cannot explore all the vertices within finite steps. Your task here is to make a program that determines whether Mr. Endo's program will stop within finite steps for a given directed graph in order to point out the bug to him. Also, calculate the minimum number of loop iterations required for the program to stop if it is finite. Since the answer might be huge, thus print the answer modulo $10^9 +7$, which is a prime number.
Input
The input consists of a single test case formatted as follows.
$N$ $M$
$u_1$ $v_1$
:
$u_M$ $v_M$
The first line consists of two integers $N$ ($2 \leq N \leq 500$) and $M$ ($1 \leq M \leq 200,000$), where $N$ is the number of vertices and $M$ is the number of edges in a given directed graph, respectively. The $i$-th line of the following $M$ lines consists of two integers $u_i$ and $v_i$ ($1 \leq u_i, v_i \leq N$), which means there is an edge from $u_i$ to $v_i$ in the given graph. The vertex $1$ is the start vertex, i.e. $start\\_vertex$ in the pseudo codes. You can assume that the given graph also meets the following conditions.
* The graph has no self-loop, i.e., $u_i \ne v_i$ for all $1 \leq i \leq M$.
* The graph has no multi-edge, i.e., $(u_i, v_i) \le (u_j, v_j)$ for all $1 \leq i < j \leq M$.
* For each vertex $v$, there is at least one path from the start vertex $1$ to $v$.
Output
If Mr. Endo's wrong BFS code cannot stop within finite steps for the given input directed graph, print '-1' in a line. Otherwise, print the minimum number of loop iterations required to stop modulo $10^9+7$.
Examples
Input
4 4
1 2
2 3
3 4
4 1
Output
-1
Input
4 5
1 2
2 3
3 4
4 1
1 3
Output
7
Input
5 13
4 2
2 4
1 2
5 4
5 1
2 1
5 3
4 3
1 5
4 5
2 3
5 2
1 3
Output
3
|
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define SIZE 505
int V,E;
int root = 0;
int POW[20],pow_max = 0;
bool can_visit[20][SIZE][SIZE],check[2][SIZE];
bool isOK(int count){
int CURRENT = 0,NEXT = 1;
for(int i = 0; i < V; i++){
check[CURRENT][i] = false;
check[NEXT][i] = false;
}
bool FLG;
check[CURRENT][root] = true;
for(int i = pow_max; i >= 0; i--){
if(POW[i] > count)continue;
count -= POW[i];
for(int k = 0; k < V; k++){
if(!check[CURRENT][k])continue;
for(int p = 0; p < V; p++){
if(can_visit[i][k][p]){
check[NEXT][p] = true;
}
}
}
FLG = true;
for(int k = 0; k < V; k++){
if(!check[NEXT][k]){
FLG = false;
break;
}
}
if(FLG)return true;
swap(CURRENT,NEXT);
for(int k = 0; k < V; k++){
check[NEXT][k] = false;
}
}
return false;
}
int main(){
scanf("%d %d",&V,&E);
POW[0] = 1;
for(int i = 1; i <= 19; i++){
POW[i] = POW[i-1]*2;
}
for(int i = 0; i <= 19; i++){
if(POW[i] > V*V+(V+5)){
pow_max = i;
break;
}
}
for(int i = 0; i <= pow_max; i++){
for(int from = 0; from < V; from++){
for(int to = 0; to < V; to++){
can_visit[i][from][to] = false;
}
}
}
int from,to;
for(int loop = 0; loop < E; loop++){
scanf("%d %d",&from,&to);
from--;
to--;
can_visit[0][from][to] = true;
}
for(int i = 1; i <= pow_max; i++){
for(int a = 0; a < V; a++){
for(int b = 0; b < V; b++){
if(!can_visit[i-1][a][b])continue;
for(int c = 0; c < V; c++){
if(!can_visit[i-1][b][c])continue;
can_visit[i][a][c] = true;
}
}
}
}
int left = 0,right = V*V+V+5,mid = (left+right)/2;
int ans = BIG_NUM;
while(left <= right){
if(isOK(mid)){
ans = mid;
right = mid-1;
}else{
left = mid+1;
}
mid = (left+right)/2;
}
if(ans == BIG_NUM){
printf("-1\n");
}else{
printf("%d\n",ans);
}
return 0;
}
|
Problem
Gaccho has his favorite watch. One day the minute hand of the clock came off and I lost it somewhere. However, Gaccho wants to keep using the watch and wants to read the time with only the short hand.
Output the time (hour h, minute m) for the information θ of the short hand. A clock is a so-called analog clock, in which numbers 1 to 12 are arranged clockwise at regular intervals in ascending order.
Constraints
* 0 ≤ θ ≤ 359
Input
The input is given in the following format.
θ
An integer representing the angle θ of the short hand is given in one line in degrees. The direction pointed by the short hand is the direction rotated by θ degrees clockwise when the direction pointing to 12 o'clock is 0 degrees.
Output
The time when the hour hand takes a given angle
h m
Output in one line in the form of.
Since there is no distinction between morning and afternoon in the time, 0 ≤ h ≤ 11 is set.
Examples
Input
0
Output
0 0
Input
45
Output
1 30
Input
100
Output
3 20
|
#include <cassert>
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#define rep(i,j,k) for(int i=(int)j;i<(int)k;i++)
#define ll long long
//#define all(v) ((v).begin(),(v).end())
#define Sort(v) sort(all(v))
#define INF 1000000000
#define END return 0
#define pb push_back
#define se second
#define fi first
#define pb push_back
#define all(v) (v).begin() , (v).end()
#define MP make_pair
#define MOD 1000000007LL;
using namespace std;
int day[12]={31,28,31,30,31,30,31,31,30,31,30,31};
int main(){
int n;
cin>>n;
n*=2;
cout<<n/60<<" "<<n%60<<endl;
return 0;
}
|
You want to make change for $ n $ cents. Assuming that you have infinite supply of coins of 1, 5, 10 and / or 25 cents coins respectively, find the minimum number of coins you need.
Constraints
* $ 1 \ le n \ le 10 ^ 9 $
Input
$ n $
The integer $ n $ is given in a line.
output
Print the minimum number of coins you need in a line.
Examples
Input
100
Output
4
Input
54321
Output
2175
|
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int r = n;
const int c25 = r / 25;
r -= 25 * c25;
const int c10 = r / 10;
r -= 10 * c10;
const int c5 = r / 5;
r -= 5 * c5;
cout << c25 + c10 + c5 + r << endl;
}
|
Write a program which reads two integers a and b, and calculates the following values:
* a ÷ b: d (in integer)
* remainder of a ÷ b: r (in integer)
* a ÷ b: f (in real number)
Constraints
* 1 ≤ a, b ≤ 109
Input
Two integers a and b are given in a line.
Output
Print d, r and f separated by a space in a line. For f, the output should not contain an absolute error greater than 10-5.
Example
Input
3 2
Output
1 1 1.50000
|
a,b=map(int,raw_input().split())
print "%d %d %.8f"%(a/b,a%b,float(a)/b)
|
Virat Kohli and Rohit Sharma are warming up for the World Cup at the Brisbane Cricket Ground, commonly known as "The Gabba". Their coach has asked them to go to the ground at the crack of dawn, and then jog around the stadium in laps. The Cricket Ground has poles spaced equally apart and numbered sequentially from 1 to N. The first M-1 poles lead up to the entrance of the stadium, and the poles numbered M, M+1, ... N are arranged circularly around the stadium, with pole M being next to pole N. Both players start running from pole 1. They always go from pole i to pole i+1, except when i = N, where they go from pole N to pole M.
Due to their different levels of fitness - something that their coach is quite upset about with Virat, that being another story - they have different running speeds P and Q, measured in poles/minute. They have been asked to run for ‘S’ minutes each. Since they can’t keep running for long, the coach has asked them to do short sprints of 1 minute each. First, Virat sprints and covers P poles in 1 minute and stops. Then Rohit sprints and covers Q poles in 1 minute and stops. Virat starts again, and they keep doing this for 2*S minutes (S minutes each). Virat and Rohit are considered to meet if they are at the same pole at the end of some minute. Can you tell how many times they will meet during their jogging routine?
Input:
The first line contains the number of test cases, T. This is followed by T lines, one for each test case. Each test case contains five integers - N, M, S, P and Q.
Output:
For each test case, output the answer on a new line.
Constraints:
1 ≤ T ≤ 100
1 ≤ M < N ≤ 500
1 ≤ S ≤ 100000
1 ≤ P,Q ≤ 500
P ≠ Q
Sample Input:
2
4 1 4 2 3
5 3 10 1 2
Sample Output:
1
3
Explanation:
For the first example, Kohli’s position at the end of his 1st, 2nd, 3rd & 4th minutes of run is {3, 1, 3, 1} respectively. While Rohit’s position at the end of his 1st, 2nd, 3rd & 4th minutes of run is {4, 3, 2, 1} respectively. Therefore, they meet exactly once after 8 minutes (their 4 minutes) at pole 1.
For the second example, they would meet at the end of their 3rd (total 6th), 6th (total 12th) & 9th (total 18th) minute of run.
|
# your code goes here
i_num = int(raw_input())
Nvar, Mvar = 0,0
def step_calc(pos_var, step):
pos_var += step
if pos_var <= Mvar:
return pos_var
pos_var -= Mvar
return Mvar + (pos_var%(Nvar - Mvar + 1))
for i_var in xrange(i_num):
i_line = raw_input().split(' ')
i_line = [int(item) for item in i_line]
Nvar, Mvar = i_line[0], i_line[1]
S_var = i_line[2]
Pvar, Qvar = i_line[3], i_line[4]
coinc_num = 0
Pcurr, Qcurr = 0,0
for t_var in xrange(S_var):
Pcurr = step_calc(Pcurr, Pvar)
Qcurr = step_calc(Qcurr, Qvar)
if Pcurr == Qcurr:
coinc_num += 1
print(coinc_num)
|
Chef is studying Rotational Motion in physics. Here is preparing for Engineering Entrance exam. He's stuck in a problem. Which states that "Two fans, each with a single blade are rotating one above the other, about the same axis of rotation and both blades have the same length. Consider the blade as a rod. Both the fans are rotating indefinitely.
Fans can rotate in either clockwise or anticlockwise direction. There is a dot marked on the blade of both the fans and the dot is marked at the same distance from the center of rotation.
You're be given speeds of the fans.
Clockwise rotation - positive speed.
Anticlockwise rotation - negative speed.
Help Chef to find the number of distinct points the dots will coincide on the circumference of rotation.
Input
First line consists of T Test cases.
Each of the next T lines consists of Two numbers S1 and S2 which describes the speed of rotation of both the fans respectively
Output
Print T lines with each containing the required answer.
Constraints
1 ≤ T ≤ 100
S1 ≠ S2
S1,S2 ≠ 0
-100000 ≤ S1,S2 ≤ 100000.
Example
Input:
3
1 2
6 5
1 -2
Output:
1
1
3
|
problem='https://www.codechef.com/problems/CHFANS'
__author__='Ravindra Singh'
def gcd(a,b):
if a%b==0:
return b
else:
return gcd(b,a%b)
T=int(raw_input())
for i in range(T):
a,b=map(int,raw_input().split())
if a>b:
print abs(abs((a-b))//gcd(a,b))
else:
print abs(abs((a-b))//gcd(b,a))
|
You are given a permutation A of the first N positive integers. You are also given Q queries to perform one-by-one, the i-th is defined by a pair Xi Yi and has the meaning that you swap the Xi-th number in the permutation with the Yi-th one. After performing each query you should output the number of inversions in the obtained permutation, modulo 2.
The inversion is such a pair (i, j) that i < j and Ai > Aj.
Input
The first line of input contains two space separated integers N and Q - the size of the permutation and the number of queries.
The second line contains N space separated integers - the permutation A.
Then there are Q lines. The i-th line contains two space separated integers - Xi and Yi, denoting the i-th query.
Output
Output Q lines. Output the number of inversions in the permutation (modulo 2) after performing the first i queries on the i-th line.
Constraints
1 ≤ N ≤ 100, 1 ≤ Q ≤ 100 : 14 points.
1 ≤ N ≤ 1000, 1 ≤ Q ≤ 1000 : 23 points.
1 ≤ N ≤ 10^5, 1 ≤ Q ≤ 10^5 : 63 points.
1 ≤ Xi, Yi ≤ N
Xi isn't equal to Yi
Example
Input:
5 1
1 2 3 4 5
2 3
Output:
1
|
def SortCount(A):
l = len(A)
if l > 1:
n = l//2
C = A[:n]
D = A[n:]
C, c = SortCount(A[:n])
D, d = SortCount(A[n:])
B, b = MergeCount(C,D)
return B, b+c+d
else:
return A, 0
def MergeCount(A,B):
count = 0
M = []
i=0
j=0
while i<len(A) and j<len(B):
if A[i]<B[j]:
M.append(A[i])
i+=1
else:
count += len(A)-i
M.append(B[j])
j+=1
while i<len(A):
M.append(A[i])
i+=1
while j<len(B):
M.append(B[j])
j+=1
return M, count
n,q=map(int,raw_input().split())
a=map(int,raw_input().split())
ccc=SortCount(a)[1]%2
for i in range(q):
x,y = map(int,raw_input().split())
a[x-1],a[y-1] = a[y-1],a[x-1]
if ccc==1:
print 0
ccc=0
elif ccc==0:
print 1
ccc=1
|
Liliputs are holding a drawing competition for K kids, but with K human-sized pencils stolen from humans. In order to make life easier for the kids, the organizers want to give a pencil to each kid in a way such that the sum of the absolute differences of the height of a kid and the length of the pencil assigned to him/her is minimized. What is the minimum sum of absolute differences that can be achieved?
Input
The first line contains the number of test cases N (0 < N ≤ 3).
For each test case, the first line contains the number of kids and pencils K (0 < K ≤ 100). The second line contains K positive integers, each containing the height in millimeter of a kid. The third line contains K positive integers, each containing the length in millimeter of a pencil.
Output
For each test case, print the case number, followed by a colon, followed by a single space, followed by a single integer indicating the minimum sum of absolute differences achieved (in millimeter).
Sample Input
2
5
51 60 51 72 70
65 60 88 72 88
4
123 234 188 175
219 334 122 233
Sample Output
Case 1: 69
Case 2: 190
|
for num in range(input()):
n =input()
arr1 = map(int,raw_input().split())
arr1.sort()
arr2 = map(int,raw_input().split())
arr2.sort()
m=0
for i in range(n):
m+=abs(arr1[i]-arr2[i])
# m=min(m,abs(arr1[i]-arr2[i]))
print "Case "+str(num+1)+": "+str(m)
|
Leha is playing a very interesting game. The game will be played on a rectangular grid consisting of N rows and M columns. Initially all the cells of the grid are uncolored.
Leha's initial score is zero. At each turn, he chooses some cell that is yet not colored, and colors that cell. The score obtained in this step will be number of neighboring colored cells of the cell that Leha colored in this step. Two cells are neighbors of each other if they share a side between them. The game will end when all the cells are colored. Finally, total score obtained at the end of the game will sum of score obtained in each turn.
Leha wants to know what maximum score he can get? Can you please help him in finding this out?
Input
The first line contains a single integer T denoting the number of test cases. T test cases follow.
Each of the following T lines contains two space-separated integers N, M denoting the dimensions of the grid.
Output
For each test case, output a single line containing an integer corresponding to the maximal possible score Leha can obtain.
Constraints
1 ≤ T ≤ 100
1 ≤ N, M ≤ 1 000
Example
Input:
1
2 2
Output:
4
Explanation
Leha can obtain total score 4 in the following way.
In the first step, he colors down left cell, all the neighboring cells of this cell are uncolored. So, it adds 0 to total score.
In second step, he can color upper right cell, it also adds total 0 to the score.
In third step, he can color top left cell. There are two neighboring cell of this cell, both of which are colored. So, this add 2 to the score.
In the last step, he can choose the remaining down right cell. There are two neighboring cell of this cell, both of which are colored. So, this also add 2 to the score.
Leha can't obtain a score more than 4. Hence 4 is the answer.
|
T=int(raw_input())
while T:
n,m=map(int,raw_input().split())
ans = 2*n*m-n-m
print(ans)
T-=1
|
A number is called palindromic if its decimal representation is a palindrome. You are given a range, described by a pair of integers L and R. Find the sum of all palindromic numbers lying in the range [L, R], inclusive of both the extrema.
Input
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test case contains a pair of space separated integers L and R denoting the range for which you are required to find the sum of the palindromic numbers.
Output
For each test case, output a single line containing the sum of all the palindromic numbers in the given range.
Constraints
1 ≤ T ≤ 100
Example
Input:
2
1 10
123 150
Output:
45
272
Explanation
Example case 1. The palindromic numbers between 1 and 10 are all numbers except the number 10. Their sum is 45.
Example case 2. The palindromic numbers between 123 and 150 are 131 and 141 and their sum is 272.
|
for tests in xrange(int(raw_input())):
a, z = map(int, raw_input().split())
str_range = map(str, xrange(a, z + 1))
print sum([int(str_num) for str_num in str_range if str_num == str_num[::-1]])
|
You are given a permutation p_1, p_2, ..., p_n. A permutation of length n is a sequence such that each integer between 1 and n occurs exactly once in the sequence.
Find the number of pairs of indices (l, r) (1 ≤ l ≤ r ≤ n) such that the value of the median of p_l, p_{l+1}, ..., p_r is exactly the given number m.
The median of a sequence is the value of the element which is in the middle of the sequence after sorting it in non-decreasing order. If the length of the sequence is even, the left of two middle elements is used.
For example, if a=[4, 2, 7, 5] then its median is 4 since after sorting the sequence, it will look like [2, 4, 5, 7] and the left of two middle elements is equal to 4. The median of [7, 1, 2, 9, 6] equals 6 since after sorting, the value 6 will be in the middle of the sequence.
Write a program to find the number of pairs of indices (l, r) (1 ≤ l ≤ r ≤ n) such that the value of the median of p_l, p_{l+1}, ..., p_r is exactly the given number m.
Input
The first line contains integers n and m (1 ≤ n ≤ 2⋅10^5, 1 ≤ m ≤ n) — the length of the given sequence and the required value of the median.
The second line contains a permutation p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). Each integer between 1 and n occurs in p exactly once.
Output
Print the required number.
Examples
Input
5 4
2 4 5 3 1
Output
4
Input
5 5
1 2 3 4 5
Output
1
Input
15 8
1 15 2 14 3 13 4 8 12 5 11 6 10 7 9
Output
48
Note
In the first example, the suitable pairs of indices are: (1, 3), (2, 2), (2, 3) and (2, 4).
|
import java.io.*;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.net.ssl.SSLContext;
public class Main
{
static long mod=(long)(1e+9) + 7;
static int[] sieve;
static ArrayList<Integer> primes;
static HashMap<Integer,Integer> hm;
public static long greater(int m,int a[])
{
int sum=0;
long till=0;
long fans=0;
hm=new HashMap<Integer,Integer>();
hm.put(0, 1);
for(int i=0;i<a.length;i++)
{
if(a[i]<m)
{
sum--;
if(hm.containsKey(sum))
till-=hm.get(sum);
}
else
{
if(hm.containsKey(sum))
till+=hm.get(sum);
sum++;
}
if(!hm.containsKey(sum)) hm.put(sum, 1);
else hm.put(sum, hm.get(sum)+1);
fans+=till;
}
return fans;
}
public static void main(String[] args) throws java.lang.Exception
{
fast s = new fast();
PrintWriter out=new PrintWriter(System.out);
Scanner sc=new Scanner(System.in);
StringBuilder fans = new StringBuilder();
int n=s.nextInt();
int m=s.nextInt();
int a[]=new int[n];
for(int i=0;i<n;i++) a[i]=s.nextInt();
System.out.println(greater(m,a)-greater(m+1,a));
}
static class fast {
private InputStream i;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
public static boolean next_permutation(int a[])
{
int i=0,j=0;int index=-1;
int n=a.length;
for(i=0;i<n-1;i++)
if(a[i]<a[i+1]) index=i;
if(index==-1) return false;
i=index;
for(j=i+1;j<n && a[i]<a[j];j++);
int temp=a[i];
a[i]=a[j-1];
a[j-1]=temp;
for(int p=i+1,q=n-1;p<q;p++,q--)
{
temp=a[p];
a[p]=a[q];
a[q]=temp;
}
return true;
}
public static void division(char ch[],int divisor)
{
int div=Character.getNumericValue(ch[0]); int mul=10;int remainder=0;
StringBuilder quotient=new StringBuilder("");
for(int i=1;i<ch.length;i++)
{
div=div*mul+Character.getNumericValue(ch[i]);
if(div<divisor) {quotient.append("0");continue;}
quotient.append(div/divisor);
div=div%divisor;mul=10;
}
remainder=div;
while(quotient.charAt(0)=='0')quotient.deleteCharAt(0);
System.out.println(quotient+" "+remainder);
}
public static void sieve(int size)
{
sieve=new int[size+1];
primes=new ArrayList<Integer>();
sieve[1]=1;
for(int i=2;i<=Math.sqrt(size);i++)
{
if(sieve[i]==0)
{
for(int j=i*i;j<size;j+=i) sieve[j]=1;
}
}
for(int i=2;i<=size;i++)
{
if(sieve[i]==0) primes.add(i);
}
}
public static long pow(long n, long b, long MOD)
{
long x=1;long y=n;
while(b > 0)
{
if(b%2 == 1)
{
x=x*y;
if(x>MOD) x=x%(MOD);
}
y = y*y;
if(y>MOD) y=y%(MOD);
b >>= 1;
}
return x;
}
public static int upper(Integer[] a,int start,int end,int key)
{
int mid=(start+end)>>1;
if(start==end && a[mid]<key) {return -1;}
if(start>end) return -1;
if(a[mid]>=key && (((mid-1)>=0 && a[mid-1]<key) || (mid-1)==0)) return mid;
else if(a[mid]== key && (mid-1)>=0 && a[mid-1]==key) return lower(a,start,mid-1,key);
else if(key>a[mid]) return lower(a,mid+1,end,key);
else return lower(a,start,mid-1,key);
}
public static int lower(Integer a[],int start,int end,int key)
{
int mid=(start+end)>>1;
if(start==end && a[mid]>key) {return -1;}
if(start>end) return -1;
if(a[mid]<=key && (((mid+1)<a.length && a[mid+1]>key) || (mid+1)==a.length)) return mid;
else if(a[mid]== key && (mid+1)<a.length && a[mid+1]==key) return upper(a,mid+1,end,key);
else if(key>=a[mid]) return upper(a,mid+1,end,key);
else return upper(a,start,mid-1,key);
}
public int gcd(int a,int b)
{
if(a==0) return b;
return gcd(b%a,a);
}
public fast() {
this(System.in);
}
public fast(InputStream is) {
i = is;
}
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = i.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public String nextLine() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isEndOfLine(c));
return res.toString();
}
public String nextString() {
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 long nextLong() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public int nextInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
}
}
|
You are given n segments on a number line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
The intersection of a sequence of segments is such a maximal set of points (not necesserily having integer coordinates) that each point lies within every segment from the sequence. If the resulting set isn't empty, then it always forms some continuous segment. The length of the intersection is the length of the resulting segment or 0 in case the intersection is an empty set.
For example, the intersection of segments [1;5] and [3;10] is [3;5] (length 2), the intersection of segments [1;5] and [5;7] is [5;5] (length 0) and the intersection of segments [1;5] and [6;6] is an empty set (length 0).
Your task is to remove exactly one segment from the given sequence in such a way that the intersection of the remaining (n - 1) segments has the maximal possible length.
Input
The first line contains a single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of segments in the sequence.
Each of the next n lines contains two integers l_i and r_i (0 ≤ l_i ≤ r_i ≤ 10^9) — the description of the i-th segment.
Output
Print a single integer — the maximal possible length of the intersection of (n - 1) remaining segments after you remove exactly one segment from the sequence.
Examples
Input
4
1 3
2 6
0 4
3 3
Output
1
Input
5
2 6
1 3
0 4
1 20
0 4
Output
2
Input
3
4 5
1 2
9 20
Output
0
Input
2
3 10
1 5
Output
7
Note
In the first example you should remove the segment [3;3], the intersection will become [2;3] (length 1). Removing any other segment will result in the intersection [3;3] (length 0).
In the second example you should remove the segment [1;3] or segment [2;6], the intersection will become [2;4] (length 2) or [1;3] (length 2), respectively. Removing any other segment will result in the intersection [2;3] (length 1).
In the third example the intersection will become an empty set no matter the segment you remove.
In the fourth example you will get the intersection [3;10] (length 7) if you remove the segment [1;5] or the intersection [1;5] (length 4) if you remove the segment [3;10].
|
#include <bits/stdc++.h>
using namespace std;
struct re {
long long x, y;
};
re r[300005];
re f[300005], b[300005];
re ti(re a, re b) {
re c;
c.x = max(a.x, b.x);
c.y = min(a.y, b.y);
return c;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
int i;
for (i = 1; i <= n; i++) cin >> r[i].x >> r[i].y;
re b1 = r[1];
for (i = 1; i <= n; i++) {
b1 = ti(b1, r[i]);
f[i] = b1;
}
b1 = r[n];
for (i = n; i >= 1; i--) {
b1 = ti(b1, r[i]);
b[i] = b1;
}
long long s = 0;
if (f[n - 1].x <= f[n - 1].y) s = max(s, f[n - 1].y - f[n - 1].x);
if (b[2].x <= b[2].y) s = max(s, b[2].y - b[2].x);
for (i = 2; i <= n - 1; i++) {
b1 = ti(f[i - 1], b[i + 1]);
if (b1.x <= b1.y) s = max(s, b1.y - b1.x);
}
cout << s;
return 0;
}
|
The average miner Vaganych took refresher courses. As soon as a miner completes the courses, he should take exams. The hardest one is a computer test called "Testing Pants for Sadness".
The test consists of n questions; the questions are to be answered strictly in the order in which they are given, from question 1 to question n. Question i contains ai answer variants, exactly one of them is correct.
A click is regarded as selecting any answer in any question. The goal is to select the correct answer for each of the n questions. If Vaganych selects a wrong answer for some question, then all selected answers become unselected and the test starts from the very beginning, from question 1 again. But Vaganych remembers everything. The order of answers for each question and the order of questions remain unchanged, as well as the question and answers themselves.
Vaganych is very smart and his memory is superb, yet he is unbelievably unlucky and knows nothing whatsoever about the test's theme. How many clicks will he have to perform in the worst case?
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). It is the number of questions in the test. The second line contains space-separated n positive integers ai (1 ≤ ai ≤ 109), the number of answer variants to question i.
Output
Print a single number — the minimal number of clicks needed to pass the test it the worst-case scenario.
Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.
Examples
Input
2
1 1
Output
2
Input
2
2 2
Output
5
Input
1
10
Output
10
Note
Note to the second sample. In the worst-case scenario you will need five clicks:
* the first click selects the first variant to the first question, this answer turns out to be wrong.
* the second click selects the second variant to the first question, it proves correct and we move on to the second question;
* the third click selects the first variant to the second question, it is wrong and we go back to question 1;
* the fourth click selects the second variant to the first question, it proves as correct as it was and we move on to the second question;
* the fifth click selects the second variant to the second question, it proves correct, the test is finished.
|
import java.util.Scanner;
public class P103A {
public static void main(String[] args) {
Scanner inScanner = new Scanner(System.in);
int n = inScanner.nextInt();
long sum = 0;
for (long i = 0; i < n; i++)
sum += (i + 1) * inScanner.nextLong() - i;
System.out.println(sum);
}
}
|
You are given an array a of length n that consists of zeros and ones.
You can perform the following operation multiple times. The operation consists of two steps:
1. Choose three integers 1 ≤ x < y < z ≤ n, that form an arithmetic progression (y - x = z - y).
2. Flip the values a_x, a_y, a_z (i.e. change 1 to 0, change 0 to 1).
Determine if it is possible to make all elements of the array equal to zero. If yes, print the operations that lead the the all-zero state. Your solution should not contain more than (⌊ n/3 ⌋ + 12) operations. Here ⌊ q ⌋ denotes the number q rounded down. We can show that it is possible to make all elements equal to zero in no more than this number of operations whenever it is possible to do so at all.
Input
The first line contains a single integer n (3 ≤ n ≤ 10^5) — the length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — the elements of the array.
Output
Print "YES" (without quotes) if the answer exists, otherwise print "NO" (without quotes). You can print each letter in any case (upper or lower).
If there is an answer, in the second line print an integer m (0 ≤ m ≤ (⌊ n/3 ⌋ + 12)) — the number of operations in your answer.
After that in (i + 2)-th line print the i-th operations — the integers x_i, y_i, z_i. You can print them in arbitrary order.
Examples
Input
5
1 1 0 1 1
Output
YES
2
1 3 5
2 3 4
Input
3
0 1 0
Output
NO
Note
In the first sample the shown output corresponds to the following solution:
* 1 1 0 1 1 (initial state);
* 0 1 1 1 0 (the flipped positions are the first, the third and the fifth elements);
* 0 0 0 0 0 (the flipped positions are the second, the third and the fourth elements).
Other answers are also possible. In this test the number of operations should not exceed ⌊ 5/3 ⌋ + 12 = 1 + 12 = 13.
In the second sample the only available operation is to flip all the elements. This way it is only possible to obtain the arrays 0 1 0 and 1 0 1, but it is impossible to make all elements equal to zero.
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int n;
int a[maxn];
struct Ans {
int x, y, z;
} ans[maxn];
int nnm;
int que[maxn];
void fan(int x, int y, int z) {
if (x > z) swap(x, z);
nnm++;
ans[nnm].x = x;
ans[nnm].y = y;
ans[nnm].z = z;
a[x] ^= 1;
a[y] ^= 1;
a[z] ^= 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int l = 1, r = n;
int op = 0;
while (r - l + 1 > 6) {
if (op == 0) {
while (l <= r && a[l] == 0) l++;
if (r - l + 1 <= 6) break;
if (a[l + 1] == 1 && a[l + 2] == 1)
fan(l, l + 1, l + 2);
else if (a[l + 1] == 1 && a[l + 2] == 0)
op = 1;
else if (a[l + 1] == 0 && a[l + 2] == 1)
fan(l, l + 2, l + 4);
else if (a[l + 1] == 0 && a[l + 2] == 0)
fan(l, l + 3, l + 6);
continue;
} else {
while (l <= r && a[r] == 0) r--;
if (r - l + 1 <= 6) break;
if (a[r - 1] == 1 && a[r - 2] == 1)
fan(r - 2, r - 1, r);
else if (a[r - 1] == 1 && a[r - 2] == 0) {
if ((l + r) & 1) {
fan(l, (l + r - 1) / 2, r - 1);
fan(l + 1, (l + r + 1) / 2, r);
} else {
fan(l, (l + r) / 2, r);
fan(l + 1, (l + r) / 2, r - 1);
}
op = 0;
} else if (a[r - 1] == 0 && a[r - 2] == 1)
fan(r - 4, r - 2, r);
else if (a[r - 1] == 0 && a[r - 2] == 0)
fan(r - 6, r - 3, r);
}
}
if (l <= r) {
int cnt = 0;
for (int i = l; i <= r; i++) que[++cnt] = a[i];
for (int i = cnt + 1; i <= 6; i++) que[i] = 0;
cnt = 6;
for (int i = 6; i >= 4; i--)
if (que[i] == 1) {
fan(l + i - 3, l + i - 2, l + i - 1);
que[i] ^= 1;
que[i - 1] ^= 1;
que[i - 2] ^= 1;
}
int sum = 0;
for (int i = 1; i <= 3; i++) sum += que[i];
if (sum >= 2) {
fan(l, l + 1, l + 2);
que[1] ^= 1;
que[2] ^= 1;
que[3] ^= 1;
}
if (sum != 3 && sum != 0) {
int pos;
for (int i = 1; i <= 3; i++)
if (que[i] == 1) pos = i;
pos = pos + l - 1;
int tl = pos - 1;
int tr = n - pos;
if (tl == 2 && tr == 5) {
fan(pos - 2, pos + 1, pos + 4);
fan(pos - 1, pos + 2, pos + 5);
fan(pos - 2, pos - 1, pos);
fan(pos + 1, pos + 2, pos + 3);
fan(pos + 3, pos + 4, pos + 5);
} else if (tl == 5 && tr == 2) {
fan(pos + 2, pos - 1, pos - 4);
fan(pos + 1, pos - 2, pos - 5);
fan(pos + 2, pos + 1, pos);
fan(pos - 1, pos - 2, pos - 3);
fan(pos - 3, pos - 4, pos - 5);
} else {
if (tr >= 6) {
fan(pos, pos + 1, pos + 2);
fan(pos + 1, pos + 2, pos + 3);
tr -= 3;
tl += 3;
pos += 3;
} else if (tl >= 6) {
fan(pos - 2, pos - 1, pos);
fan(pos - 3, pos - 2, pos - 1);
tl -= 3, tr += 3;
pos -= 3;
}
if (tl >= 3 && tr >= 3) {
fan(pos - 1, pos, pos + 1);
fan(pos - 3, pos - 2, pos - 1);
fan(pos + 3, pos + 2, pos + 1);
fan(pos - 3, pos, pos + 3);
fan(pos - 2, pos, pos + 2);
}
}
}
}
for (int i = 1; i <= n; i++)
if (a[i] == 1) {
printf("NO\n");
return 0;
}
printf("YES\n");
printf("%d\n", nnm);
for (int i = 1; i <= nnm; i++)
printf("%d %d %d\n", ans[i].x, ans[i].y, ans[i].z);
return 0;
}
|
You are given two permutations a and b, both consisting of n elements. Permutation of n elements is such a integer sequence that each value from 1 to n appears exactly once in it.
You are asked to perform two types of queries with them:
* 1~l_a~r_a~l_b~r_b — calculate the number of values which appear in both segment [l_a; r_a] of positions in permutation a and segment [l_b; r_b] of positions in permutation b;
* 2~x~y — swap values on positions x and y in permutation b.
Print the answer for each query of the first type.
It is guaranteed that there will be at least one query of the first type in the input.
Input
The first line contains two integers n and m (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5) — the number of elements in both permutations and the number of queries.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — permutation a. It is guaranteed that each value from 1 to n appears in a exactly once.
The third line contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ n) — permutation b. It is guaranteed that each value from 1 to n appears in b exactly once.
Each of the next m lines contains the description of a certain query. These are either:
* 1~l_a~r_a~l_b~r_b (1 ≤ l_a ≤ r_a ≤ n, 1 ≤ l_b ≤ r_b ≤ n);
* 2~x~y (1 ≤ x, y ≤ n, x ≠ y).
Output
Print the answers for the queries of the first type, each answer in the new line — the number of values which appear in both segment [l_a; r_a] of positions in permutation a and segment [l_b; r_b] of positions in permutation b.
Example
Input
6 7
5 1 4 2 3 6
2 5 3 1 4 6
1 1 2 4 5
2 2 4
1 1 2 4 5
1 2 3 3 5
1 1 6 1 2
2 4 1
1 4 4 1 3
Output
1
1
1
2
0
Note
Consider the first query of the first example. Values on positions [1; 2] of a are [5, 1] and values on positions [4; 5] of b are [1, 4]. Only value 1 appears in both segments.
After the first swap (the second query) permutation b becomes [2, 1, 3, 5, 4, 6].
After the second swap (the sixth query) permutation b becomes [5, 1, 3, 2, 4, 6].
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse4.2,sse4.1,ssse3,sse3,sse2,sse")
#pragma GCC target("avx")
#pragma GCC target("avx2")
using namespace std;
const int maxn = (int)2e5;
alignas(32) int a[maxn];
alignas(32) int b[maxn];
alignas(32) int posA[maxn];
alignas(32) int posB[maxn];
alignas(32) int special[maxn];
alignas(32) int result[128];
bool check(int lb, int rb, int i) {
return lb <= special[i] && special[i] <= rb;
}
int getCount(int la, int ra, int lb, int rb) {
int count = 0;
if (la / 128 == ra / 128) {
for (int i = la; i <= ra; i++) count += check(lb, rb, i);
return count;
} else {
while (la % 128 != 0) {
count += check(lb, rb, la);
la++;
}
while (ra % 128 != 128 - 1) {
count += check(lb, rb, ra);
ra--;
}
ra++;
for (int i = 0; i < 128; i++) result[i] = 0;
for (int i = la; i + 128 <= ra; i += 128) {
for (int j = 0; j < 128; j++) {
result[j] += check(lb, rb, i + j);
}
}
for (int i = 0; i < 128; i++) count += result[i];
}
return count;
}
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i], a[i]--;
for (int i = 0; i < n; i++) cin >> b[i], b[i]--;
for (int i = 0; i < n; i++) posA[a[i]] = i;
for (int i = 0; i < n; i++) posB[b[i]] = i;
for (int i = 0; i < n; i++) special[i] = posB[a[i]];
for (int i = 0; i < m; i++) {
int t;
cin >> t;
if (t == 1) {
int la, ra, lb, rb;
cin >> la >> ra >> lb >> rb;
la--, ra--, lb--, rb--;
int count = getCount(la, ra, lb, rb);
cout << count << '\n';
} else {
int x, y;
cin >> x >> y;
x--, y--;
swap(b[x], b[y]);
posB[b[x]] = x;
posB[b[y]] = y;
special[posA[b[x]]] = x;
special[posA[b[y]]] = y;
}
}
}
|
Fedya and Sasha are friends, that's why Sasha knows everything about Fedya.
Fedya keeps his patience in an infinitely large bowl. But, unlike the bowl, Fedya's patience isn't infinite, that is why let v be the number of liters of Fedya's patience, and, as soon as v becomes equal to 0, the bowl will burst immediately. There is one tap in the bowl which pumps s liters of patience per second. Notice that s can be negative, in that case, the tap pumps out the patience. Sasha can do different things, so he is able to change the tap's speed. All actions that Sasha does can be represented as q queries. There are three types of queries:
1. "1 t s" — add a new event, means that starting from the t-th second the tap's speed will be equal to s.
2. "2 t" — delete the event which happens at the t-th second. It is guaranteed that such event exists.
3. "3 l r v" — Sasha wonders: if you take all the events for which l ≤ t ≤ r and simulate changes of Fedya's patience from the very beginning of the l-th second till the very beginning of the r-th second inclusive (the initial volume of patience, at the beginning of the l-th second, equals to v liters) then when will be the moment when the bowl will burst. If that does not happen, then the answer will be -1.
Since Sasha does not want to check what will happen when Fedya's patience ends, and he has already come up with the queries, he is asking you to help him and find the answer for each query of the 3-rd type.
It is guaranteed that at any moment of time, there won't be two events which happen at the same second.
Input
The first line contans one integer q (1 ≤ q ≤ 10^5) — the number of queries.
Each of the next q lines have one of the following formats:
* 1 t s (1 ≤ t ≤ 10^9, -10^9 ≤ s ≤ 10^9), means that a new event is added, which means that starting from the t-th second the tap's speed will be equal to s.
* 2 t (1 ≤ t ≤ 10^9), means that the event which happens at the t-th second must be deleted. Guaranteed that such exists.
* 3 l r v (1 ≤ l ≤ r ≤ 10^9, 0 ≤ v ≤ 10^9), means that you should simulate the process from the very beginning of the l-th second till the very beginning of the r-th second inclusive, and to say when will the bowl burst.
It is guaranteed that t, s, l, r, v in all the queries are integers.
Also, it is guaranteed that there is at least one query of the 3-rd type, and there won't be a query of the 1-st type with such t, that there already exists an event which happens at that second t.
Output
For each query of the 3-rd type, print in a new line the moment when the bowl will burst or print -1 if it won't happen.
Your answer will be considered correct if it's absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \frac{|a - b|}{max{(1, |b|)}} ≤ 10^{-6}.
Examples
Input
6
1 2 1
1 4 -3
3 1 6 1
3 1 6 3
3 1 6 4
3 1 6 5
Output
5
5.666667
6
-1
Input
10
1 2 2
1 4 4
1 7 -10
3 2 4 1
3 5 6 0
3 1 15 1
2 4
3 1 15 1
1 8 1
3 1 15 1
Output
-1
5
8.7
8.1
-1
Input
5
1 1000 9999999
1 2000 -9999
3 1000 2000 0
2 1000
3 1000 2002 1
Output
1000
2000.0001
Note
In the first example all the queries of the 3-rd type cover all the events, it's simulation is following:
<image>
|
#include <bits/stdc++.h>
using namespace std;
mt19937 gen(200);
struct node {
pair<int, int> f, s;
node *le, *ri;
long long mn, res;
int tl, tr;
node() { mn = 228; }
node(int l, int r) {
tl = l;
tr = r;
mn = 228;
if (l == r) return;
le = new node(l, (l + r) / 2);
ri = new node((l + r) / 2 + 1, r);
}
node(node* a, node* b) {
le = a;
ri = b;
tl = le->tl;
tr = ri->tr;
if (le->mn == 228) {
res = ri->res;
mn = ri->mn;
f = ri->f;
s = ri->s;
return;
}
if (ri->mn == 228) {
res = le->res;
mn = le->mn;
f = le->f;
s = le->s;
return;
}
f = le->f;
s = ri->s;
long long del = 1ll * le->s.second * (ri->f.first - le->s.first);
res = le->res + del + ri->res;
mn = min(le->mn, le->res + del);
mn = min(mn, ri->mn + le->res + del);
}
void combine() {
node tmp(le, ri);
*this = tmp;
}
void update(int id, int time, int speed) {
if (tl == tr) {
mn = res = 0;
f.first = s.first = time;
f.second = s.second = speed;
return;
}
if (id <= (tl + tr) / 2)
le->update(id, time, speed);
else
ri->update(id, time, speed);
combine();
}
void del(int id) {
if (tl == tr) {
mn = 228;
return;
}
if (id <= (tl + tr) / 2)
le->del(id);
else
ri->del(id);
combine();
}
node* get_seg(int l, int r) {
if (tr < l || r < tl) return new node();
if (l <= tl && tr <= r) {
return this;
;
}
return new node(le->get_seg(l, r), ri->get_seg(l, r));
}
long double simulate(int r, long long v) {
if (mn == 228) return -1;
if (v + mn > 0 && v + res + 1ll * s.second * (r - s.first) > 0) return -1;
if (f == s) return s.first - (long double)v / s.second;
if (le->mn == 228) return ri->simulate(r, v);
long double to = le->simulate(le->s.first, v);
if (to != -1) return to;
v += le->res;
long long del =
1ll * le->s.second * ((ri->mn == 228 ? r : ri->f.first) - le->s.first);
if (v + del <= 0) return le->s.first - (long double)v / le->s.second;
v += del;
return ri->simulate(r, v);
}
long double query(int l, int r, int rr, long long v) {
node* t = get_seg(l, r);
return t->simulate(rr, v);
}
};
struct query {
int time, speed, start;
int l, r, type;
query() {}
};
vector<int> pos;
vector<query> q;
int main() {
ios_base::sync_with_stdio(false);
cout.precision(7);
int qq;
cin >> qq;
q.resize(qq);
for (int i = 0; i < qq; ++i) {
cin >> q[i].type;
if (q[i].type == 1) {
cin >> q[i].time >> q[i].speed;
pos.push_back(q[i].time);
}
if (q[i].type == 2) {
cin >> q[i].time;
}
if (q[i].type == 3) {
cin >> q[i].l >> q[i].r >> q[i].start;
}
}
sort(pos.begin(), pos.end());
pos.erase(unique(pos.begin(), pos.end()), pos.end());
if (pos.size() == 0) pos.push_back(0);
node* t = new node(0, pos.size() - 1);
for (int i = 0; i < qq; ++i) {
if (q[i].type == 1) {
int id = lower_bound(pos.begin(), pos.end(), q[i].time) - pos.begin();
t->update(id, q[i].time, q[i].speed);
}
if (q[i].type == 2) {
int id = lower_bound(pos.begin(), pos.end(), q[i].time) - pos.begin();
t->del(id);
}
if (q[i].type == 3) {
int l = lower_bound(pos.begin(), pos.end(), q[i].l) - pos.begin();
int r = --upper_bound(pos.begin(), pos.end(), q[i].r) - pos.begin();
if (q[i].start == 0)
cout << fixed << q[i].l << '\n';
else
cout << fixed << t->query(l, r, q[i].r, q[i].start) << '\n';
}
}
return 0;
}
|
Treeland consists of n cities and n-1 roads. Each road is bidirectional and connects two distinct cities. From any city you can get to any other city by roads. Yes, you are right — the country's topology is an undirected tree.
There are some private road companies in Treeland. The government decided to sell roads to the companies. Each road will belong to one company and a company can own multiple roads.
The government is afraid to look unfair. They think that people in a city can consider them unfair if there is one company which owns two or more roads entering the city. The government wants to make such privatization that the number of such cities doesn't exceed k and the number of companies taking part in the privatization is minimal.
Choose the number of companies r such that it is possible to assign each road to one company in such a way that the number of cities that have two or more roads of one company is at most k. In other words, if for a city all the roads belong to the different companies then the city is good. Your task is to find the minimal r that there is such assignment to companies from 1 to r that the number of cities which are not good doesn't exceed k.
<image> The picture illustrates the first example (n=6, k=2). The answer contains r=2 companies. Numbers on the edges denote edge indices. Edge colors mean companies: red corresponds to the first company, blue corresponds to the second company. The gray vertex (number 3) is not good. The number of such vertices (just one) doesn't exceed k=2. It is impossible to have at most k=2 not good cities in case of one company.
Input
The first line contains two integers n and k (2 ≤ n ≤ 200000, 0 ≤ k ≤ n - 1) — the number of cities and the maximal number of cities which can have two or more roads belonging to one company.
The following n-1 lines contain roads, one road per line. Each line contains a pair of integers x_i, y_i (1 ≤ x_i, y_i ≤ n), where x_i, y_i are cities connected with the i-th road.
Output
In the first line print the required r (1 ≤ r ≤ n - 1). In the second line print n-1 numbers c_1, c_2, ..., c_{n-1} (1 ≤ c_i ≤ r), where c_i is the company to own the i-th road. If there are multiple answers, print any of them.
Examples
Input
6 2
1 4
4 3
3 5
3 6
5 2
Output
2
1 2 1 1 2
Input
4 2
3 1
1 4
1 2
Output
1
1 1 1
Input
10 2
10 3
1 2
1 3
1 4
2 5
2 6
2 7
3 8
3 9
Output
3
1 1 2 3 2 3 1 3 1
|
import java.util.*;
import java.lang.*;
import java.io.*;
import java.awt.*;
// U KNOW THAT IF THIS DAY WILL BE URS THEN NO ONE CAN DEFEAT U HERE................
//JUst keep faith in ur strengths ..................................................
// ASCII = 48 + i ;// 2^28 = 268,435,456 > 2* 10^8 // log 10 base 2 = 3.3219
// odd:: (x^2+1)/2 , (x^2-1)/2 ; x>=3// even:: (x^2/4)+1 ,(x^2/4)-1 x >=4
// FOR ANY ODD NO N : N,N-1,N-2
//ALL ARE PAIRWISE COPRIME
//THEIR COMBINED LCM IS PRODUCT OF ALL THESE NOS
// two consecutive odds are always coprime to each other
// two consecutive even have always gcd = 2 ;
// Rectangle r = new Rectangle(int x , int y,int widht,int height)
//Creates a rect. with bottom left cordinates as (x, y) and top right as ((x+width),(y+height))
//BY DEFAULT Priority Queue is MIN in nature in java
//to use as max , just push with negative sign and change sign after removal
// We can make a sieve of max size 1e7 .(no time or space issue)
// In 1e7 starting nos we have about 66*1e4 prime nos
public class Main
{
// static int[] arr = new int[100002] ;
// static int[] dp = new int[100002] ;
static PrintWriter out;
static class FastReader{
BufferedReader br;
StringTokenizer st;
public FastReader(){
br=new BufferedReader(new InputStreamReader(System.in));
out=new PrintWriter(System.out);
}
String next(){
while(st==null || !st.hasMoreElements()){
try{
st= new StringTokenizer(br.readLine());
}
catch (IOException e){
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt(){
return Integer.parseInt(next());
}
long nextLong(){
return Long.parseLong(next());
}
double nextDouble(){
return Double.parseDouble(next());
}
String nextLine(){
String str = "";
try{
str=br.readLine();
}
catch(IOException e){
e.printStackTrace();
}
return str;
}
}
////////////////////////////////////////////////////////////////////////////////////
public static int countDigit(long n)
{
return (int)Math.floor(Math.log10(n) + 1);
}
/////////////////////////////////////////////////////////////////////////////////////////
public static int sumOfDigits(long n)
{
if( n< 0)return -1 ;
int sum = 0;
while( n > 0)
{
sum = sum + (int)( n %10) ;
n /= 10 ;
}
return sum ;
}
//////////////////////////////////////////////////////////////////////////////////////////////////
public static long arraySum(int[] arr , int start , int end)
{
long ans = 0 ;
for(int i = start ; i <= end ; i++)ans += arr[i] ;
return ans ;
}
/////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
public static void swapArray(int[] arr , int start , int end)
{
while(start < end)
{
int temp = arr[start] ;
arr[start] = arr[end];
arr[end] = temp;
start++ ;end-- ;
}
}
//////////////////////////////////////////////////////////////////////////////////
static long factorial(long a)
{
if(a== 0L || a==1L)return 1L ;
return a*factorial(a-1L) ;
}
///////////////////////////////////////////////////////////////////////////////
public static int[][] rotate(int[][] input){
int n =input.length;
int m = input[0].length ;
int[][] output = new int [m][n];
for (int i=0; i<n; i++)
for (int j=0;j<m; j++)
output [j][n-1-i] = input[i][j];
return output;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////// ////////////////////////////////////////////////
public static boolean isPowerOfTwo(long n)
{
if(n==0)
return false;
if(((n ) & (n-1)) == 0 ) return true ;
else return false ;
}
/////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
public static String reverse(String input)
{
StringBuilder str = new StringBuilder("") ;
for(int i =input.length()-1 ; i >= 0 ; i-- )
{
str.append(input.charAt(i));
}
return str.toString() ;
}
///////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
public static boolean isPossibleTriangle(int a ,int b , int c)
{
if( a + b > c && c+b > a && a +c > b)return true ;
else return false ;
}
////////////////////////////////////////////////////////////////////////////////////////////
static long xnor(long num1, long num2) {
if (num1 < num2) {
long temp = num1;
num1 = num2;
num2 = temp;
}
num1 = togglebit(num1);
return num1 ^ num2;
}
static long togglebit(long n) {
if (n == 0)
return 1;
long i = n;
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
return i ^ n;
}
///////////////////////////////////////////////////////////////////////////////////////////////
public static int xorOfFirstN(int n)
{
if( n % 4 ==0)return n ;
else if( n % 4 == 1)return 1 ;
else if( n % 4 == 2)return n+1 ;
else return 0 ;
}
//////////////////////////////////////////////////////////////////////////////////////////////
public static int gcd(int a, int b )
{
if(b==0)return a ;
else return gcd(b,a%b) ;
}
public static long gcd(long a, long b )
{
if(b==0)return a ;
else return gcd(b,a%b) ;
}
////////////////////////////////////////////////////////////////////////////////////
public static int lcm(int a, int b ,int c , int d )
{
int temp = lcm(a,b , c) ;
int ans = lcm(temp ,d ) ;
return ans ;
}
///////////////////////////////////////////////////////////////////////////////////////////
public static int lcm(int a, int b ,int c )
{
int temp = lcm(a,b) ;
int ans = lcm(temp ,c) ;
return ans ;
}
////////////////////////////////////////////////////////////////////////////////////////
public static int lcm(int a , int b )
{
int gc = gcd(a,b);
return (a/gc)*b ;
}
public static long lcm(long a , long b )
{
long gc = gcd(a,b);
return (a/gc)*b;
}
///////////////////////////////////////////////////////////////////////////////////////////
static boolean isPrime(long n)
{
if(n==1)
{
return false ;
}
boolean ans = true ;
for(long i = 2L; i*i <= n ;i++)
{
if(n% i ==0)
{
ans = false ;break ;
}
}
return ans ;
}
static boolean isPrime(int n)
{
if(n==1)
{
return false ;
}
boolean ans = true ;
for(int i = 2; i*i <= n ;i++)
{
if(n% i ==0)
{
ans = false ;break ;
}
}
return ans ;
}
///////////////////////////////////////////////////////////////////////////
static int sieve = 1000000 ;
static boolean[] prime = new boolean[sieve + 1] ;
public static void sieveOfEratosthenes()
{
// FALSE == prime
// TRUE == COMPOSITE
// FALSE== 1
// time complexity = 0(NlogLogN)== o(N)
// gives prime nos bw 1 to N
for(int i = 4; i<= sieve ; i++)
{
prime[i] = true ;
i++ ;
}
for(int p = 3; p*p <= sieve; p++)
{
if(prime[p] == false)
{
for(int i = p*p; i <= sieve; i += p)
prime[i] = true;
}
p++ ;
}
}
///////////////////////////////////////////////////////////////////////////////////
public static void sortD(int[] arr , int s , int e)
{
sort(arr ,s , e) ;
int i =s ; int j = e ;
while( i < j)
{
int temp = arr[i] ;
arr[i] =arr[j] ;
arr[j] = temp ;
i++ ; j-- ;
}
return ;
}
/////////////////////////////////////////////////////////////////////////////////////////
public static long countSubarraysSumToK(long[] arr ,long sum )
{
HashMap<Long,Long> map = new HashMap<>() ;
int n = arr.length ;
long prefixsum = 0 ;
long count = 0L ;
for(int i = 0; i < n ; i++)
{
prefixsum = prefixsum + arr[i] ;
if(sum == prefixsum)count = count+1 ;
if(map.containsKey(prefixsum -sum))
{
count = count + map.get(prefixsum -sum) ;
}
if(map.containsKey(prefixsum ))
{
map.put(prefixsum , map.get(prefixsum) +1 );
}
else{
map.put(prefixsum , 1L );
}
}
return count ;
}
///////////////////////////////////////////////////////////////////////////////////////////////
// KMP ALGORITHM : TIME COMPL:O(N+M)
// FINDS THE OCCURENCES OF PATTERN AS A SUBSTRING IN STRING
//RETURN THE ARRAYLIST OF INDEXES
// IF SIZE OF LIST IS ZERO MEANS PATTERN IS NOT PRESENT IN STRING
public static ArrayList<Integer> kmpAlgorithm(String str , String pat)
{
ArrayList<Integer> list =new ArrayList<>();
int n = str.length() ;
int m = pat.length() ;
String q = pat + "#" + str ;
int[] lps =new int[n+m+1] ;
longestPefixSuffix(lps, q,(n+m+1)) ;
for(int i =m+1 ; i < (n+m+1) ; i++ )
{
if(lps[i] == m)
{
list.add(i-2*m) ;
}
}
return list ;
}
public static void longestPefixSuffix(int[] lps ,String str , int n)
{
lps[0] = 0 ;
for(int i = 1 ; i<= n-1; i++)
{
int l = lps[i-1] ;
while( l > 0 && str.charAt(i) != str.charAt(l))
{
l = lps[l-1] ;
}
if(str.charAt(i) == str.charAt(l))
{
l++ ;
}
lps[i] = l ;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
// CALCULATE TOTIENT Fn FOR ALL VALUES FROM 1 TO n
// TOTIENT(N) = count of nos less than n and grater than 1 whose gcd with n is 1
// or n and the no will be coprime in nature
//time : O(n*(log(logn)))
public static void eulerTotientFunction(int[] arr ,int n )
{
for(int i = 1; i <= n ;i++)arr[i] =i ;
for(int i= 2 ; i<= n ;i++)
{
if(arr[i] == i)
{
arr[i] =i-1 ;
for(int j =2*i ; j<= n ; j+= i )
{
arr[j] = (arr[j]*(i-1))/i ;
}
}
}
return ;
}
/////////////////////////////////////////////////////////////////////////////////////////////
public static long nCr(int n,int k)
{
long ans=1L;
k=k>n-k?n-k:k;
int j=1;
for(;j<=k;j++,n--)
{
if(n%j==0)
{
ans*=n/j;
}else
if(ans%j==0)
{
ans=ans/j*n;
}else
{
ans=(ans*n)/j;
}
}
return ans;
}
///////////////////////////////////////////////////////////////////////////////////////////
public static ArrayList<Integer> allFactors(int n)
{
ArrayList<Integer> list = new ArrayList<>() ;
for(int i = 1; i*i <= n ;i++)
{
if( n % i == 0)
{
if(i*i == n)
{
list.add(i) ;
}
else{
list.add(i) ;
list.add(n/i) ;
}
}
}
return list ;
}
public static ArrayList<Long> allFactors(long n)
{
ArrayList<Long> list = new ArrayList<>() ;
for(long i = 1L; i*i <= n ;i++)
{
if( n % i == 0)
{
if(i*i == n)
{
list.add(i) ;
}
else{
list.add(i) ;
list.add(n/i) ;
}
}
}
return list ;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
static final int MAXN = 1000001;
static int spf[] = new int[MAXN];
static void sieve()
{
spf[1] = 1;
for (int i=2; i<MAXN; i++)
spf[i] = i;
for (int i=4; i<MAXN; i+=2)
spf[i] = 2;
for (int i=3; i*i<MAXN; i++)
{
if (spf[i] == i)
{
for (int j=i*i; j<MAXN; j+=i)
if (spf[j]==j)
spf[j] = i;
}
}
}
static ArrayList<Integer> getPrimeFactorization(int x)
{
ArrayList<Integer> ret = new ArrayList<Integer>();
while (x != 1)
{
ret.add(spf[x]);
x = x / spf[x];
}
return ret;
}
//////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////
public static void merge(int arr[], int l, int m, int r)
{
// Find sizes of two subarrays to be merged
int n1 = m - l + 1;
int n2 = r - m;
/* Create temp arrays */
int L[] = new int[n1];
int R[] = new int[n2];
//Copy data to temp arrays
for (int i=0; i<n1; ++i)
L[i] = arr[l + i];
for (int j=0; j<n2; ++j)
R[j] = arr[m + 1+ j];
/* Merge the temp arrays */
// Initial indexes of first and second subarrays
int i = 0, j = 0;
// Initial index of merged subarry array
int k = l;
while (i < n1 && j < n2)
{
if (L[i] <= R[j])
{
arr[k] = L[i];
i++;
}
else
{
arr[k] = R[j];
j++;
}
k++;
}
/* Copy remaining elements of L[] if any */
while (i < n1)
{
arr[k] = L[i];
i++;
k++;
}
/* Copy remaining elements of R[] if any */
while (j < n2)
{
arr[k] = R[j];
j++;
k++;
}
}
// Main function that sorts arr[l..r] using
// merge()
public static void sort(int arr[], int l, int r)
{
if (l < r)
{
// Find the middle point
int m = (l+r)/2;
// Sort first and second halves
sort(arr, l, m);
sort(arr , m+1, r);
// Merge the sorted halves
merge(arr, l, m, r);
}
}
public static void sort(long arr[], int l, int r)
{
if (l < r)
{
// Find the middle point
int m = (l+r)/2;
// Sort first and second halves
sort(arr, l, m);
sort(arr , m+1, r);
// Merge the sorted halves
merge(arr, l, m, r);
}
}
public static void merge(long arr[], int l, int m, int r)
{
// Find sizes of two subarrays to be merged
int n1 = m - l + 1;
int n2 = r - m;
/* Create temp arrays */
long L[] = new long[n1];
long R[] = new long[n2];
//Copy data to temp arrays
for (int i=0; i<n1; ++i)
L[i] = arr[l + i];
for (int j=0; j<n2; ++j)
R[j] = arr[m + 1+ j];
/* Merge the temp arrays */
// Initial indexes of first and second subarrays
int i = 0, j = 0;
// Initial index of merged subarry array
int k = l;
while (i < n1 && j < n2)
{
if (L[i] <= R[j])
{
arr[k] = L[i];
i++;
}
else
{
arr[k] = R[j];
j++;
}
k++;
}
/* Copy remaining elements of L[] if any */
while (i < n1)
{
arr[k] = L[i];
i++;
k++;
}
/* Copy remaining elements of R[] if any */
while (j < n2)
{
arr[k] = R[j];
j++;
k++;
}
}
/////////////////////////////////////////////////////////////////////////////////////////
public static long knapsack(int[] weight,long value[],int maxWeight){
int n= value.length ;
//dp[i] stores the profit with KnapSack capacity "i"
long []dp = new long[maxWeight+1];
//initially profit with 0 to W KnapSack capacity is 0
Arrays.fill(dp, 0);
// iterate through all items
for(int i=0; i < n; i++)
//traverse dp array from right to left
for(int j = maxWeight; j >= weight[i]; j--)
dp[j] = Math.max(dp[j] , value[i] + dp[j - weight[i]]);
/*above line finds out maximum of dp[j](excluding ith element value)
and val[i] + dp[j-wt[i]] (including ith element value and the
profit with "KnapSack capacity - ith element weight") */
return dp[maxWeight];
}
///////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// to return max sum of any subarray in given array
public static long kadanesAlgorithm(long[] arr)
{
if(arr.length == 0)return 0 ;
long[] dp = new long[arr.length] ;
dp[0] = arr[0] ;
long max = dp[0] ;
for(int i = 1; i < arr.length ; i++)
{
if(dp[i-1] > 0)
{
dp[i] = dp[i-1] + arr[i] ;
}
else{
dp[i] = arr[i] ;
}
if(dp[i] > max)max = dp[i] ;
}
return max ;
}
/////////////////////////////////////////////////////////////////////////////////////////////
public static long kadanesAlgorithm(int[] arr)
{
if(arr.length == 0)return 0 ;
long[] dp = new long[arr.length] ;
dp[0] = arr[0] ;
long max = dp[0] ;
for(int i = 1; i < arr.length ; i++)
{
if(dp[i-1] > 0)
{
dp[i] = dp[i-1] + arr[i] ;
}
else{
dp[i] = arr[i] ;
}
if(dp[i] > max)max = dp[i] ;
}
return max ;
}
///////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
//TO GENERATE ALL(DUPLICATE ALSO EXIST) PERMUTATIONS OF A STRING
// JUST CALL generatePermutation( str, start, end) start :inclusive ,end : exclusive
//Function for swapping the characters at position I with character at position j
public static String swapString(String a, int i, int j) {
char[] b =a.toCharArray();
char ch;
ch = b[i];
b[i] = b[j];
b[j] = ch;
return String.valueOf(b);
}
//Function for generating different permutations of the string
public static void generatePermutation(String str, int start, int end)
{
//Prints the permutations
if (start == end-1)
System.out.println(str);
else
{
for (int i = start; i < end; i++)
{
//Swapping the string by fixing a character
str = swapString(str,start,i);
//Recursively calling function generatePermutation() for rest of the characters
generatePermutation(str,start+1,end);
//Backtracking and swapping the characters again.
str = swapString(str,start,i);
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
public static long factMod(long n, long mod) {
if (n <= 1) return 1;
long ans = 1;
for (int i = 1; i <= n; i++) {
ans = (ans * i) % mod;
}
return ans;
}
/////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////
public static long power(int a ,int b)
{
//time comp : o(logn)
long x = (long)(a) ;
long n = (long)(b) ;
if(n==0)return 1 ;
if(n==1)return x;
long ans =1L ;
while(n>0)
{
if(n % 2 ==1)
{
ans = ans *x ;
}
n = n/2L ;
x = x*x ;
}
return ans ;
}
public static long power(long a ,long b)
{
//time comp : o(logn)
long x = (a) ;
long n = (b) ;
if(n==0)return 1L ;
if(n==1)return x;
long ans =1L ;
while(n>0)
{
if(n % 2 ==1)
{
ans = ans *x ;
}
n = n/2L ;
x = x*x ;
}
return ans ;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
public static long powerMod(long x, long n, long mod) {
//time comp : o(logn)
if(n==0)return 1L ;
if(n==1)return x;
long ans = 1;
while (n > 0) {
if (n % 2 == 1) ans = (ans * x) % mod;
x = (x * x) % mod;
n /= 2;
}
return ans;
}
//////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/*
lowerBound - finds largest element equal or less than value paased
upperBound - finds smallest element equal or more than value passed
if not present return -1;
*/
public static long lowerBound(long[] arr,long k)
{
long ans=-1;
int start=0;
int end=arr.length-1;
while(start<=end)
{
int mid=(start+end)/2;
if(arr[mid]<=k)
{
ans=arr[mid];
start=mid+1;
}
else
{
end=mid-1;
}
}
return ans;
}
public static int lowerBound(int[] arr,int k)
{
int ans=-1;
int start=0;
int end=arr.length-1;
while(start<=end)
{
int mid=(start+end)/2;
if(arr[mid]<=k)
{
ans=arr[mid];
start=mid+1;
}
else
{
end=mid-1;
}
}
return ans;
}
public static long upperBound(long[] arr,long k)
{
long ans=-1;
int start=0;
int end=arr.length-1;
while(start<=end)
{
int mid=(start+end)/2;
if(arr[mid]>=k)
{
ans=arr[mid];
end=mid-1;
}
else
{
start=mid+1;
}
}
return ans;
}
public static int upperBound(int[] arr,int k)
{
int ans=-1;
int start=0;
int end=arr.length-1;
while(start<=end)
{
int mid=(start+end)/2;
if(arr[mid]>=k)
{
ans=arr[mid];
end=mid-1;
}
else
{
start=mid+1;
}
}
return ans;
}
//////////////////////////////////////////////////////////////////////////////////////////
public static void printArray(int[] arr , int si ,int ei)
{
for(int i = si ; i <= ei ; i++)
{
out.print(arr[i] +" ") ;
}
}
public static void printArrayln(int[] arr , int si ,int ei)
{
for(int i = si ; i <= ei ; i++)
{
out.print(arr[i] +" ") ;
}
out.println() ;
}
public static void printLArray(long[] arr , int si , int ei)
{
for(int i = si ; i <= ei ; i++)
{
out.print(arr[i] +" ") ;
}
}
public static void printLArrayln(long[] arr , int si , int ei)
{
for(int i = si ; i <= ei ; i++)
{
out.print(arr[i] +" ") ;
}
out.println() ;
}
public static void printtwodArray(int[][] ans)
{
for(int i = 0; i< ans.length ; i++)
{
for(int j = 0 ; j < ans[0].length ; j++)out.print(ans[i][j] +" ");
out.println() ;
}
out.println() ;
}
static long modPow(long a, long x, long p) {
//calculates a^x mod p in logarithmic time.
a = a % p ;
if(a == 0)return 0L ;
long res = 1L;
while(x > 0) {
if( x % 2 != 0) {
res = (res * a) % p;
}
a = (a * a) % p;
x =x/2;
}
return res;
}
static long modInverse(long a, long p) {
//calculates the modular multiplicative of a mod p.
//(assuming p is prime).
return modPow(a, p-2, p);
}
static long[] factorial = new long[1000001] ;
static void modfac(long mod)
{
factorial[0]=1L ; factorial[1]=1L ;
for(int i = 2; i<= 1000000 ;i++)
{
factorial[i] = factorial[i-1] *(long)(i) ;
factorial[i] = factorial[i] % mod ;
}
}
static long modBinomial(long n, long r, long p) {
// calculates C(n,r) mod p (assuming p is prime).
if(n < r) return 0L ;
long num = factorial[(int)(n)] ;
long den = (factorial[(int)(r)]*factorial[(int)(n-r)]) % p ;
long ans = num*(modInverse(den,p)) ;
ans = ans % p ;
return ans ;
}
static void update(int val , long[] bit ,int n)
{
for( ; val <= n ; val += (val &(-val)) )
{
bit[val]++ ;
}
}
static long query(int val , long[] bit , int n)
{
long ans = 0L;
for( ; val >=1 ; val-=(val&(-val)) )ans += bit[val];
return ans ;
}
static int countSetBits(long n)
{
int count = 0;
while (n > 0) {
n = (n) & (n - 1L);
count++;
}
return count;
}
static int abs(int x)
{
if(x < 0)x = -1*x ;
return x ;
}
static long abs(long x)
{
if(x < 0)x = -1L*x ;
return x ;
}
////////////////////////////////////////////////////////////////////////////////////////////////
static void p(int val)
{
out.print(val) ;
}
static void p()
{
out.print(" ") ;
}
static void pln(int val)
{
out.println(val) ;
}
static void pln()
{
out.println() ;
}
static void p(long val)
{
out.print(val) ;
}
static void pln(long val)
{
out.println(val) ;
}
static void yes()
{
out.println("YES") ;
}
static void no()
{
out.println("NO") ;
}
////////////////////////////////////////////////////////////////////////////////////////////
// calculate total no of nos greater than or equal to key in sorted array arr
static int bs(int[] arr, int s ,int e ,int key)
{
if( s> e)return 0 ;
int mid = (s+e)/2 ;
if(arr[mid] <key)
{
return bs(arr ,mid+1,e , key) ;
}
else{
return bs(arr ,s ,mid-1, key) + e-mid+1;
}
}
// static ArrayList<Integer>[] adj ;
// static int mod= 1000000007 ;
static ArrayList<Pair> adj[] ;
static int[] col ;
static void dfs(int curr , int max , int p , int colp)
{
int color = 1 ;
for(Pair a : adj[curr])
{
int v = a.first ; int index = a.second ;
if(v== p)continue ;
if(color == colp)
{
color++ ;
}
if(color > max)color = 1 ;
col[index] = color ;
dfs(v,max,curr,color) ;
color++ ;
if(color > max)color = 1;
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
public static void solve()
{
FastReader scn = new FastReader() ;
//Scanner scn = new Scanner(System.in);
//int[] store = {2 ,3, 5 , 7 ,11 , 13 , 17 , 19 , 23 , 29 , 31 , 37 } ;
// product of first 11 prime nos is greater than 10 ^ 12;
//sieve() ;
//ArrayList<Integer> arr[] = new ArrayList[n] ;
ArrayList<Integer> list = new ArrayList<>() ;
ArrayList<Long> lista = new ArrayList<>() ;
ArrayList<Long> listb = new ArrayList<>() ;
// ArrayList<Integer> lista = new ArrayList<>() ;
// ArrayList<Integer> listb = new ArrayList<>() ;
//ArrayList<String> lists = new ArrayList<>() ;
HashMap<Integer,Integer> map = new HashMap<>() ;
//HashMap<Long,Long> map = new HashMap<>() ;
HashMap<Integer,Integer> mapx = new HashMap<>() ;
HashMap<Integer,Integer> mapy = new HashMap<>() ;
//HashMap<String,Integer> maps = new HashMap<>() ;
//HashMap<Integer,Boolean> mapb = new HashMap<>() ;
//HashMap<Point,Integer> point = new HashMap<>() ;
Set<Integer> set = new HashSet<>() ;
Set<Integer> setx = new HashSet<>() ;
Set<Integer> sety = new HashSet<>() ;
StringBuilder sb =new StringBuilder("") ;
//Collections.sort(list);
//if(map.containsKey(arr[i]))map.put(arr[i] , map.get(arr[i]) +1 ) ;
//else map.put(arr[i],1) ;
// if(map.containsKey(temp))map.put(temp , map.get(temp) +1 ) ;
// else map.put(temp,1) ;
//int bit =Integer.bitCount(n);
// gives total no of set bits in n;
// Arrays.sort(arr, new Comparator<Pair>() {
// @Override
// public int compare(Pair a, Pair b) {
// if (a.first != b.first) {
// return a.first - b.first; // for increasing order of first
// }
// return a.second - b.second ; //if first is same then sort on second basis
// }
// });
int testcase = 1;
//testcase = scn.nextInt() ;
for(int testcases =1 ; testcases <= testcase ;testcases++)
{
//if(map.containsKey(arr[i]))map.put(arr[i],map.get(arr[i])+1) ;else map.put(arr[i],1) ;
//if(map.containsKey(temp))map.put(temp,map.get(temp)+1) ;else map.put(temp,1) ;
//adj = new ArrayList[n] ;
// for(int i = 0; i< n; i++)
// {
// adj[i] = new ArrayList<Integer>();
// }
// long n = scn.nextLong() ;
//String s = scn.next() ;
int n= scn.nextInt() ;int k = scn.nextInt() ;
int[] deg= new int[n] ;
int[] temp = new int[n] ;col = new int[n] ;
adj = new ArrayList[n] ;
for(int i = 0 ; i< n ;i++)
{
adj[i] = new ArrayList<Pair>() ;
}
for(int i=0; i <= n-2;i++)
{
int u = scn.nextInt()-1 ; int v = scn.nextInt()-1 ;
temp[u]++ ;temp[v]++ ;
adj[u].add(new Pair(v,i)) ;
adj[v].add(new Pair(u,i)) ;
}
sort(temp,0,n-1) ;
pln(temp[n-k-1]) ;
dfs(0,temp[n-k-1],-1,-1) ;
for(int i = 0; i <= n-2 ;i++)
{
out.print(col[i]+" ");
}
out.println() ;
//out.println(ans) ;
//out.println(ans+" "+in) ;
//out.println("Case #" + testcases + ": " + ans ) ;
//out.println("@") ;
set.clear() ;
sb.delete(0 , sb.length()) ;
list.clear() ;lista.clear() ;listb.clear() ;
map.clear() ;
mapx.clear() ;
mapy.clear() ;
setx.clear() ;sety.clear() ;
} // test case end loop
out.flush() ;
} // solve fn ends
public static void main (String[] args) throws java.lang.Exception
{
solve() ;
}
}
class Pair
{
int first ;
int second ;
public Pair(int f ,int s)
{
this.first = f ;
this.second = s ;
}
@Override
public String toString() {
String ans = "" ;
ans += this.first ;
ans += " ";
ans += this.second ;
return ans ;
}
}
|
You are given two n × m matrices containing integers. A sequence of integers is strictly increasing if each next number is greater than the previous one. A row is strictly increasing if all numbers from left to right are strictly increasing. A column is strictly increasing if all numbers from top to bottom are strictly increasing. A matrix is increasing if all rows are strictly increasing and all columns are strictly increasing.
For example, the matrix \begin{bmatrix} 9&10&11\\\ 11&12&14\\\ \end{bmatrix} is increasing because each individual row and column is strictly increasing. On the other hand, the matrix \begin{bmatrix} 1&1\\\ 2&3\\\ \end{bmatrix} is not increasing because the first row is not strictly increasing.
Let a position in the i-th row (from top) and j-th column (from left) in a matrix be denoted as (i, j).
In one operation, you can choose any two numbers i and j and swap the number located in (i, j) in the first matrix with the number in (i, j) in the second matrix. In other words, you can swap two numbers in different matrices if they are located in the corresponding positions.
You would like to make both matrices increasing by performing some number of operations (possibly none). Determine if it is possible to do this. If it is, print "Possible", otherwise, print "Impossible".
Input
The first line contains two integers n and m (1 ≤ n,m ≤ 50) — the dimensions of each matrix.
Each of the next n lines contains m integers a_{i1}, a_{i2}, …, a_{im} (1 ≤ a_{ij} ≤ 10^9) — the number located in position (i, j) in the first matrix.
Each of the next n lines contains m integers b_{i1}, b_{i2}, …, b_{im} (1 ≤ b_{ij} ≤ 10^9) — the number located in position (i, j) in the second matrix.
Output
Print a string "Impossible" or "Possible".
Examples
Input
2 2
2 10
11 5
9 4
3 12
Output
Possible
Input
2 3
2 4 5
4 5 6
3 6 7
8 10 11
Output
Possible
Input
3 2
1 3
2 4
5 10
3 1
3 6
4 8
Output
Impossible
Note
The first example, we can do an operation on the top left and bottom right cells of the matrices. The resulting matrices will be \begin{bmatrix} 9&10\\\ 11&12\\\ \end{bmatrix} and \begin{bmatrix} 2&4\\\ 3&5\\\ \end{bmatrix}.
In the second example, we don't need to do any operations.
In the third example, no matter what we swap, we can't fix the first row to be strictly increasing in both matrices.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n][m], b[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> b[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] > b[i][j]) {
swap(a[i][j], b[i][j]);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i == 0) {
if (j != 0) {
if (a[i][j] <= a[i][j - 1] || b[i][j] <= b[i][j - 1]) {
cout << "Impossible";
return 0;
}
}
} else {
if (j == 0) {
if (a[i][j] <= a[i - 1][j] || b[i][j] <= b[i - 1][j]) {
cout << "Impossible";
return 0;
}
} else {
if (a[i][j] <= a[i - 1][j] || b[i][j] <= b[i - 1][j] ||
a[i][j] <= a[i][j - 1] || b[i][j] <= b[i][j - 1]) {
cout << "Impossible";
return 0;
}
}
}
}
}
cout << "Possible";
return 0;
}
|
Polycarp knows that if the sum of the digits of a number is divisible by 3, then the number itself is divisible by 3. He assumes that the numbers, the sum of the digits of which is divisible by 4, are also somewhat interesting. Thus, he considers a positive integer n interesting if its sum of digits is divisible by 4.
Help Polycarp find the nearest larger or equal interesting number for the given number a. That is, find the interesting number n such that n ≥ a and n is minimal.
Input
The only line in the input contains an integer a (1 ≤ a ≤ 1000).
Output
Print the nearest greater or equal interesting number for the given number a. In other words, print the interesting number n such that n ≥ a and n is minimal.
Examples
Input
432
Output
435
Input
99
Output
103
Input
237
Output
237
Input
42
Output
44
|
def fun(x):
s=0
org=x
while(x):
s+=x%10
x=x//10
temp=s%4
if temp :
org+=1
return fun(org)
else :
return org
x=int(input())
print(fun(x))
|
Gildong is playing a video game called Block Adventure. In Block Adventure, there are n columns of blocks in a row, and the columns are numbered from 1 to n. All blocks have equal heights. The height of the i-th column is represented as h_i, which is the number of blocks stacked in the i-th column.
Gildong plays the game as a character that can stand only on the top of the columns. At the beginning, the character is standing on the top of the 1-st column. The goal of the game is to move the character to the top of the n-th column.
The character also has a bag that can hold infinitely many blocks. When the character is on the top of the i-th column, Gildong can take one of the following three actions as many times as he wants:
* if there is at least one block on the column, remove one block from the top of the i-th column and put it in the bag;
* if there is at least one block in the bag, take one block out of the bag and place it on the top of the i-th column;
* if i < n and |h_i - h_{i+1}| ≤ k, move the character to the top of the i+1-st column. k is a non-negative integer given at the beginning of the game. Note that it is only possible to move to the next column.
In actions of the first two types the character remains in the i-th column, and the value h_i changes.
The character initially has m blocks in the bag. Gildong wants to know if it is possible to win the game. Help Gildong find the answer to his question.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000). Description of the test cases follows.
The first line of each test case contains three integers n, m, and k (1 ≤ n ≤ 100, 0 ≤ m ≤ 10^6, 0 ≤ k ≤ 10^6) — the number of columns in the game, the number of blocks in the character's bag at the beginning, and the non-negative integer k described in the statement.
The second line of each test case contains n integers. The i-th integer is h_i (0 ≤ h_i ≤ 10^6), the initial height of the i-th column.
Output
For each test case, print "YES" if it is possible to win the game. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
5
3 0 1
4 3 5
3 1 2
1 4 7
4 10 0
10 20 10 20
2 5 5
0 11
1 9 9
99
Output
YES
NO
YES
NO
YES
Note
In the first case, Gildong can take one block from the 1-st column, move to the 2-nd column, put the block on the 2-nd column, then move to the 3-rd column.
In the second case, Gildong has to put the block in his bag on the 1-st column to get to the 2-nd column. But it is impossible to get to the 3-rd column because |h_2 - h_3| = 3 > k and there is no way to decrease the gap.
In the fifth case, the character is already on the n-th column from the start so the game is won instantly.
|
t = int(input())
for _ in range(t):
n, m, k = map(int, input().split())
h = list(map(int, input().split()))
for i in range(n - 1):
m += h[i] - max(0, (h[i + 1] - k))
if m < 0:
print("NO")
break
if(m >= 0):
print("YES")
|
In the galaxy far far away is the ancient interplanetary republic of Bubbleland, consisting of N planets. Between them, there are M bidirectional wormholes, each connecting a pair of planets. Bubbleland is a very centralized republic, having a capital planet Whiteplanet, from which any another planet can be reached using these wormholes. It is also guaranteed that no wormhole connects planet to itself and that no two different wormholes connect same pair of planets.
We call a path that begins at one planet, visits other planets and each of them at most once and returns to starting point a tour. Interplanetary Safety Regulations guarantee that each planet belongs to at most one tour and that there are at most 42 tours.
After many eons of usage, wormholes need to be repaired and each wormhole has the cost W_{i} which needs to be payed for reparation. Unfortunately, the Senate of Bubbleland is short on budget. Therefore, they have decided only to fix as many wormholes as they need in order to have all planets reachable from capital and to pay as little money as they have to for this repair. However the way in which the Senate calculates the cost is different. Cost of the set of reparations is binary xor of costs of each individual reparation, that is if reparations to be made have costs A_{1},A_{2},...,A_{k}, the cost of entire set is A_{1} ⊕ A_{2} ⊕ ... ⊕ A_{k}.
Now the Senate would like to know how much money do they have to pay and also the number of different ways to achieve that cost modulo 1000000007.
Input
First line of input contains two numbers N (1 ≤ N ≤ 100.000), the number of planets and M (1 ≤ M ≤ 100.041), the number of wormholes. Following M lines contain three numbers U, V (1 ≤ U ≠ V ≤ N) and W (1 ≤ W ≤ 100.000), meaning that there exists a wormhole connecting planets U and V, with repair cost of W.
Output
Output two numbers, the smallest possible cost of entire reparation and the number of different valid reparations with that cost modulo 1000000007.
Example
Input
6 6
4 1 5
5 2 1
6 3 2
1 2 6
1 3 3
2 3 4
Output
1 1
Note
We can repair wormholes 1,2,3,5 and 6, paying 5 ⊕ 1⊕ 2 ⊕ 3 ⊕ 4=1, one can check that this is the cheapest repair in which all of the planets are connected and the only valid repair with that cost.
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int mod1 = 998244353;
const int N = 1 << 17;
int weight[N], in[N], parent[N];
vector<pair<int, int> > edge[N];
int a[N], b[N], c[N], d[N];
long long qpow(long long a, long long b, long long mod) {
long long res = 1;
while (b) {
if (b & 1) {
res = res * a % mod;
}
b >>= 1;
a = a * a % mod;
}
return res;
}
struct FWT {
int mod = 1e9 + 7;
int rev = qpow(2, mod - 2, mod);
int add(int a, int b) {
if (a + b >= mod) return a + b - mod;
if (a + b < 0) return a + b + mod;
return a + b;
}
int mul(int a, int b) { return (long long)a * b % mod; }
void fwt(int a[], int n, int op) {
for (int d = 1; d < n; d <<= 1) {
for (int m = d << 1, i = 0; i < n; i += m) {
for (int j = 0; j < d; j++) {
int x = a[i + j], y = a[i + j + d];
if (op == 0)
a[i + j] = add(x, y), a[i + j + d] = add(x, -y);
else
a[i + j] = mul(add(x, y), rev), a[i + j + d] = mul(add(x, -y), rev);
}
}
}
}
void solve(int a[], int b[], int n) {
fwt(a, n, 0);
fwt(b, n, 0);
for (int i = (0); i < (n); i++) a[i] = mul(a[i], b[i]);
fwt(a, n, 1);
}
} Fwt;
int dfn = 0;
vector<int> sum;
int T = 0;
void dfs(int u) {
in[u] = dfn++;
for (auto i : edge[u]) {
int v = i.first;
int w = i.second;
if (v == parent[u]) continue;
if (in[v] == -1) {
parent[v] = u;
weight[v] = w;
dfs(v);
} else if (in[v] < in[u]) {
int tot = w;
for (int i = u; i != v; i = parent[i]) {
tot ^= weight[i];
}
T ^= tot;
memset(b, 0, sizeof(b));
memset(d, 0, sizeof(d));
for (int i = u; i != v; i = parent[i]) {
b[tot ^ weight[i]] += 1;
d[tot ^ weight[i]] += 1;
}
b[tot ^ w] += 1;
d[tot ^ w] += 1;
Fwt.mod = 1e9 + 7;
Fwt.fwt(b, N, 0);
Fwt.mod = mod1;
Fwt.fwt(d, N, 0);
for (int i = (0); i < (N); i++) a[i] = (long long)a[i] * b[i] % mod;
for (int i = (0); i < (N); i++) c[i] = (long long)c[i] * d[i] % mod1;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
memset(in, -1, sizeof(in));
for (int i = (1); i < (m + 1); i++) {
int u, v, w;
cin >> u >> v >> w;
edge[u].push_back(make_pair(v, w));
edge[v].push_back(make_pair(u, w));
T ^= w;
}
a[0] = 1;
c[0] = 1;
Fwt.mod = 1e9 + 7;
Fwt.fwt(a, N, 0);
Fwt.mod = mod1;
Fwt.fwt(c, N, 0);
dfs(1);
memset(b, 0, sizeof(b));
memset(d, 0, sizeof(d));
b[T] = 1;
d[T] = 1;
Fwt.mod = 1e9 + 7;
Fwt.fwt(b, N, 0);
for (int i = (0); i < (N); i++) a[i] = (long long)a[i] * b[i] % mod;
Fwt.mod = mod1;
Fwt.fwt(d, N, 0);
for (int i = (0); i < (N); i++) c[i] = (long long)c[i] * d[i] % mod1;
Fwt.mod = 1e9 + 7;
Fwt.fwt(a, N, 1);
Fwt.mod = mod1;
Fwt.fwt(c, N, 1);
for (int i = (0); i < (N); i++) {
if (a[i] || c[i]) {
cout << i << " " << a[i] << "\n";
return 0;
}
}
return 0;
}
|
Ujan has been lazy lately, but now has decided to bring his yard to good shape. First, he decided to paint the path from his house to the gate.
The path consists of n consecutive tiles, numbered from 1 to n. Ujan will paint each tile in some color. He will consider the path aesthetic if for any two different tiles with numbers i and j, such that |j - i| is a divisor of n greater than 1, they have the same color. Formally, the colors of two tiles with numbers i and j should be the same if |i-j| > 1 and n mod |i-j| = 0 (where x mod y is the remainder when dividing x by y).
Ujan wants to brighten up space. What is the maximum number of different colors that Ujan can use, so that the path is aesthetic?
Input
The first line of input contains a single integer n (1 ≤ n ≤ 10^{12}), the length of the path.
Output
Output a single integer, the maximum possible number of colors that the path can be painted in.
Examples
Input
4
Output
2
Input
5
Output
5
Note
In the first sample, two colors is the maximum number. Tiles 1 and 3 should have the same color since 4 mod |3-1| = 0. Also, tiles 2 and 4 should have the same color since 4 mod |4-2| = 0.
In the second sample, all five colors can be used.
<image>
|
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Random;
import java.io.PrintWriter;
/*
Solution Created: 04:36:52 14/11/2019
Custom Competitive programming helper.
*/
public class Main {
public static void solve(Reader in, Writer out) {
long n = in.nextLong();
ArrayList<Long> divs = new ArrayList<Long>();
for(int i = 2; i<=Math.sqrt(n); i++) {
if(n%i!=0) continue;
divs.add((long) i);
if(i!=n/i) divs.add(n/i);
}
if(divs.size()==0) {
out.println(n);
return;
}
long totalGCD = 0;
for(Long i : divs) totalGCD = Util.gcd(totalGCD, i);
out.println(totalGCD);
}
public static void main(String[] args) {
Reader in = new Reader();
Writer out = new Writer();
solve(in, out);
out.exit();
}
static class Graph {
private ArrayList<Integer> con[];
private boolean[] visited;
public Graph(int n) {
con = new ArrayList[n];
for (int i = 0; i < n; ++i)
con[i] = new ArrayList();
visited = new boolean[n];
}
public void reset() {
Arrays.fill(visited, false);
}
public void addEdge(int v, int w) {
con[v].add(w);
}
public void dfs(int cur) {
visited[cur] = true;
for (Integer v : con[cur]) {
if (!visited[v]) {
dfs(v);
}
}
}
public void bfs(int cur) {
Queue<Integer> q = new LinkedList<>();
q.add(cur);
visited[cur] = true;
while (!q.isEmpty()) {
cur = q.poll();
for (Integer v : con[cur]) {
if (!visited[v]) {
visited[v] = true;
q.add(v);
}
}
}
}
}
static class Reader {
static BufferedReader br;
static StringTokenizer st;
private int charIdx = 0;
private String s;
public Reader() {
this.br = new BufferedReader(new InputStreamReader(System.in));
}
public int[] na(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public double[] nd(int n) {
double[] a = new double[n];
for (int i = 0; i < n; i++)
a[i] = nextDouble();
return a;
}
public char nextChar() {
if (s == null || charIdx >= s.length()) {
if (st == null || !st.hasMoreTokens())
try {
readLine();
} catch (Exception e) {
}
s = st.nextToken();
charIdx = 0;
}
return s.charAt(charIdx++);
}
public long[] nl(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public char[] nca() {
return next().toCharArray();
}
public String[] nS(int n) {
String[] a = new String[n];
for (int i = 0; i < n; i++)
a[i] = next();
return a;
}
public int nextInt() {
if (st == null || !st.hasMoreTokens())
try {
readLine();
} catch (Exception e) {
}
return Integer.parseInt(st.nextToken());
}
public double nextDouble() {
if (st == null || !st.hasMoreTokens())
try {
readLine();
} catch (Exception e) {
}
return Double.parseDouble(st.nextToken());
}
public Long nextLong() {
if (st == null || !st.hasMoreTokens())
try {
readLine();
} catch (Exception e) {
}
return Long.parseLong(st.nextToken());
}
public String next() {
if (st == null || !st.hasMoreTokens())
try {
readLine();
} catch (Exception e) {
}
return st.nextToken();
}
public static void readLine() {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
}
}
}
static class Solution {
public static void solve(Reader in, Writer out) {
}
}
static class Sort {
static Random random = new Random();
public static void sortArray(int[] s) {
shuffle(s);
Arrays.sort(s);
}
public static void sortArray(long[] s) {
shuffle(s);
Arrays.sort(s);
}
public static void sortArray(String[] s) {
shuffle(s);
Arrays.sort(s);
}
public static void sortArray(char[] s) {
shuffle(s);
Arrays.sort(s);
}
private static void shuffle(int[] s) {
for (int i = 0; i < s.length; ++i) {
int j = random.nextInt(i + 1);
int t = s[i];
s[i] = s[j];
s[j] = t;
}
}
private static void shuffle(long[] s) {
for (int i = 0; i < s.length; ++i) {
int j = random.nextInt(i + 1);
long t = s[i];
s[i] = s[j];
s[j] = t;
}
}
private static void shuffle(String[] s) {
for (int i = 0; i < s.length; ++i) {
int j = random.nextInt(i + 1);
String t = s[i];
s[i] = s[j];
s[j] = t;
}
}
private static void shuffle(char[] s) {
for (int i = 0; i < s.length; ++i) {
int j = random.nextInt(i + 1);
char t = s[i];
s[i] = s[j];
s[j] = t;
}
}
}
static class Util{
static boolean isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
public static int upperBound(long[] a, long v) {
int l=0, h=a.length-1, ans = -1;
while(l<h) {
int mid = (l+h)/2;
if(a[mid]<=v) {
ans = mid;
l = mid+1;
}else h = mid-1;
}
return ans;
}
public static int lowerBound(long[] a, long v) {
int l=0, h=a.length-1, ans = -1;
while(l<h) {
int mid = (l+h)/2;
if(v<=a[mid]) {
ans = mid;
h = mid-1;
}else l = mid-1;
}
return ans;
}
public static boolean[] getSieve(int n) {
boolean[] isPrime = new boolean[n+1];
for (int i = 2; i <= n; i++) isPrime[i] = true;
for (int i = 2; i*i <= n; i++) if (isPrime[i])
for (int j = i; i*j <= n; j++) isPrime[i*j] = false;
return isPrime;
}
public static long gcd(long a, long b) {
if (a == 0)
return b;
return gcd(b%a, a);
}
public static long modAdd(long a, long b, long mod) {
return (a%mod+b%mod)%mod;
}
public static long modMul(long a, long b, long mod) {
return ((a%mod)*(b%mod))%mod;
}
public static void dbg(Object... o) {
System.out.println(Arrays.deepToString(o));
}
}
static class Writer {
private PrintWriter pw;
public Writer(){
pw = new PrintWriter(System.out);
}
public void printArray(int[] a) {
for(int i = 0; i<a.length; i++) print(a[i]+" ");
}
public void printlnArray(int[] a) {
for(int i = 0; i<a.length; i++) print(a[i]+" ");
pw.println();
}
public void printArray(long[] a) {
for(int i = 0; i<a.length; i++) print(a[i]+" ");
}
public void printlnArray(long[] a) {
for(int i = 0; i<a.length; i++) print(a[i]+" ");
pw.println();
}
public void print(Object o) {
pw.print(o.toString());
}
public void println(Object o) {
pw.println(o.toString());
}
public void println() {
pw.println();
}
public void flush() {
pw.flush();
}
public void exit() {
pw.close();
}
}
}
|
This is the easier version of the problem. In this version 1 ≤ n, m ≤ 100. You can hack this problem only if you solve and lock both problems.
You are given a sequence of integers a=[a_1,a_2,...,a_n] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:
* [11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
* [40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1 ≤ k ≤ n) is given, then the subsequence is called optimal if:
* it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
* and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b_1, b_2, ..., b_k] is lexicographically smaller than the sequence c=[c_1, c_2, ..., c_k] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1 ≤ t ≤ k) such that b_1=c_1, b_2=c_2, ..., b_{t-1}=c_{t-1} and at the same time b_t<c_t. For example:
* [10, 20, 20] lexicographically less than [10, 21, 1],
* [7, 99, 99] is lexicographically less than [10, 21, 1],
* [10, 21, 0] is lexicographically less than [10, 21, 1].
You are given a sequence of a=[a_1,a_2,...,a_n] and m requests, each consisting of two numbers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j). For each query, print the value that is in the index pos_j of the optimal subsequence of the given sequence a for k=k_j.
For example, if n=4, a=[10,20,30,20], k_j=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request k_j=2, pos_j=1 is the number 20, and the answer to the request k_j=2, pos_j=2 is the number 30.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the length of the sequence a.
The second line contains elements of the sequence a: integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The third line contains an integer m (1 ≤ m ≤ 100) — the number of requests.
The following m lines contain pairs of integers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j) — the requests.
Output
Print m integers r_1, r_2, ..., r_m (1 ≤ r_j ≤ 10^9) one per line: answers to the requests in the order they appear in the input. The value of r_j should be equal to the value contained in the position pos_j of the optimal subsequence for k=k_j.
Examples
Input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
20
10
20
10
20
10
Input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
Output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:
* for k=1: [20],
* for k=2: [10,20],
* for k=3: [10,20,10].
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, int> a, pair<int, int> b) {
return (a.first > b.first || (a.first == b.first && a.second < b.second));
}
int main() {
int n;
cin >> n;
vector<int> a(n);
vector<pair<int, int> > c;
for (int i = 0; i < n; i++) {
cin >> a[i];
c.push_back({a[i], i});
}
int m;
cin >> m;
sort(c.begin(), c.end(), cmp);
for (int q = 0; q < m; q++) {
vector<int> ans;
int k, pos;
cin >> k >> pos;
pos--;
for (int i = 0; i < k; i++) {
ans.push_back(c[i].second);
}
sort(ans.begin(), ans.end());
cout << a[ans[pos]] << "\n";
}
cout << endl;
return 0;
}
|
There are n friends who want to give gifts for the New Year to each other. Each friend should give exactly one gift and receive exactly one gift. The friend cannot give the gift to himself.
For each friend the value f_i is known: it is either f_i = 0 if the i-th friend doesn't know whom he wants to give the gift to or 1 ≤ f_i ≤ n if the i-th friend wants to give the gift to the friend f_i.
You want to fill in the unknown values (f_i = 0) in such a way that each friend gives exactly one gift and receives exactly one gift and there is no friend who gives the gift to himself. It is guaranteed that the initial information isn't contradictory.
If there are several answers, you can print any.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of friends.
The second line of the input contains n integers f_1, f_2, ..., f_n (0 ≤ f_i ≤ n, f_i ≠ i, all f_i ≠ 0 are distinct), where f_i is the either f_i = 0 if the i-th friend doesn't know whom he wants to give the gift to or 1 ≤ f_i ≤ n if the i-th friend wants to give the gift to the friend f_i. It is also guaranteed that there is at least two values f_i = 0.
Output
Print n integers nf_1, nf_2, ..., nf_n, where nf_i should be equal to f_i if f_i ≠ 0 or the number of friend whom the i-th friend wants to give the gift to. All values nf_i should be distinct, nf_i cannot be equal to i. Each friend gives exactly one gift and receives exactly one gift and there is no friend who gives the gift to himself.
If there are several answers, you can print any.
Examples
Input
5
5 0 0 2 4
Output
5 3 1 2 4
Input
7
7 0 0 1 4 0 6
Output
7 3 2 1 4 5 6
Input
7
7 4 0 3 0 5 1
Output
7 4 2 3 6 5 1
Input
5
2 1 0 0 0
Output
2 1 4 5 3
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import javax.swing.JInternalFrame;
public class Main
{
public static void main(String[] args) throws IOException
{
StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
in.nextToken();
int num = (int)in.nval;
//两行，第一行存储是否送出礼物，0否，其他数字，送给的人：送给的人；第二行存储是否收到礼物，0否1是
int[][] numLine = new int[num + 1][2];
for(int i = 1; i <= num; i++)
{
in.nextToken();
int num1 = (int)in.nval;
if(num1 != 0)
{
numLine[i][0] = num1;
numLine[num1][1] = 1;
}
}
int allLost = 0;
for(int i = 1; i <= num; i++)
{
if(numLine[i][0] == 0)
{
allLost++;
}
}
int i1 = 1;
int i2 = 1;
int[][] tempLine = new int[2][4];
if(allLost % 2 == 1)
{
for(;tempLine[0][0] != 3;i1++)
{
if(numLine[i1][0] == 0)
{
tempLine[0][tempLine[0][0] + 1] = i1;
tempLine[0][0] += 1;
}
}
for(;tempLine[1][0] != 3;i2++)
{
if(numLine[i2][1] == 0)
{
tempLine[1][tempLine[1][0] + 1] = i2;
tempLine[1][0] += 1;
}
}
for(;;)
{
if(tempLine[0][1] != tempLine[1][1] && tempLine[0][2] != tempLine[1][2] && tempLine[0][3] != tempLine[1][3])
{
for(int j = 1; j < 4; j++)
{
numLine[tempLine[0][j]][0] = tempLine[1][j];
}
tempLine[0][0] = 0;
tempLine[1][0] = 0;
break;
}
else
{
int t1 = tempLine[1][1];
tempLine[1][1] = tempLine[1][2];
tempLine[1][2] = tempLine[1][3];
tempLine[1][3] = t1;
}
}
}
for(; i1 <= num || i2 <= num;)
{
for(;tempLine[0][0] != 2 && i1 <= num;i1++)
{
if(numLine[i1][0] == 0)
{
tempLine[0][tempLine[0][0] + 1] = i1;
tempLine[0][0] += 1;
}
}
for(;tempLine[1][0] != 2 && i2 <= num;i2++)
{
if(numLine[i2][1] == 0)
{
tempLine[1][tempLine[1][0] + 1] = i2;
tempLine[1][0] += 1;
}
}
for(;;)
{
if(tempLine[0][1] != tempLine[1][1] && tempLine[0][2] != tempLine[1][2])
{
for(int j = 1; j < 3; j++)
{
numLine[tempLine[0][j]][0] = tempLine[1][j];
}
tempLine[0][0] = 0;
tempLine[1][0] = 0;
break;
}
else
{
int t1 = tempLine[1][1];
tempLine[1][1] = tempLine[1][2];
tempLine[1][2] = t1;
}
}
}
for(int i = 1; i <= num; i++)
{
if(i != 1)
{
System.out.print(" ");
}
System.out.print(numLine[i][0]);
}
}
}
|
Let's call a graph with n vertices, each of which has it's own point A_i = (x_i, y_i) with integer coordinates, a planar tree if:
* All points A_1, A_2, …, A_n are different and no three points lie on the same line.
* The graph is a tree, i.e. there are exactly n-1 edges there exists a path between any pair of vertices.
* For all pairs of edges (s_1, f_1) and (s_2, f_2), such that s_1 ≠ s_2, s_1 ≠ f_2, f_1 ≠ s_2, and f_1 ≠ f_2, the segments A_{s_1} A_{f_1} and A_{s_2} A_{f_2} don't intersect.
Imagine a planar tree with n vertices. Consider the convex hull of points A_1, A_2, …, A_n. Let's call this tree a spiderweb tree if for all 1 ≤ i ≤ n the following statements are true:
* All leaves (vertices with degree ≤ 1) of the tree lie on the border of the convex hull.
* All vertices on the border of the convex hull are leaves.
An example of a spiderweb tree:
<image>
The points A_3, A_6, A_7, A_4 lie on the convex hull and the leaf vertices of the tree are 3, 6, 7, 4.
Refer to the notes for more examples.
Let's call the subset S ⊂ \{1, 2, …, n\} of vertices a subtree of the tree if for all pairs of vertices in S, there exists a path that contains only vertices from S. Note that any subtree of the planar tree is a planar tree.
You are given a planar tree with n vertexes. Let's call a partition of the set \{1, 2, …, n\} into non-empty subsets A_1, A_2, …, A_k (i.e. A_i ∩ A_j = ∅ for all 1 ≤ i < j ≤ k and A_1 ∪ A_2 ∪ … ∪ A_k = \{1, 2, …, n\}) good if for all 1 ≤ i ≤ k, the subtree A_i is a spiderweb tree. Two partitions are different if there exists some set that lies in one parition, but not the other.
Find the number of good partitions. Since this number can be very large, find it modulo 998 244 353.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of vertices in the tree.
The next n lines each contain two integers x_i, y_i (-10^9 ≤ x_i, y_i ≤ 10^9) — the coordinates of i-th vertex, A_i.
The next n-1 lines contain two integers s, f (1 ≤ s, f ≤ n) — the edges (s, f) of the tree.
It is guaranteed that all given points are different and that no three of them lie at the same line. Additionally, it is guaranteed that the given edges and coordinates of the points describe a planar tree.
Output
Print one integer — the number of good partitions of vertices of the given planar tree, modulo 998 244 353.
Examples
Input
4
0 0
0 1
-1 -1
1 -1
1 2
1 3
1 4
Output
5
Input
5
3 2
0 -3
-5 -3
5 -5
4 5
4 2
4 1
5 2
2 3
Output
8
Input
6
4 -5
0 1
-2 8
3 -10
0 -1
-4 -5
2 5
3 2
1 2
4 6
4 2
Output
13
Input
8
0 0
-1 2
-2 5
-5 1
1 3
0 3
2 4
-1 -4
1 2
3 2
5 6
4 2
1 5
5 7
5 8
Output
36
Note
<image> The picture for the first sample.
In the first test case, all good partitions are:
1. \{1\}, \{2\}, \{3\}, \{4\};
2. \{1, 2\}, \{3\}, \{4\};
3. \{1, 3\}, \{2\}, \{4\};
4. \{1, 4\}, \{2\}, \{3\};
5. \{1, 2, 3, 4\}.
The partition \{1, 2, 3\}, \{4\} isn't good, because the subtree \{1, 2, 3\} isn't spiderweb tree, since the non-leaf vertex 1 lies on the convex hull.
The partition \{2, 3, 4\}, \{1\} isn't good, because the subset \{2, 3, 4\} isn't a subtree.
<image> The picture for the second sample.
In the second test case, the given tree isn't a spiderweb tree, because the leaf vertex 1 doesn't lie on the convex hull. However, the subtree \{2, 3, 4, 5\} is a spiderweb tree.
<image> The picture for the third sample. <image> The picture for the fourth sample.
In the fourth test case, the partition \{1, 2, 3, 4\}, \{5, 6, 7, 8\} is good because all subsets are spiderweb subtrees.
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(long long a) {
write(a);
puts("");
}
inline void wri(long long a) {
write(a);
putchar(' ');
}
inline unsigned long long rnd() {
return ((unsigned long long)rand() << 30 ^ rand()) << 4 | rand() % 4;
}
const int N = 105, mod = 998244353;
long long f[N], dp[N], DP[N << 1], val[N][N];
vector<int> v[N], way[N][N], d[N];
pair<int, int> a[N];
int n, rt, e[N][N], fir[N][N], lst[N][N], cover[N][N];
void dfs_way(int p, int fa) {
way[rt][p] = way[rt][fa];
way[rt][p].push_back(p);
for (auto i : v[p])
if (i != fa) dfs_way(i, p);
}
long long mul(pair<int, int> a, pair<int, int> b) {
return (long long)a.first * b.second - (long long)a.second * b.first;
}
pair<int, int> operator-(pair<int, int> a, pair<int, int> b) {
return make_pair(a.first - b.first, a.second - b.second);
}
bool cmp(int x, int y) {
return a[x].second == a[y].second ? a[x].first < a[y].first
: a[x].second < a[y].second;
}
int half(pair<int, int> x) {
return x.second < 0 || (x.second == 0 && x.first < 0);
}
bool cnm(pair<int, int> x, pair<int, int> y) {
pair<int, int> A = a[x.second] - a[x.first], B = a[y.second] - a[y.first];
int X = half(A), Y = half(B);
return X == Y ? mul(A, B) > 0 : X < Y;
}
void dfs(int p, int fa) {
for (auto it = v[p].begin(); it != v[p].end(); it++)
if (*it == fa) {
v[p].erase(it);
break;
}
d[p].push_back(p);
for (auto i : v[p]) {
dfs(i, p);
for (auto j : d[i]) d[p].push_back(j);
}
f[p] = 1;
for (auto i : v[p]) f[p] = f[p] * dp[i] % mod;
dp[p] = f[p];
for (auto i : v[p]) {
long long zs = f[i];
for (auto j : v[p])
if (i != j) zs = zs * dp[j] % mod;
dp[p] = (dp[p] + zs) % mod;
}
int k = 0;
memset((e), 0, sizeof(e));
for (auto i : d[p])
for (auto j : v[i]) {
e[i][j] = ++k;
e[j][i] = ++k;
}
vector<pair<int, int> > al;
sort(d[p].begin(), d[p].end(), cmp);
int m = d[p].size();
for (auto i : d[p])
for (auto j : d[p])
if (way[i][j].size() >= 3 && mul(a[j] - a[i], a[p] - a[i]) >= 0) {
al.push_back(make_pair(i, j));
int sz = way[i][j].size();
fir[i][j] = e[way[i][j][0]][way[i][j][1]];
lst[i][j] = e[way[i][j].back()][way[i][j][sz - 2]];
cover[i][j] = 0;
val[i][j] = 1;
for (int o = (int)(0); o <= (int)(sz - 1); o++) {
int x = o ? way[i][j][o - 1] : -1,
y = o <= sz - 2 ? way[i][j][o + 1] : -1, dq = way[i][j][o];
for (auto son : v[dq])
if (son != x && son != y) {
if (x < 0) {
if (mul(a[y] - a[dq], a[son] - a[dq]) > 0) continue;
} else if (y < 0) {
if (mul(a[son] - a[x], a[dq] - a[x]) < 0) continue;
} else {
int A = mul(a[y] - a[dq], a[son] - a[dq]) > 0,
B = mul(a[son] - a[x], a[dq] - a[x]) < 0;
if (mul(a[dq] - a[x], a[y] - a[x]) > 0) {
if (A && B) continue;
} else {
if (A || B) continue;
}
}
val[i][j] = val[i][j] * dp[son] % mod;
}
cover[i][j] |= dq == p;
}
}
sort(al.begin(), al.end(), cnm);
for (int i = (int)(0); i <= (int)(m - 1); i++)
for (int j = (int)(i + 1); j <= (int)(m - 1); j++)
if (e[d[p][i]][d[p][j]]) {
for (int ban = -1; ban <= 1; ban += 2) {
memset((DP), 0, sizeof(DP));
DP[e[d[p][i]][d[p][j]]] = 1;
for (auto o : al) {
if (ban == -1 && cover[o.first][o.second]) continue;
int S = fir[o.first][o.second], T = lst[o.first][o.second];
DP[T] = (DP[T] + DP[S] * val[o.first][o.second]) % mod;
}
DP[e[d[p][i]][d[p][j]]] += mod - 1;
dp[p] += ban * DP[e[d[p][i]][d[p][j]]];
}
}
dp[p] = (dp[p] % mod + mod) % mod;
}
int main() {
n = read();
for (int i = (int)(1); i <= (int)(n); i++) {
a[i].first = read();
a[i].second = read();
}
for (int i = (int)(1); i <= (int)(n - 1); i++) {
int s = read(), t = read();
v[s].push_back(t);
v[t].push_back(s);
}
for (int i = (int)(1); i <= (int)(n); i++) {
rt = i;
dfs_way(i, 0);
for (int j = (int)(1); j <= (int)(n); j++) {
for (auto k : way[i][j])
if (mul(a[j] - a[i], a[k] - a[i]) < 0) {
way[i][j].clear();
break;
}
}
}
dfs(1, 0);
cout << dp[1] << endl;
}
|
This is a hard version of the problem. In this version, the given array can contain equal elements and the constraints on n are greater than in the easy version of the problem.
You are given an array a of n integers (the given array can contain equal elements). You can perform the following operations on array elements:
1. choose any index i (1 ≤ i ≤ n) and move the element a[i] to the begin of the array;
2. choose any index i (1 ≤ i ≤ n) and move the element a[i] to the end of the array.
For example, if n = 5, a = [4, 7, 2, 2, 9], then the following sequence of operations can be performed:
* after performing the operation of the first type to the second element, the array a will become [7, 4, 2, 2, 9];
* after performing the operation of the second type to the second element, the array a will become [7, 2, 2, 9, 4].
You can perform operations of any type any number of times in any order.
Find the minimum total number of operations of the first and second type that will make the a array sorted in non-decreasing order. In other words, what is the minimum number of operations must be performed so the array satisfies the inequalities a[1] ≤ a[2] ≤ … ≤ a[n].
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases in the test. Then t test cases follow.
Each test case starts with a line containing an integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the size of the array a.
Then follow n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — an array that needs to be sorted by the given operations. The given array can contain equal elements.
The sum of n for all test cases in one test does not exceed 2 ⋅ 10^5.
Output
For each test case output one integer — the minimum total number of operations of the first and second type, which will make the array sorted in non-decreasing order.
Example
Input
9
5
4 7 2 2 9
5
3 5 8 1 7
5
1 2 2 4 5
2
0 1
3
0 1 0
4
0 1 0 0
4
0 1 0 1
4
0 1 0 2
20
16 15 1 10 0 14 0 10 3 9 2 5 4 5 17 9 10 20 0 9
Output
2
2
0
0
1
1
1
1
16
Note
In the first test case, you first need to move two 2, to the beginning of the array. Therefore, the desired sequence of operations: [4, 7, 2, 2, 9] → [2, 4, 7, 2, 9] → [2, 2, 4, 7, 9].
In the second test case, you need to move the 1 to the beginning of the array, and the 8 — to the end. Therefore, the desired sequence of operations: [3, 5, 8, 1, 7] → [1, 3, 5, 8, 7] → [1, 3, 5, 7, 8].
In the third test case, the array is already sorted.
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 7;
int T;
int n, a[MAXN], f[MAXN][3], vis[MAXN];
vector<int> v;
inline int getid(int x) {
return lower_bound(v.begin(), v.end(), x) - v.begin() + 1;
}
inline void solve() {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
for (int i = 1; i <= n; ++i) {
a[i] = getid(a[i]);
}
for (int i = n; i >= 1; --i) {
if (!vis[a[i]]) vis[a[i]] = i;
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
f[a[i]][0] = f[a[i]][0] + 1;
if (f[a[i]][1])
f[a[i]][1] = f[a[i]][1] + 1;
else {
f[a[i]][1] = max(f[a[i] - 1][0] + 1, f[a[i]][1]);
if (i > vis[a[i] - 1]) f[a[i]][1] = max(f[a[i] - 1][1] + 1, f[a[i]][1]);
}
f[a[i]][2] = max(f[a[i]][2] + 1, f[a[i] - 1][0] + 1);
if (i > vis[a[i] - 1]) {
f[a[i]][2] = max(f[a[i] - 1][1] + 1, f[a[i]][2]);
}
ans = max(f[a[i]][2], ans);
}
printf("%d\n", n - ans);
v.clear();
for (int i = 1; i <= n; ++i) {
f[i][0] = 0;
f[i][1] = 0;
f[i][2] = 0;
vis[i] = 0;
}
}
int main() {
scanf("%d", &T);
while (T-- > 0) {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
v.push_back(a[i]);
}
solve();
}
return 0;
}
|
You are given an array a_1, a_2, ..., a_n, consisting of n positive integers.
Initially you are standing at index 1 and have a score equal to a_1. You can perform two kinds of moves:
1. move right — go from your current index x to x+1 and add a_{x+1} to your score. This move can only be performed if x<n.
2. move left — go from your current index x to x-1 and add a_{x-1} to your score. This move can only be performed if x>1. Also, you can't perform two or more moves to the left in a row.
You want to perform exactly k moves. Also, there should be no more than z moves to the left among them.
What is the maximum score you can achieve?
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of testcases.
The first line of each testcase contains three integers n, k and z (2 ≤ n ≤ 10^5, 1 ≤ k ≤ n - 1, 0 ≤ z ≤ min(5, k)) — the number of elements in the array, the total number of moves you should perform and the maximum number of moves to the left you can perform.
The second line of each testcase contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^4) — the given array.
The sum of n over all testcases does not exceed 3 ⋅ 10^5.
Output
Print t integers — for each testcase output the maximum score you can achieve if you make exactly k moves in total, no more than z of them are to the left and there are no two or more moves to the left in a row.
Example
Input
4
5 4 0
1 5 4 3 2
5 4 1
1 5 4 3 2
5 4 4
10 20 30 40 50
10 7 3
4 6 8 2 9 9 7 4 10 9
Output
15
19
150
56
Note
In the first testcase you are not allowed to move left at all. So you make four moves to the right and obtain the score a_1 + a_2 + a_3 + a_4 + a_5.
In the second example you can move one time to the left. So we can follow these moves: right, right, left, right. The score will be a_1 + a_2 + a_3 + a_2 + a_3.
In the third example you can move four times to the left but it's not optimal anyway, you can just move four times to the right and obtain the score a_1 + a_2 + a_3 + a_4 + a_5.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n, k, z;
cin >> n >> k >> z;
long long a[n + 7];
for (int i = 0; i < n; i++) cin >> a[i];
long long ans = 0;
for (int i = 0; i <= (z); i++) {
long long r = (k - (2 * i)), sum = 0, mx = 0;
for (long long j = 0; j <= r; j++) {
sum += a[j];
mx = max(mx, a[j] + a[j + 1]);
}
ans = max(ans, sum + (mx * i));
}
cout << ans << '\n';
}
return 0;
}
|
There are n points on a plane. The i-th point has coordinates (x_i, y_i). You have two horizontal platforms, both of length k. Each platform can be placed anywhere on a plane but it should be placed horizontally (on the same y-coordinate) and have integer borders. If the left border of the platform is (x, y) then the right border is (x + k, y) and all points between borders (including borders) belong to the platform.
Note that platforms can share common points (overlap) and it is not necessary to place both platforms on the same y-coordinate.
When you place both platforms on a plane, all points start falling down decreasing their y-coordinate. If a point collides with some platform at some moment, the point stops and is saved. Points which never collide with any platform are lost.
Your task is to find the maximum number of points you can save if you place both platforms optimally.
You have to answer t independent test cases.
For better understanding, please read the Note section below to see a picture for the first test case.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5; 1 ≤ k ≤ 10^9) — the number of points and the length of each platform, respectively. The second line of the test case contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9), where x_i is x-coordinate of the i-th point. The third line of the input contains n integers y_1, y_2, ..., y_n (1 ≤ y_i ≤ 10^9), where y_i is y-coordinate of the i-th point. All points are distinct (there is no pair 1 ≤ i < j ≤ n such that x_i = x_j and y_i = y_j).
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer: the maximum number of points you can save if you place both platforms optimally.
Example
Input
4
7 1
1 5 2 3 1 5 4
1 3 6 7 2 5 4
1 1
1000000000
1000000000
5 10
10 7 5 15 8
20 199 192 219 1904
10 10
15 19 8 17 20 10 9 2 10 19
12 13 6 17 1 14 7 9 19 3
Output
6
1
5
10
Note
The picture corresponding to the first test case of the example:
<image>
Blue dots represent the points, red segments represent the platforms. One of the possible ways is to place the first platform between points (1, -1) and (2, -1) and the second one between points (4, 3) and (5, 3). Vectors represent how the points will fall down. As you can see, the only point we can't save is the point (3, 7) so it falls down infinitely and will be lost. It can be proven that we can't achieve better answer here. Also note that the point (5, 3) doesn't fall at all because it is already on the platform.
|
from bisect import bisect,bisect_left
for _ in range(int(input())):
n,k=map(int,input().split())
x=list(map(int,input().split()))
y=input()
x.sort()
a=[]
b=[]
i=0
while i<n:
b.append(bisect(x,x[i]+k)-i)
a.append(i-bisect_left(x,x[i]-k)+1)
i+=1
b.reverse()
for i in range(1,n):
a[i]=max(a[i],a[i-1])
b[i]=max(b[i],b[i-1])
b.reverse()
m=1
for i in range(n-1):
m=max(a[i]+b[i+1],m)
print(m)
|
Numbers 1, 2, 3, ... n (each integer from 1 to n once) are written on a board. In one operation you can erase any two numbers a and b from the board and write one integer (a + b)/(2) rounded up instead.
You should perform the given operation n - 1 times and make the resulting number that will be left on the board as small as possible.
For example, if n = 4, the following course of action is optimal:
1. choose a = 4 and b = 2, so the new number is 3, and the whiteboard contains [1, 3, 3];
2. choose a = 3 and b = 3, so the new number is 3, and the whiteboard contains [1, 3];
3. choose a = 1 and b = 3, so the new number is 2, and the whiteboard contains [2].
It's easy to see that after n - 1 operations, there will be left only one number. Your goal is to minimize it.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of integers written on the board initially.
It's guaranteed that the total sum of n over test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, in the first line, print the minimum possible number left on the board after n - 1 operations. Each of the next n - 1 lines should contain two integers — numbers a and b chosen and erased in each operation.
Example
Input
1
4
Output
2
2 4
3 3
3 1
|
import java.util.Scanner;
import java.util.Arrays;
import java.util.ArrayList;
public class contest11103{
static Scanner scan = new Scanner(System.in);
static long ceil(long x, long y){
if((x+y)%2==0){
return (x+y)/2;
}else{
return (x+y)/2+(long)1;
}
}
static int t = scan.nextInt();
public static void main(String[] args){
for(int i=0; i<t; i++){
int n = scan.nextInt();
System.out.println(2);
if(n==2){
System.out.println(1+" "+2);
continue;
}
System.out.println(n+" "+(n-2));
System.out.println((n-1)+" "+(n-1));
for(int j=0; j<n-3; j++){
int x = n-1-j;
int y = n-3-j;
System.out.println(x+" "+y);
}
}
}
}
|
Gildong is playing with his dog, Badugi. They're at a park that has n intersections and n-1 bidirectional roads, each 1 meter in length and connecting two intersections with each other. The intersections are numbered from 1 to n, and for every a and b (1 ≤ a, b ≤ n), it is possible to get to the b-th intersection from the a-th intersection using some set of roads.
Gildong has put one snack at every intersection of the park. Now Gildong will give Badugi a mission to eat all of the snacks. Badugi starts at the 1-st intersection, and he will move by the following rules:
* Badugi looks for snacks that are as close to him as possible. Here, the distance is the length of the shortest path from Badugi's current location to the intersection with the snack. However, Badugi's sense of smell is limited to k meters, so he can only find snacks that are less than or equal to k meters away from himself. If he cannot find any such snack, he fails the mission.
* Among all the snacks that Badugi can smell from his current location, he chooses a snack that minimizes the distance he needs to travel from his current intersection. If there are multiple such snacks, Badugi will choose one arbitrarily.
* He repeats this process until he eats all n snacks. After that, he has to find the 1-st intersection again which also must be less than or equal to k meters away from the last snack he just ate. If he manages to find it, he completes the mission. Otherwise, he fails the mission.
Unfortunately, Gildong doesn't know the value of k. So, he wants you to find the minimum value of k that makes it possible for Badugi to complete his mission, if Badugi moves optimally.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).
The first line of each test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of intersections of the park.
The next n-1 lines contain two integers u and v (1 ≤ u,v ≤ n, u ≠ v) each, which means there is a road between intersection u and v. All roads are bidirectional and distinct.
It is guaranteed that:
* For each test case, for every a and b (1 ≤ a, b ≤ n), it is possible to get to the b-th intersection from the a-th intersection.
* The sum of n in all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print one integer — the minimum possible value of k such that Badugi can complete the mission.
Example
Input
3
3
1 2
1 3
4
1 2
2 3
3 4
8
1 2
2 3
3 4
1 5
5 6
6 7
5 8
Output
2
3
3
Note
In the first case, Badugi can complete his mission with k=2 by moving as follows:
1. Initially, Badugi is at the 1-st intersection. The closest snack is obviously at the 1-st intersection, so he just eats it.
2. Next, he looks for the closest snack, which can be either the one at the 2-nd or the one at the 3-rd intersection. Assume that he chooses the 2-nd intersection. He moves to the 2-nd intersection, which is 1 meter away, and eats the snack.
3. Now the only remaining snack is on the 3-rd intersection, and he needs to move along 2 paths to get to it.
4. After eating the snack at the 3-rd intersection, he needs to find the 1-st intersection again, which is only 1 meter away. As he gets back to it, he completes the mission.
In the second case, the only possible sequence of moves he can make is 1 – 2 – 3 – 4 – 1. Since the distance between the 4-th intersection and the 1-st intersection is 3, k needs to be at least 3 for Badugi to complete his mission.
In the third case, Badugi can make his moves as follows: 1 – 5 – 6 – 7 – 8 – 2 – 3 – 4 – 1. It can be shown that this is the only possible sequence of moves for Badugi to complete his mission with k=3.
<image>
|
#include<bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<stack>
#include<queue>
#define INF 0x3f3f3f3f
#define lowbit(x) x & -x
#define lson root<<1,l,mid
#define rson root<<1|1,mid+1,r
using namespace std;
typedef long long ll;
const int mod=1e9+7;
const int N=2e5+5;
vector<int>G[N];
int dep[N];
int ans,maxdepv=0;
void dfs(int u,int fa){
dep[u]=1;
int minn=2e5+5;
int maxx=0;
for(int v:G[u]){
if(v==fa)
continue;
dfs(v,u);
minn=min(dep[v],minn);
maxx=max(maxx,dep[v]);
}
if(minn==2e5+5)
return ;
if(u!=1 && G[u].size()>2){
ans=max(ans,maxx+1);
}
if(u==1){
maxdepv=maxx;
}
dep[u]+=minn;
}
int main(){
#ifdef Mizp
freopen("in.txt","r",stdin);
#endif
int T;
cin>>T;
while(T--){
int n;
cin>>n;
ans=0;
maxdepv=0;
for(int i=1;i<=n;i++)
G[i].clear();
for(int i=1;i<n;i++){
int u,v;
cin>>u>>v;
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1,0);
if(G[1].size()>1){
int flag=0;
for(int i: G[1]){
if(maxdepv==dep[i]){
flag++;
}else{
ans=max(ans,dep[i]+1);
}
}
if(flag==1){
ans=max(ans,maxdepv);
}else{
ans=max(ans,maxdepv+1);
}
cout<<ans<<'\n';
}
else
cout<<max(ans,dep[1]-1)<<'\n';
}
return 0;
}
|
Nezzar loves the game osu!.
osu! is played on beatmaps, which can be seen as an array consisting of distinct points on a plane. A beatmap is called nice if for any three consecutive points A,B,C listed in order, the angle between these three points, centered at B, is strictly less than 90 degrees.
<image> Points A,B,C on the left have angle less than 90 degrees, so they can be three consecutive points of a nice beatmap; Points A',B',C' on the right have angle greater or equal to 90 degrees, so they cannot be three consecutive points of a nice beatmap.
Now Nezzar has a beatmap of n distinct points A_1,A_2,…,A_n. Nezzar would like to reorder these n points so that the resulting beatmap is nice.
Formally, you are required to find a permutation p_1,p_2,…,p_n of integers from 1 to n, such that beatmap A_{p_1},A_{p_2},…,A_{p_n} is nice. If it is impossible, you should determine it.
Input
The first line contains a single integer n (3 ≤ n ≤ 5000).
Then n lines follow, i-th of them contains two integers x_i, y_i (-10^9 ≤ x_i, y_i ≤ 10^9) — coordinates of point A_i.
It is guaranteed that all points are distinct.
Output
If there is no solution, print -1.
Otherwise, print n integers, representing a valid permutation p.
If there are multiple possible answers, you can print any.
Example
Input
5
0 0
5 0
4 2
2 1
3 0
Output
1 2 5 3 4
Note
Here is the illustration for the first test:
<image>
Please note that the angle between A_1, A_2 and A_5, centered at A_2, is treated as 0 degrees. However, angle between A_1, A_5 and A_2, centered at A_5, is treated as 180 degrees.
|
#include<bits/stdc++.h>
#define pb push_back
#define fi first
#define se second
#define all(v) (v).begin(), (v).end()
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
typedef pair<LL, LL> pil;
const int MAX_N = 5005;
const LL MOD = 1000000007LL;
const int inf = 0x3fffffff;
int n;
bool chk[MAX_N];
pil arr[MAX_N];
LL get_dst(int u, int v){
return (arr[u].fi - arr[v].fi) * (arr[u].fi - arr[v].fi)
+ (arr[u].se - arr[v].se) * (arr[u].se - arr[v].se);
}
int get_far(int pre){
int res = pre;
for(int i=1;i<=n;i++){
if(chk[i]) continue;
if(get_dst(pre, res) < get_dst(pre, i)) res = i;
}
return res;
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%lld %lld",&arr[i].fi, &arr[i].se);
}
int pre = 1;
chk[pre] = true;
printf("%d ",pre);
for(int i=2;i<=n;i++){
int curr = get_far(pre);
printf("%d ",curr);
chk[pre = curr] = true;
}
printf("\n");
return 0;
}
|
A palindrome is a string that reads the same backward as forward. For example, the strings "z", "aaa", "aba", and "abccba" are palindromes, but "codeforces" and "ab" are not. You hate palindromes because they give you déjà vu.
There is a string s. You must insert exactly one character 'a' somewhere in s. If it is possible to create a string that is not a palindrome, you should find one example. Otherwise, you should report that it is impossible.
For example, suppose s= "cbabc". By inserting an 'a', you can create "acbabc", "cababc", "cbaabc", "cbabac", or "cbabca". However "cbaabc" is a palindrome, so you must output one of the other options.
Input
The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.
The only line of each test case contains a string s consisting of lowercase English letters.
The total length of all strings does not exceed 3⋅ 10^5.
Output
For each test case, if there is no solution, output "NO".
Otherwise, output "YES" followed by your constructed string of length |s|+1 on the next line. If there are multiple solutions, you may print any.
You can print each letter of "YES" and "NO" in any case (upper or lower).
Example
Input
6
cbabc
ab
zza
ba
a
nutforajaroftuna
Output
YES
cbabac
YES
aab
YES
zaza
YES
baa
NO
YES
nutforajarofatuna
Note
The first test case is described in the statement.
In the second test case, we can make either "aab" or "aba". But "aba" is a palindrome, so "aab" is the only correct answer.
In the third test case, "zaza" and "zzaa" are correct answers, but not "azza".
In the fourth test case, "baa" is the only correct answer.
In the fifth test case, we can only make "aa", which is a palindrome. So the answer is "NO".
In the sixth test case, "anutforajaroftuna" is a palindrome, but inserting 'a' elsewhere is valid.
|
def par(s):
n = len(s)
for i in range(n // 2):
if s[i] != s[n - 1 - i]:
return False
return True
def solve(s):
if not par('a' + s):
return 'YES\n' + 'a' + s
if not par(s + 'a'):
return 'YES\n' + s + 'a'
return 'NO'
t = int(input())
while t > 0:
s = input()
print(solve(s))
t -= 1
|
You are given an array a of n integers. Define the cost of some array t as follows:
$$$cost(t) = ∑_{x ∈ set(t) } last(x) - first(x),$$$
where set(t) is the set of all values in t without repetitions, first(x), and last(x) are the indices of the first and last occurrence of x in t, respectively. In other words, we compute the distance between the first and last occurrences for each distinct element and sum them up.
You need to split the array a into k consecutive segments such that each element of a belongs to exactly one segment and the sum of the cost of individual segments is minimum.
Input
The first line contains two integers n, k (1 ≤ n ≤ 35 000, 1 ≤ k ≤ min(n,100)).
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n).
Output
Output the minimum sum of the cost of individual segments.
Examples
Input
7 2
1 6 6 4 6 6 6
Output
3
Input
7 4
5 5 5 5 2 3 3
Output
1
Note
In the first example, we can divide the array into [1,6,6,4] and [6,6,6]. Cost of [1,6,6,4] will be (1-1) + (3 - 2) + (4-4) = 1 and cost of [6,6,6] will be 3-1 = 2. Total cost would be 1 + 2 = 3.
In the second example, divide the array into [5,5],[5],[5,2,3] and [3]. Total Cost would be 1 + 0 + 0 + 0 = 1.
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<int, int> pii;
typedef vector<int> vi;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define sz(x) ((int)(x.size()))
#define all(x) (x).begin(), (x).end()
#define rep(i, l, r) for(int i = (l); i < (r); ++i)
#define dd(x) cout << #x << " = " << x << ", "
#define de(x) cout << #x << " = " << x << endl
//-------
const int N = 35353;
const ll INF = 1e18;
int n, m;
int a[N], last[N];
ll f[N];
struct SegmentTree {
int n;
std::vector<ll> mn, tag;
SegmentTree(int n) : n(n), mn(4 * n, INF), tag(4 * n) {}
void pull(int p) {
mn[p] = std::min(mn[2 * p], mn[2 * p + 1]);
}
void push(int p) {
add(2 * p, tag[p]);
add(2 * p + 1, tag[p]);
tag[p] = 0;
}
void add(int p, ll v) {
mn[p] += v;
tag[p] += v;
}
void rangeAdd(int p, int l, int r, int x, int y, ll v) {
if (l > y || r < x) {
return;
}
if (l >= x && r <= y) {
add(p, v);
return;
}
int m = (l + r) / 2;
push(p);
rangeAdd(2 * p, l, m, x, y, v);
rangeAdd(2 * p + 1, m + 1, r, x, y, v);
pull(p);
}
};
int main() {
scanf("%d%d", &n, &m);
rep(i, 0, n) scanf("%d", a + i);
rep(i, 0, n) a[i]--;
fill_n(last, n, -1);
fill_n(f, n, INF);
f[0] = 0;
ll ans = 0;
rep(j, 0, m) {
SegmentTree seg_tree(n);
fill_n(last, n, -1);
ll lastf = 0;
rep(i, 1, n + 1) {
auto & val = a[i - 1];
seg_tree.rangeAdd(1, 0, n - 1, i - 1, i - 1, lastf - INF);
if (last[val] != -1) {
seg_tree.rangeAdd(1, 0, n - 1, 0, last[val], i - 1 - last[val]);
}
lastf = f[i];
f[i] = seg_tree.mn[1];
last[val] = i - 1;
}
}
printf("%lld\n", f[n]);
return 0;
}
|
You are given a non-empty string s consisting of lowercase letters. Find the number of pairs of non-overlapping palindromic substrings of this string.
In a more formal way, you have to find the quantity of tuples (a, b, x, y) such that 1 ≤ a ≤ b < x ≤ y ≤ |s| and substrings s[a... b], s[x... y] are palindromes.
A palindrome is a string that can be read the same way from left to right and from right to left. For example, "abacaba", "z", "abba" are palindromes.
A substring s[i... j] (1 ≤ i ≤ j ≤ |s|) of string s = s1s2... s|s| is a string sisi + 1... sj. For example, substring s[2...4] of string s = "abacaba" equals "bac".
Input
The first line of input contains a non-empty string s which consists of lowercase letters ('a'...'z'), s contains at most 2000 characters.
Output
Output a single number — the quantity of pairs of non-overlapping palindromic substrings of s.
Please do not use the %lld format specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d format specifier.
Examples
Input
aa
Output
1
Input
aaa
Output
5
Input
abacaba
Output
36
|
#include <bits/stdc++.h>
using namespace std;
string str;
long long ans[2001], sum[2001], temp, pal[2001][2001], n;
int main() {
ios_base::sync_with_stdio(false);
cin >> str;
n = str.size();
for (int i = 0; i < n; i++)
for (int j = 0; j < n - i; j++) {
int x = j;
int y = j + i;
if (x == y)
pal[x][y] = 1;
else if (x == y - 1 && str[x] == str[y])
pal[x][y] = 1;
else if (pal[x + 1][y - 1] == 1 && str[x] == str[y])
pal[x][y] = 1;
}
for (int i = 0; i < n; i++) {
temp = 0;
for (int j = 0; j <= i; j++)
if (pal[j][i]) temp++;
sum[i] = (i ? sum[i - 1] : 0) + temp;
}
for (int i = 0; i < n; i++) {
temp = 0;
for (int j = 0; j <= i; j++) temp += pal[j][i] * sum[j - 1];
ans[i] = ans[i - 1] + temp;
}
cout << ans[n - 1] << endl;
}
|
Offering the ABBYY Cup participants a problem written by the Smart Beaver is becoming a tradition. He proposed the following problem.
You are given a monochrome image, that is, an image that is composed of two colors (black and white). The image is given in raster form, that is, as a matrix of pixels' colors, and the matrix's size coincides with the size of the image.
The white color on the given image corresponds to the background. Also, the image contains several black geometric shapes. It is known that the image can contain only two types of shapes: squares and circles. Your task is to count the number of circles and the number of squares which the given image contains.
The squares on the image can be rotated arbitrarily. In addition, the image can possibly contain some noise arranged as follows: each pixel of the original image can change its color to the opposite with the probability of 20%.
<image> An example of an image that has no noise and the sides of the squares are parallel to the coordinate axes (two circles and three squares). <image> An example of an image that has no noise and the squares are rotated arbitrarily (two circles and three squares). <image> An example of an image that has noise and the squares are rotated arbitrarily (one circle and three squares).
Input
The first input line contains a single integer n (1000 ≤ n ≤ 2000), which is the length and the width of the original image.
Next n lines describe the matrix of colors of the image pixels. The i-th line contains exactly n integers aij (0 ≤ aij ≤ 1), separated by spaces. Value of aij = 0 corresponds to a white pixel and aij = 1 corresponds to a black one.
It is guaranteed that the lengths of the sides of the squares and the diameters of the circles in the image are at least 15 pixels, and the distance between any two figures is at least 10 pixels. It is also guaranteed that a human can easily calculate the number of circles and squares in the original image. The total number of figures in the image doesn't exceed 50.
The input limitations for getting 20 points are:
* These test cases have no noise and the sides of the squares are parallel to the coordinate axes.
The input limitations for getting 50 points are:
* These test cases have no noise, but the squares are rotated arbitrarily.
The input limitations for getting 100 points are:
* These test cases have noise and the squares are rotated arbitrarily.
Output
Print exactly two integers, separated by a single space — the number of circles and the number of squares in the given image, correspondingly.
Examples
Note
You are given a sample of original data for each difficulty level. The samples are available at http://codeforces.ru/static/materials/contests/178/e-samples.zip .
|
import java.util.*;
import java.io.*;
public class Solution {
FastScanner in;
PrintWriter out;
int N;
int circles = 0;
int boxes = 0;
int [][] a;
boolean [][] was;
class point {
int x;
int y;
point(int x, int y) {
this.x = x;
this.y = y;
}
}
boolean ok (int x, int y) {
if (x < 0 || x >= N || y < 0 || y >= N) return false;
if (was[x][y] || a[x][y] == 0) return false;
return true;
}
void rec(int x, int y) {
ArrayList<point> tmp = new ArrayList<point>();
tmp.add(new point(x, y));
int from = 0;
was[x][y] = true;
while (from < tmp.size()) {
point now = tmp.get(from);
for (int nx = now.x - 1; nx <= now.x + 1; nx++)
for (int ny = now.y - 1; ny <= now.y + 1; ny++)
if (ok(nx, ny)) {
was[nx][ny] = true;
tmp.add(new point(nx, ny));
}
from++;
}
//
long cmx = 0, cmy = 0;
long R2 = 0;
for (int i = 0; i < tmp.size(); i++) {
cmx += tmp.get(i).x;
cmy += tmp.get(i).y;
}
cmx /= tmp.size();
cmy /= tmp.size();
for (int i = 0; i < tmp.size(); i++) {
long x1 = (tmp.get(i).x - cmx)*(tmp.get(i).x - cmx) + (tmp.get(i).y - cmy)*(tmp.get(i).y - cmy);
if (x1 > R2) R2 = x1;
}
long S = (long) (0.93 * Math.PI * R2);
if (tmp.size() > S) circles++; else boxes++;
}
public void solve() throws IOException {
N = in.nextInt();
a = new int[N][N];
was = new boolean[N][N];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
a[i][j] = in.nextInt();
was[i][j] = false;
}
}
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
if (!was[i][j] && a[i][j] == 1) {
rec(i, j);
}
out.print(circles);
out.print(" ");
out.print(boxes);
}
public void run() {
try {
//in = new FastScanner(new File("input.txt"));
//out = new PrintWriter(new File("output.txt"));
in = new FastScanner(System.in);
out = new PrintWriter(System.out);
solve();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
class FastScanner {
BufferedReader br;
StringTokenizer st;
FastScanner(File f) {
try {
br = new BufferedReader(new FileReader(f));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
FastScanner(InputStream f) {
br = new BufferedReader(new InputStreamReader(f));
}
String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
}
public static void main(String[] arg) {
new Solution().run();
}
}
|
A widely known among some people Belarusian sport programmer Yura possesses lots of information about cars. That is why he has been invited to participate in a game show called "Guess That Car!".
The game show takes place on a giant parking lot, which is 4n meters long from north to south and 4m meters wide from west to east. The lot has n + 1 dividing lines drawn from west to east and m + 1 dividing lines drawn from north to south, which divide the parking lot into n·m 4 by 4 meter squares. There is a car parked strictly inside each square. The dividing lines are numbered from 0 to n from north to south and from 0 to m from west to east. Each square has coordinates (i, j) so that the square in the north-west corner has coordinates (1, 1) and the square in the south-east corner has coordinates (n, m). See the picture in the notes for clarifications.
Before the game show the organizers offer Yura to occupy any of the (n + 1)·(m + 1) intersection points of the dividing lines. After that he can start guessing the cars. After Yura chooses a point, he will be prohibited to move along the parking lot before the end of the game show. As Yura is a car expert, he will always guess all cars he is offered, it's just a matter of time. Yura knows that to guess each car he needs to spend time equal to the square of the euclidean distance between his point and the center of the square with this car, multiplied by some coefficient characterizing the machine's "rarity" (the rarer the car is, the harder it is to guess it). More formally, guessing a car with "rarity" c placed in a square whose center is at distance d from Yura takes c·d2 seconds. The time Yura spends on turning his head can be neglected.
It just so happened that Yura knows the "rarity" of each car on the parking lot in advance. Help him choose his point so that the total time of guessing all cars is the smallest possible.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the sizes of the parking lot. Each of the next n lines contains m integers: the j-th number in the i-th line describes the "rarity" cij (0 ≤ cij ≤ 100000) of the car that is located in the square with coordinates (i, j).
Output
In the first line print the minimum total time Yura needs to guess all offered cars. In the second line print two numbers li and lj (0 ≤ li ≤ n, 0 ≤ lj ≤ m) — the numbers of dividing lines that form a junction that Yura should choose to stand on at the beginning of the game show. If there are multiple optimal starting points, print the point with smaller li. If there are still multiple such points, print the point with smaller lj.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2 3
3 4 5
3 9 1
Output
392
1 1
Input
3 4
1 0 0 0
0 0 3 0
0 0 5 5
Output
240
2 3
Note
In the first test case the total time of guessing all cars is equal to 3·8 + 3·8 + 4·8 + 9·8 + 5·40 + 1·40 = 392.
The coordinate system of the field:
<image>
|
#include <bits/stdc++.h>
using namespace std;
int fast_input(void) {
int x = 0;
char ch;
ch = getchar();
while (ch < '0' && ch > '9') {
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x + x + x + x + x + x + x + x + x + x + ch - '0';
ch = getchar();
}
return x;
}
int X[2], n[2], line[2][1101];
long long cost[2];
long long func(int ele, int g) {
int i, j;
long long sum = 0, x;
ele = ele + ele + ele + ele;
for (i = 0; i < n[g]; i++) {
x = i + i + i + i + 2;
sum += (ele - x) * (ele - x) * line[g][i];
}
return sum;
}
void srch2(int left, int right, int g) {
if (right - left < 3) {
long long ans, mn = 1e18;
int id = -1;
for (int i = left; i <= right; i++) {
ans = func(i, g);
if (ans < mn) {
mn = ans;
id = i;
}
}
cost[g] = mn;
X[g] = id;
return;
}
int mid1, mid2;
mid1 = (left + left + right) / 3;
mid2 = (left + right + right) / 3;
if (func(mid1, g) <= func(mid2, g)) {
srch2(left, mid2, g);
} else {
srch2(mid1, right, g);
}
}
int main() {
int i, j, a;
n[0] = fast_input();
n[1] = fast_input();
for (i = 0; i < n[0]; i++)
for (j = 0; j < n[1]; j++) {
a = fast_input();
line[0][i] += a;
line[1][j] += a;
}
srch2(0, n[0], 0);
srch2(0, n[1], 1);
cout << cost[0] + cost[1] << endl;
cout << X[0] << " " << X[1] << endl;
}
|
An expedition group flew from planet ACM-1 to Earth in order to study the bipedal species (its representatives don't even have antennas on their heads!).
The flying saucer, on which the brave pioneers set off, consists of three sections. These sections are connected by a chain: the 1-st section is adjacent only to the 2-nd one, the 2-nd one — to the 1-st and the 3-rd ones, the 3-rd one — only to the 2-nd one. The transitions are possible only between the adjacent sections.
The spacecraft team consists of n aliens. Each of them is given a rank — an integer from 1 to n. The ranks of all astronauts are distinct. The rules established on the Saucer, state that an alien may move from section a to section b only if it is senior in rank to all aliens who are in the segments a and b (besides, the segments a and b are of course required to be adjacent). Any alien requires exactly 1 minute to make a move. Besides, safety regulations require that no more than one alien moved at the same minute along the ship.
Alien A is senior in rank to alien B, if the number indicating rank A, is more than the corresponding number for B.
At the moment the whole saucer team is in the 3-rd segment. They all need to move to the 1-st segment. One member of the crew, the alien with the identification number CFR-140, decided to calculate the minimum time (in minutes) they will need to perform this task.
Help CFR-140, figure out the minimum time (in minutes) that all the astronauts will need to move from the 3-rd segment to the 1-st one. Since this number can be rather large, count it modulo m.
Input
The first line contains two space-separated integers: n and m (1 ≤ n, m ≤ 109) — the number of aliens on the saucer and the number, modulo which you should print the answer, correspondingly.
Output
Print a single number — the answer to the problem modulo m.
Examples
Input
1 10
Output
2
Input
3 8
Output
2
Note
In the first sample the only crew member moves from segment 3 to segment 2, and then from segment 2 to segment 1 without any problems. Thus, the whole moving will take two minutes.
To briefly describe the movements in the second sample we will use value <image>, which would correspond to an alien with rank i moving from the segment in which it is at the moment, to the segment number j. Using these values, we will describe the movements between the segments in the second sample: <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>; In total: the aliens need 26 moves. The remainder after dividing 26 by 8 equals 2, so the answer to this test is 2.
|
import java.io.*;
import java.util.*;
public class Test {
static BufferedReader reader;
static StringTokenizer tokenizer;
static PrintWriter writer;
static int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
static long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
static double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
static String nextToken() throws IOException {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
public static void main(String[] args) throws IOException {
reader = new BufferedReader(new InputStreamReader(System.in));
tokenizer = null;
writer = new PrintWriter(System.out);
solve();
reader.close();
writer.close();
}
static long f(long n, long m) {
if (n == 0)
return 1;
if (n % 2 == 1)
return (f(n - 1, m) * 3) % m;
else {
long b = f(n / 2, m);
return (b * b) % m;
}
}
private static void solve() throws IOException {
long n = nextInt();
long m = nextInt();
writer.println((f(n, m)+m - 1)%m);
}
}
|
You received as a gift a very clever robot walking on a rectangular board. Unfortunately, you understood that it is broken and behaves rather strangely (randomly). The board consists of N rows and M columns of cells. The robot is initially at some cell on the i-th row and the j-th column. Then at every step the robot could go to some another cell. The aim is to go to the bottommost (N-th) row. The robot can stay at it's current cell, move to the left, move to the right, or move to the cell below the current. If the robot is in the leftmost column it cannot move to the left, and if it is in the rightmost column it cannot move to the right. At every step all possible moves are equally probable. Return the expected number of step to reach the bottommost row.
Input
On the first line you will be given two space separated integers N and M (1 ≤ N, M ≤ 1000). On the second line you will be given another two space separated integers i and j (1 ≤ i ≤ N, 1 ≤ j ≤ M) — the number of the initial row and the number of the initial column. Note that, (1, 1) is the upper left corner of the board and (N, M) is the bottom right corner.
Output
Output the expected number of steps on a line of itself with at least 4 digits after the decimal point.
Examples
Input
10 10
10 4
Output
0.0000000000
Input
10 14
5 14
Output
18.0038068653
|
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.IOException;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskD solver = new TaskD();
solver.solve(in, out);
out.close();
}
}
class TaskD {
public void solve(InputReader in, PrintWriter out) {
double[][] dp = new double[1008][1008];
int n = in.nextInt();
int m = in.nextInt();
int x = in.nextInt();
int y = in.nextInt();
if (m == 1) {
out.printf("%.10f\n",(float) 2 * (n - x));
return;
}
for (int i = 0; i < 1008; i++) {
for (int j = 0; j < 1008; j++) {
dp[i][j] = 0;
}
}
for (int i = n - 1; i > 0; i--) {
for(int t=0;t<60;t++) {
for (int j = 1; j <= m; j++) {
if (j == 1) {
dp[i][j] = (dp[i][j + 1] + dp[i + 1][j] + dp[i][j]) / 3 + 1;
} else if (j == m) {
dp[i][j] = (dp[i][j - 1] + dp[i + 1][j] + dp[i][j]) / 3 + 1;
} else {
dp[i][j] = (dp[i][j] + dp[i + 1][j] + dp[i][j + 1] + dp[i][j - 1]) / 4 + 1;
}
}
}
}
out.printf("%.10f\n", dp[x][y]);
}
}
class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
}
|
Imagine an n × m grid with some blocked cells. The top left cell in the grid has coordinates (1, 1) and the bottom right cell has coordinates (n, m). There are k blocked cells in the grid and others are empty. You flash a laser beam from the center of an empty cell (xs, ys) in one of the diagonal directions (i.e. north-east, north-west, south-east or south-west). If the beam hits a blocked cell or the border of the grid it will reflect. The behavior of the beam reflection in different situations is depicted in the figure below.
<image>
After a while the beam enters an infinite cycle. Count the number of empty cells that the beam goes through at least once. We consider that the beam goes through cell if it goes through its center.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 105, 0 ≤ k ≤ 105). Each of the next k lines contains two integers xi and yi (1 ≤ xi ≤ n, 1 ≤ yi ≤ m) indicating the position of the i-th blocked cell.
The last line contains xs, ys (1 ≤ xs ≤ n, 1 ≤ ys ≤ m) and the flash direction which is equal to "NE", "NW", "SE" or "SW". These strings denote directions ( - 1, 1), ( - 1, - 1), (1, 1), (1, - 1).
It's guaranteed that no two blocked cells have the same coordinates.
Output
In the only line of the output print the number of empty cells that the beam goes through at least once.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3 3 0
1 2 SW
Output
6
Input
7 5 3
3 3
4 3
5 3
2 1 SE
Output
14
|
#include <bits/stdc++.h>
using namespace std;
int a1234;
char buf[1 << 18], *bufs = buf, *buft = buf;
inline int gc() {
return bufs == buft && (buft = (bufs = buf) + fread(buf, 1, 1 << 18, stdin)),
bufs == buft ? -1 : *bufs++;
}
inline void xxx() {
for (;;)
;
}
inline int rd(int l, int r) { return rand() % (r - l + 1) + l; }
const int mxn = 4e5 + 10;
int n, m, k, nn;
int dr[mxn][2], fd, sx, sy;
const int dx[] = {-1, -1, 1, 1}, dy[] = {-1, 1, -1, 1};
char ss[66];
vector<int> v[mxn];
map<pair<int, int>, int> mp, bl;
inline int id(int o, int x, int y) {
return o ? x + y + m + n + 5 : x - y + m + 1;
}
int he[mxn];
struct thr {
int a, b, c;
thr() {}
thr(int aa, int bb, int cc) { a = aa, b = bb, c = cc; }
};
thr db[mxn];
bool tmp[mxn];
long long ans = 0;
inline void eee(int x, int y) {
bl[pair<int, int>(x, y)] = 1;
int aa = id(0, x, y), bb = id(1, x, y);
v[aa].push_back(x), v[bb].push_back(x);
if (!he[aa]) he[aa] = aa - m - 1;
if (!he[bb]) he[bb] = bb - m - n - 5;
}
inline bool isdu(int x, int y) {
return bl.find(pair<int, int>(x, y)) != bl.end();
}
int main() {
a1234 = scanf("%d%d%d", &n, &m, &k);
for (int i = 1, x, y; i <= k; ++i)
a1234 = scanf("%d%d", &x, &y), dr[i][0] = x, dr[i][1] = y, eee(x, y);
for (int i = 0; i <= n + 1; ++i) eee(i, 0), eee(i, m + 1);
for (int i = 1; i <= m; ++i) eee(0, i), eee(n + 1, i);
nn = id(1, n + 1, m + 1);
for (int i = 0; i <= nn; ++i) sort(v[i].begin(), v[i].end());
a1234 = scanf("%d%d%s", &sx, &sy, ss);
if (ss[0] == 'N') fd = ss[1] == 'W' ? 0 : 1;
if (ss[0] == 'S') fd = ss[1] == 'W' ? 2 : 3;
int x = sx, y = sy, o = fd, xh, bu = 0, oo;
while (1) {
++bu;
if (o == 0 || o == 3)
oo = 0, xh = id(0, x, y);
else
oo = 1, xh = id(1, x, y);
vector<int>::iterator p = lower_bound(v[xh].begin(), v[xh].end(), x);
int p1 = *(p - 1), p2 = *p, len = p2 - p1 - 1;
if (bu == 1) {
if (o == 0 || o == 1)
ans = x - p1, x = p1 + 1, y = oo ? he[xh] - x : x - he[xh];
else
ans = p2 - x, x = p2 - 1, y = oo ? he[xh] - x : x - he[xh];
mp[pair<int, int>(xh, p1)] = ans;
} else {
int &bs = mp[pair<int, int>(xh, p1)];
if (bs > len) break;
if (o == 0 || o == 1)
x = p1 + 1, y = oo ? he[xh] - x : x - he[xh];
else
x = p2 - 1, y = oo ? he[xh] - x : x - he[xh];
ans += len - bs, bs += len;
}
int o1, o2, x1, x2, y1, y2;
if (o == 0) {
o1 = 1, x1 = x - 1, y1 = y, o2 = 2, x2 = x, y2 = y - 1;
} else if (o == 1) {
o1 = 0, o2 = 3, x1 = x - 1, y1 = y, x2 = x, y2 = y + 1;
} else if (o == 2) {
o1 = 0, o2 = 3, x1 = x, y1 = y - 1, x2 = x + 1, y2 = y;
} else {
o1 = 1, o2 = 2, x1 = x, y1 = y + 1, x2 = x + 1, y2 = y;
}
if (isdu(x1, y1) ^ isdu(x2, y2)) {
if (isdu(x1, y1))
o = o2, x = x2, y = y2;
else
o = o1, x = x1, y = y1;
} else
o = 3 - o;
}
printf("%lld\n", ans);
return 0;
}
namespace task1 {
const int mxn = 1003;
int du[mxn][mxn], vis[mxn][mxn], ans = 1;
int x, y, o;
bool fl;
inline void work() {
while (1) {
int xx = x + dx[o], yy = y + dy[o];
if (!du[xx][yy]) {
if (vis[xx][yy]) break;
vis[x = xx][y = yy] = 1, ++ans;
continue;
}
int o1 = 5, o2 = 5, x1, x2, y1, y2;
if (o == 0)
o1 = 1, o2 = 2, x1 = x - 1, y1 = y, x2 = x, y2 = y - 1;
else if (o == 1)
o1 = 0, o2 = 3, x1 = x - 1, y1 = y, x2 = x, y2 = y + 1;
else if (o == 2)
o1 = 0, o2 = 3, x1 = x, y1 = y - 1, x2 = x + 1, y2 = y;
else
o1 = 1, o2 = 2, x1 = x, y1 = y + 1, x2 = x + 1, y2 = y;
if (du[x1][y1] == du[x2][y2]) {
fl = 1;
break;
}
if (!du[x1][y1]) {
o = o1;
if (vis[x1][y1]) break;
vis[x = x1][y = y1] = 1, ++ans;
} else {
o = o2;
if (vis[x2][y2]) break;
vis[x = x2][y = y2] = 1, ++ans;
}
}
}
int main1() {
for (int i = 1; i <= k; ++i) du[dr[i][0]][dr[i][1]] = 1;
for (int i = 0; i <= n + 1; ++i) du[i][0] = du[i][m + 1] = 1;
for (int i = 0; i <= m + 1; ++i) du[0][i] = du[n + 1][i] = 1;
x = sx, y = sy, o = fd;
vis[sx][sy] = 1;
fl = 0;
work();
if (!fl) return printf("%d\n", ans), 0;
o = 3 - fd, x = sx, y = sy;
work();
printf("%d\n", ans);
return 0;
}
} // namespace task1
|
The polar bears are going fishing. They plan to sail from (sx, sy) to (ex, ey). However, the boat can only sail by wind. At each second, the wind blows in one of these directions: east, south, west or north. Assume the boat is currently at (x, y).
* If the wind blows to the east, the boat will move to (x + 1, y).
* If the wind blows to the south, the boat will move to (x, y - 1).
* If the wind blows to the west, the boat will move to (x - 1, y).
* If the wind blows to the north, the boat will move to (x, y + 1).
Alternatively, they can hold the boat by the anchor. In this case, the boat stays at (x, y). Given the wind direction for t seconds, what is the earliest time they sail to (ex, ey)?
Input
The first line contains five integers t, sx, sy, ex, ey (1 ≤ t ≤ 105, - 109 ≤ sx, sy, ex, ey ≤ 109). The starting location and the ending location will be different.
The second line contains t characters, the i-th character is the wind blowing direction at the i-th second. It will be one of the four possibilities: "E" (east), "S" (south), "W" (west) and "N" (north).
Output
If they can reach (ex, ey) within t seconds, print the earliest time they can achieve it. Otherwise, print "-1" (without quotes).
Examples
Input
5 0 0 1 1
SESNW
Output
4
Input
10 5 3 3 6
NENSWESNEE
Output
-1
Note
In the first sample, they can stay at seconds 1, 3, and move at seconds 2, 4.
In the second sample, they cannot sail to the destination.
|
#include <bits/stdc++.h>
const int maxn = 100005;
using namespace std;
char c[maxn];
int main() {
int n, x, y, x1, y1, i;
while (scanf("%d", &n) != EOF) {
int flag = 0;
int sum = 0;
scanf("%d%d%d%d", &x, &y, &x1, &y1);
scanf("%s", c);
for (i = 0; c[i] != '\0'; i++) {
if (c[i] == 'E') {
if (x < x1) x += 1;
} else if (c[i] == 'S') {
if (y > y1) y -= 1;
} else if (c[i] == 'W') {
if (x > x1) x -= 1;
} else if (c[i] == 'N') {
if (y < y1) y += 1;
}
sum++;
if (x == x1 && y == y1) {
flag = 1;
break;
}
}
if (flag)
printf("%d\n", sum);
else
printf("-1\n");
}
return 0;
}
|
Kalila and Dimna are two jackals living in a huge jungle. One day they decided to join a logging factory in order to make money.
The manager of logging factory wants them to go to the jungle and cut n trees with heights a1, a2, ..., an. They bought a chain saw from a shop. Each time they use the chain saw on the tree number i, they can decrease the height of this tree by one unit. Each time that Kalila and Dimna use the chain saw, they need to recharge it. Cost of charging depends on the id of the trees which have been cut completely (a tree is cut completely if its height equal to 0). If the maximum id of a tree which has been cut completely is i (the tree that have height ai in the beginning), then the cost of charging the chain saw would be bi. If no tree is cut completely, Kalila and Dimna cannot charge the chain saw. The chainsaw is charged in the beginning. We know that for each i < j, ai < aj and bi > bj and also bn = 0 and a1 = 1. Kalila and Dimna want to cut all the trees completely, with minimum cost.
They want you to help them! Will you?
Input
The first line of input contains an integer n (1 ≤ n ≤ 105). The second line of input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109). The third line of input contains n integers b1, b2, ..., bn (0 ≤ bi ≤ 109).
It's guaranteed that a1 = 1, bn = 0, a1 < a2 < ... < an and b1 > b2 > ... > bn.
Output
The only line of output must contain the minimum cost of cutting all the trees completely.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 4 5
5 4 3 2 0
Output
25
Input
6
1 2 3 10 20 30
6 5 4 3 2 0
Output
138
|
#include <bits/stdc++.h>
using namespace std;
const long long maxL = 20;
long long mod = 1e9 + 7;
long long mod1 = 1e9 + 7;
long long inf = 1e12;
long long linf = 1e18;
const long long maxn = 1e5 + 100;
const long long maxk = 210;
const long long baze = 330;
vector<pair<long long, long long> > vc;
long long n, a[maxn], b[maxn], dp[maxn];
long long saghf(long long x, long long y) {
if (y < 0) y = -y, x = -x;
return (x + y - 1) / y;
}
long long when(long long i, long long j) {
return saghf(dp[i] - dp[j], b[j] - b[i]);
}
void add(long long x) {
while (((long long)((vc).size())) and
when(vc.back().second, x) <= vc.back().first)
vc.pop_back();
if (((long long)((vc).size())))
vc.push_back(pair<long long, long long>(when(vc.back().second, x), x));
else
vc.push_back(pair<long long, long long>(0, x));
}
long long get(long long x) {
return (--lower_bound((vc).begin(), (vc).end(),
pair<long long, long long>(x + 1, 0)))
->second;
}
int32_t main() {
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) cin >> b[i];
add(0);
for (long long i = 1; i < n; i++) {
long long j = get(a[i]);
dp[i] = dp[j] + a[i] * b[j];
add(i);
}
cout << dp[n - 1] << endl;
}
|
Valera loves to participate in competitions. Especially in programming contests. Today he has participated in the contest with his team, consisting of n students (including Valera). This contest was an individual competition, so each student in the team solved problems individually.
After the contest was over, Valera was interested in results. He found out that:
* each student in the team scored at least l points and at most r points;
* in total, all members of the team scored exactly sall points;
* the total score of the k members of the team who scored the most points is equal to exactly sk; more formally, if a1, a2, ..., an is the sequence of points earned by the team of students in the non-increasing order (a1 ≥ a2 ≥ ... ≥ an), then sk = a1 + a2 + ... + ak.
However, Valera did not find out exactly how many points each of n students scored. Valera asked you to recover any distribution of scores between the students of the team, such that all the conditions above are met.
Input
The first line of the input contains exactly six integers n, k, l, r, sall, sk (1 ≤ n, k, l, r ≤ 1000; l ≤ r; k ≤ n; 1 ≤ sk ≤ sall ≤ 106).
It's guaranteed that the input is such that the answer exists.
Output
Print exactly n integers a1, a2, ..., an — the number of points each student scored. If there are multiple solutions, you can print any of them. You can print the distribution of points in any order.
Examples
Input
5 3 1 3 13 9
Output
2 3 2 3 3
Input
5 3 1 3 15 9
Output
3 3 3 3 3
|
import math
scann=input()
numbers=scann.split()
s=int(numbers[0])
s2=int(numbers[1])
min1=int(numbers[2])
max1=int(numbers[3])
total=int(numbers[4])
s2mp=int(numbers[5])
div=int(s2mp/s2)
mod=s2mp%s2
students=[]
for i in range(mod):
students.append(div +1) #intentarlo solo con piso
iter1=s2-mod
for j in range(iter1):
students.append(div)
if(s!=s2):
puntos_rest= total-s2mp;
personas_rest=s-s2;
restante=(int(puntos_rest/personas_rest)) # por si es impar
mod_restante=(int(puntos_rest)% int(personas_rest)) # por si es impar
for i in range(mod_restante):
students.append(restante +1) #intentarlo solo con piso
aux=(s-s2)-mod_restante
for j in range(aux):
students.append(restante)
print(*students)
|
This problem consists of three subproblems: for solving subproblem C1 you will receive 4 points, for solving subproblem C2 you will receive 4 points, and for solving subproblem C3 you will receive 8 points.
Manao decided to pursue a fighter's career. He decided to begin with an ongoing tournament. Before Manao joined, there were n contestants in the tournament, numbered from 1 to n. Each of them had already obtained some amount of tournament points, namely the i-th fighter had pi points.
Manao is going to engage in a single fight against each contestant. Each of Manao's fights ends in either a win or a loss. A win grants Manao one point, and a loss grants Manao's opponent one point. For each i, Manao estimated the amount of effort ei he needs to invest to win against the i-th contestant. Losing a fight costs no effort.
After Manao finishes all of his fights, the ranklist will be determined, with 1 being the best rank and n + 1 being the worst. The contestants will be ranked in descending order of their tournament points. The contestants with the same number of points as Manao will be ranked better than him if they won the match against him and worse otherwise. The exact mechanism of breaking ties for other fighters is not relevant here.
Manao's objective is to have rank k or better. Determine the minimum total amount of effort he needs to invest in order to fulfill this goal, if it is possible.
Input
The first line contains a pair of integers n and k (1 ≤ k ≤ n + 1). The i-th of the following n lines contains two integers separated by a single space — pi and ei (0 ≤ pi, ei ≤ 200000).
The problem consists of three subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem C1 (4 points), the constraint 1 ≤ n ≤ 15 will hold.
* In subproblem C2 (4 points), the constraint 1 ≤ n ≤ 100 will hold.
* In subproblem C3 (8 points), the constraint 1 ≤ n ≤ 200000 will hold.
Output
Print a single number in a single line — the minimum amount of effort Manao needs to use to rank in the top k. If no amount of effort can earn Manao such a rank, output number -1.
Examples
Input
3 2
1 1
1 4
2 2
Output
3
Input
2 1
3 2
4 0
Output
-1
Input
5 2
2 10
2 10
1 1
3 1
3 1
Output
12
Note
Consider the first test case. At the time when Manao joins the tournament, there are three fighters. The first of them has 1 tournament point and the victory against him requires 1 unit of effort. The second contestant also has 1 tournament point, but Manao needs 4 units of effort to defeat him. The third contestant has 2 points and victory against him costs Manao 2 units of effort. Manao's goal is top be in top 2. The optimal decision is to win against fighters 1 and 3, after which Manao, fighter 2, and fighter 3 will all have 2 points. Manao will rank better than fighter 3 and worse than fighter 2, thus finishing in second place.
Consider the second test case. Even if Manao wins against both opponents, he will still rank third.
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1.0e-11;
const double pi = acos(-1.0);
const int INF = 1000000000;
const int N = 110;
vector<pair<int, int> > pe;
int dp[N][N][N];
int n, k;
int solve(int pt) {
if (pt > n) return INF;
for (long long i = 0; i < N; i++)
for (long long j = 0; j < N; j++)
for (long long t = 0; t < N; t++) dp[i][j][t] = INF;
dp[0][0][pe[0].first + 1 < pt] = 0;
dp[0][1][pe[0].first <= pt] = pe[0].second;
for (long long i = 1; i <= n - 1; i++) {
for (long long j = 0; j < n + 1; j++)
for (long long t = 0; t < n + 1; t++) {
dp[i][j + 1][t + (pe[i].first <= pt)] =
min(dp[i][j + 1][t + (pe[i].first <= pt)],
dp[i - 1][j][t] + pe[i].second);
dp[i][j][t + (pe[i].first + 1 < pt)] =
min(dp[i][j][t + (pe[i].first + 1 < pt)], dp[i - 1][j][t]);
}
}
int need = n + 1 - k;
int res = INF;
for (long long pos = need; pos <= n; pos++)
res = min(res, dp[n - 1][pt][pos]);
return res;
}
int main() {
cin >> n >> k;
pe.resize(n);
for (long long i = 0; i < n; i++) {
cin >> pe[i].first >> pe[i].second;
}
if (k == n + 1) {
cout << "0\n";
return 0;
}
sort((pe).begin(), (pe).end());
reverse((pe).begin(), (pe).end());
int res = INF;
for (long long pt = pe[k - 1].first; pt <= pe[k - 1].first + 2; pt++)
res = min(res, solve(pt));
if (res == INF)
cout << "-1\n";
else
cout << res << endl;
return 0;
}
|
The R2 company has n employees working for it. The work involves constant exchange of ideas, sharing the stories of success and upcoming challenging. For that, R2 uses a famous instant messaging program Spyke.
R2 has m Spyke chats just to discuss all sorts of issues. In each chat, some group of employees exchanges messages daily. An employee can simultaneously talk in multiple chats. If some employee is in the k-th chat, he can write messages to this chat and receive notifications about messages from this chat. If an employee writes a message in the chat, all other participants of the chat receive a message notification.
The R2 company is conducting an audit. Now the specialists study effective communication between the employees. For this purpose, they have a chat log and the description of chat structure. You, as one of audit specialists, are commissioned to write a program that will use this data to determine the total number of message notifications received by each employee.
Input
The first line contains three space-separated integers n, m and k (2 ≤ n ≤ 2·104; 1 ≤ m ≤ 10; 1 ≤ k ≤ 2·105) — the number of the employees, the number of chats and the number of events in the log, correspondingly.
Next n lines contain matrix a of size n × m, consisting of numbers zero and one. The element of this matrix, recorded in the j-th column of the i-th line, (let's denote it as aij) equals 1, if the i-th employee is the participant of the j-th chat, otherwise the element equals 0. Assume that the employees are numbered from 1 to n and the chats are numbered from 1 to m.
Next k lines contain the description of the log events. The i-th line contains two space-separated integers xi and yi (1 ≤ xi ≤ n; 1 ≤ yi ≤ m) which mean that the employee number xi sent one message to chat number yi. It is guaranteed that employee number xi is a participant of chat yi. It is guaranteed that each chat contains at least two employees.
Output
Print in the single line n space-separated integers, where the i-th integer shows the number of message notifications the i-th employee receives.
Examples
Input
3 4 5
1 1 1 1
1 0 1 1
1 1 0 0
1 1
3 1
1 3
2 4
3 2
Output
3 3 1
Input
4 3 4
0 1 1
1 0 1
1 1 1
0 0 0
1 2
2 1
3 1
1 3
Output
0 2 3 0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[20010][12];
int per[20010], chat[12];
int i, n, m, k, j, c, p;
cin >> n >> m >> k;
memset(per, 0, sizeof(per));
memset(chat, 0, sizeof(chat));
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j) cin >> a[i][j];
for (i = 1; i <= k; ++i) {
cin >> p >> c;
chat[c]++;
per[p]--;
}
for (i = 1; i <= n; ++i) {
for (j = 1; j <= m; ++j)
if (a[i][j]) per[i] += chat[j];
cout << per[i] << ' ';
}
cout << endl;
return 0;
}
|
The territory of Berland is represented by a rectangular field n × m in size. The king of Berland lives in the capital, located on the upper left square (1, 1). The lower right square has coordinates (n, m). One day the king decided to travel through the whole country and return back to the capital, having visited every square (except the capital) exactly one time. The king must visit the capital exactly two times, at the very beginning and at the very end of his journey. The king can only move to the side-neighboring squares. However, the royal advise said that the King possibly will not be able to do it. But there is a way out — one can build the system of one way teleporters between some squares so that the king could fulfill his plan. No more than one teleporter can be installed on one square, every teleporter can be used any number of times, however every time it is used, it transports to the same given for any single teleporter square. When the king reaches a square with an installed teleporter he chooses himself whether he is or is not going to use the teleport. What minimum number of teleporters should be installed for the king to complete the journey? You should also compose the journey path route for the king.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 100, 2 ≤ n · m) — the field size. The upper left square has coordinates (1, 1), and the lower right square has coordinates of (n, m).
Output
On the first line output integer k — the minimum number of teleporters. Then output k lines each containing 4 integers x1 y1 x2 y2 (1 ≤ x1, x2 ≤ n, 1 ≤ y1, y2 ≤ m) — the coordinates of the square where the teleporter is installed (x1, y1), and the coordinates of the square where the teleporter leads (x2, y2).
Then print nm + 1 lines containing 2 numbers each — the coordinates of the squares in the order in which they are visited by the king. The travel path must start and end at (1, 1). The king can move to side-neighboring squares and to the squares where a teleporter leads. Besides, he also should visit the capital exactly two times and he should visit other squares exactly one time.
Examples
Input
2 2
Output
0
1 1
1 2
2 2
2 1
1 1
Input
3 3
Output
1
3 3 1 1
1 1
1 2
1 3
2 3
2 2
2 1
3 1
3 2
3 3
1 1
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
if (n == 1 && m == 2) {
cout << 0 << "\n"
<< 1 << ' ' << 1 << "\n"
<< 1 << ' ' << 2 << "\n"
<< 1 << " " << 1;
} else if (n == 2 && m == 1) {
cout << 0 << "\n"
<< 1 << ' ' << 1 << "\n"
<< 2 << ' ' << 1 << "\n"
<< 1 << " " << 1;
} else if (n == 1 && m == 1) {
cout << "0\n";
cout << 1 << ' ' << 1 << "\n";
cout << 1 << ' ' << 1;
} else if (n == 1) {
cout << "1\n" << n << ' ' << m << ' ' << 1 << ' ' << 1 << "\n";
for (int i = 1; i <= m; ++i) cout << 1 << ' ' << i << "\n";
cout << 1 << ' ' << 1;
} else if (m == 1) {
cout << "1\n" << n << ' ' << m << ' ' << 1 << ' ' << 1 << "\n";
for (int i = 1; i <= n; ++i) cout << i << ' ' << 1 << "\n";
cout << 1 << ' ' << 1;
} else if (n == 2 && m == 2) {
cout << 0 << "\n";
cout << 1 << ' ' << 1 << "\n";
cout << 1 << ' ' << 2 << "\n";
cout << 2 << ' ' << 2 << "\n";
cout << 2 << ' ' << 1 << "\n";
cout << 1 << ' ' << 1 << "\n";
} else if (n % 2 == 0 && m % 2 == 0) {
cout << 0 << "\n";
cout << 1 << ' ' << 1 << endl;
int i = 1, j = 2, uk = 1;
while (i < n) {
if (j > m) {
j = m;
++i;
uk = -1;
}
if (j == 1) {
j = 2;
++i;
uk = 1;
}
cout << i << ' ' << j << "\n";
j += uk;
}
for (int i = m - 1; i > 1; --i) cout << n << ' ' << i << endl;
for (int i = n; i > 0; --i) cout << i << ' ' << 1 << "\n";
} else if (n % 2 != 0 && m % 2 != 0) {
cout << 1 << "\n";
cout << n << ' ' << m << ' ' << 1 << ' ' << 1 << "\n";
int i = 1, j = 1, uk = 1;
while (i != n || j != m) {
if (j > m) {
j = m;
++i;
uk = -1;
}
if (j == 0) {
j = 1;
++i;
uk = 1;
}
cout << i << ' ' << j << "\n";
j += uk;
}
cout << n << ' ' << m << "\n" << 1 << ' ' << 1;
} else if (n % 2 == 0) {
cout << 0 << "\n";
for (int i = 1; i <= m; ++i) cout << 1 << ' ' << i << "\n";
int i = 2, j = m, uk = -1;
while (i <= n) {
if (j > m) {
j = m;
++i;
uk = -1;
}
if (j == 1) {
j = 2;
++i;
uk = 1;
}
if (0 < i && i <= n && 0 < j && j <= m) cout << i << ' ' << j << "\n";
j += uk;
}
for (int i = n; i > 0; --i) cout << i << ' ' << 1 << "\n";
} else if (m % 2 == 0) {
cout << "0\n";
for (int i = 1; i <= m; ++i) cout << 1 << ' ' << i << "\n";
int i = 2, j = m, uk = 1;
while (i != 1 || j != 1) {
if (i > n) {
i = n;
--j;
uk = -1;
}
if (i == 1) {
i = 2;
--j;
uk = 1;
}
if (0 < i && i <= n && 0 < j && j <= m) cout << i << ' ' << j << "\n";
i += uk;
}
cout << 1 << ' ' << 1;
}
return 0;
}
|
Toastman came up with a very easy task. He gives it to Appleman, but Appleman doesn't know how to solve it. Can you help him?
Given a n × n checkerboard. Each cell of the board has either character 'x', or character 'o'. Is it true that each cell of the board has even number of adjacent cells with 'o'? Two cells of the board are adjacent if they share a side.
Input
The first line contains an integer n (1 ≤ n ≤ 100). Then n lines follow containing the description of the checkerboard. Each of them contains n characters (either 'x' or 'o') without spaces.
Output
Print "YES" or "NO" (without the quotes) depending on the answer to the problem.
Examples
Input
3
xxo
xox
oxx
Output
YES
Input
4
xxxo
xoxo
oxox
xxxx
Output
NO
|
n = int(raw_input())
a = []
for i in range(0,n+2):
a.append([]);
if i==0 or i==n+1:
for j in range(0, n+2):
a[i].append(0)
if i!=0 and i!=n+1:
line = raw_input()
a[i].append(0)
for c in line:
if c == 'x':
a[i].append(0)
else:
a[i].append(1)
a[i].append(0)
c = 0
for i in range (1,n+1):
for j in range(1,n+1):
k = 0
k += a[i][j-1] + a[i][j+1] + a[i-1][j] + a[i+1][j]
if k%2 != 0:
c = 1
if c==0:
print "YES"
else:
print "NO"
|
How many specific orders do you know? Ascending order, descending order, order of ascending length, order of ascending polar angle... Let's have a look at another specific order: d-sorting. This sorting is applied to the strings of length at least d, where d is some positive integer. The characters of the string are sorted in following manner: first come all the 0-th characters of the initial string, then the 1-st ones, then the 2-nd ones and so on, in the end go all the (d - 1)-th characters of the initial string. By the i-th characters we mean all the character whose positions are exactly i modulo d. If two characters stand on the positions with the same remainder of integer division by d, their relative order after the sorting shouldn't be changed. The string is zero-indexed. For example, for string 'qwerty':
Its 1-sorting is the string 'qwerty' (all characters stand on 0 positions),
Its 2-sorting is the string 'qetwry' (characters 'q', 'e' and 't' stand on 0 positions and characters 'w', 'r' and 'y' are on 1 positions),
Its 3-sorting is the string 'qrwtey' (characters 'q' and 'r' stand on 0 positions, characters 'w' and 't' stand on 1 positions and characters 'e' and 'y' stand on 2 positions),
Its 4-sorting is the string 'qtwyer',
Its 5-sorting is the string 'qywert'.
You are given string S of length n and m shuffling operations of this string. Each shuffling operation accepts two integer arguments k and d and transforms string S as follows. For each i from 0 to n - k in the increasing order we apply the operation of d-sorting to the substring S[i..i + k - 1]. Here S[a..b] represents a substring that consists of characters on positions from a to b inclusive.
After each shuffling operation you need to print string S.
Input
The first line of the input contains a non-empty string S of length n, consisting of lowercase and uppercase English letters and digits from 0 to 9.
The second line of the input contains integer m – the number of shuffling operations (1 ≤ m·n ≤ 106).
Following m lines contain the descriptions of the operations consisting of two integers k and d (1 ≤ d ≤ k ≤ n).
Output
After each operation print the current state of string S.
Examples
Input
qwerty
3
4 2
6 3
5 2
Output
qertwy
qtewry
qetyrw
Note
Here is detailed explanation of the sample. The first modification is executed with arguments k = 4, d = 2. That means that you need to apply 2-sorting for each substring of length 4 one by one moving from the left to the right. The string will transform in the following manner:
qwerty → qewrty → qerwty → qertwy
Thus, string S equals 'qertwy' at the end of first query.
The second modification is executed with arguments k = 6, d = 3. As a result of this operation the whole string S is replaced by its 3-sorting:
qertwy → qtewry
The third modification is executed with arguments k = 5, d = 2.
qtewry → qertwy → qetyrw
|
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Set;
import java.util.SortedSet;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;
public class Main
{
/********************************************** a list of common variables **********************************************/
private MyScanner scan = new MyScanner();
private PrintWriter out = new PrintWriter(System.out);
private final double PI = Math.acos(-1.0);
private final int SIZEN = (int)(1e5);
private final int MOD = (int)(1e9 + 7);
private final long MODH = 10000000007L, BASE = 10007;
private final int[] DX = {0, 1, 0, -1}, DY = {-1, 0, 1, 0};
private ArrayList<Integer>[] edge;
public void foo()
{
char[] s = scan.next().toCharArray();
int n = s.length;
int m = scan.nextInt();
int[] p = new int[n];
int[] ans = new int[n];
int[] tmp = new int[n];
char[] t = new char[n];
while(m-- > 0)
{
int k = scan.nextInt();
int d = scan.nextInt();
for(int i = 0;i < n;++i)
{
p[i] = i;
ans[i] = i;
}
int index = 0;
for(int i = 0;i < d;++i)
{
for(int j = i;j < k;j += d)
{
p[index++] = j;
}
}
int first = p[0];
for(int i = 0;i < n - 1;++i)
{
p[i] = p[i + 1];
}
p[n - 1] = first;
int x = n - k + 1;
while(x > 0)
{
if(1 == x % 2)
{
for(int i = 0;i < n;++i)
{
tmp[i] = ans[p[i]];
}
System.arraycopy(tmp, 0, ans, 0, n);
}
for(int i = 0;i < n;++i)
{
tmp[i] = p[p[i]];
}
System.arraycopy(tmp, 0, p, 0, n);
x >>= 1;
}
for(int i = 0;i < n;++i)
{
t[i] = s[ans[(i + k - 1) % n]];
}
System.arraycopy(t, 0, s, 0, n);
out.println(s);
}
}
public static void main(String[] args)
{
Main m = new Main();
m.foo();
m.out.close();
}
/********************************************** a list of common algorithms **********************************************/
/**
* 1---Get greatest common divisor
* @param a : first number
* @param b : second number
* @return greatest common divisor
*/
public long gcd(long a, long b)
{
return 0 == b ? a : gcd(b, a % b);
}
/**
* 2---Get the distance from a point to a line
* @param x1 the x coordinate of one endpoint of the line
* @param y1 the y coordinate of one endpoint of the line
* @param x2 the x coordinate of the other endpoint of the line
* @param y2 the y coordinate of the other endpoint of the line
* @param x the x coordinate of the point
* @param y the x coordinate of the point
* @return the distance from a point to a line
*/
public double getDist(long x1, long y1, long x2, long y2, long x, long y)
{
long a = y2 - y1;
long b = x1 - x2;
long c = y1 * (x2 - x1) - x1 * (y2 - y1);
return Math.abs(a * x + b * y + c) / Math.sqrt(a * a + b * b);
}
/**
* 3---Get the distance from one point to a segment (not a line)
* @param x1 the x coordinate of one endpoint of the segment
* @param y1 the y coordinate of one endpoint of the segment
* @param x2 the x coordinate of the other endpoint of the segment
* @param y2 the y coordinate of the other endpoint of the segment
* @param x the x coordinate of the point
* @param y the y coordinate of the point
* @return the distance from one point to a segment (not a line)
*/
public double ptToSeg(long x1, long y1, long x2, long y2, long x, long y)
{
double cross = (x2 - x1) * (x - x1) + (y2 - y1) * (y - y1);
if(cross <= 0)
{
return (x - x1) * (x - x1) + (y - y1) * (y - y1);
}
double d = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
if(cross >= d)
{
return (x - x2) * (x - x2) + (y - y2) * (y - y2);
}
double r = cross / d;
double px = x1 + (x2 - x1) * r;
double py = y1 + (y2 - y1) * r;
return (x - px) * (x - px) + (y - py) * (y - py);
}
/**
* 4---KMP match, i.e. kmpMatch("abcd", "bcd") = 1, kmpMatch("abcd", "bfcd") = -1.
* @param t: String to match.
* @param p: String to be matched.
* @return if can match, first index; otherwise -1.
*/
public int kmpMatch(char[] t, char[] p)
{
int n = t.length;
int m = p.length;
int[] next = new int[m + 1];
next[0] = -1;
int j = -1;
for(int i = 1;i < m;++i)
{
while(j >= 0 && p[i] != p[j + 1])
{
j = next[j];
}
if(p[i] == p[j + 1])
{
++j;
}
next[i] = j;
}
j = -1;
for(int i = 0;i < n;++i)
{
while(j >= 0 && t[i] != p[j + 1])
{
j = next[j];
}
if(t[i] == p[j + 1])
{
++j;
}
if(j == m - 1)
{
return i - m + 1;
}
}
return -1;
}
/**
* 5---Get the hash code of a String
* @param s: input string
* @return hash code
*/
public long hash(String s)
{
long key = 0, t = 1;
for(int i = 0;i < s.length();++i)
{
key = (key + s.charAt(i) * t) % MODH;
t = t * BASE % MODH;
}
return key;
}
/**
* 6---Get x ^ n % MOD quickly.
* @param x: base
* @param n: times
* @return x ^ n % MOD
*/
public long quickMod(long x, long n)
{
long ans = 1;
while(n > 0)
{
if(1 == n % 2)
{
ans = ans * x % MOD;
}
x = x * x % MOD;
n >>= 1;
}
return ans;
}
class MyScanner
{
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
BufferedInputStream bis = new BufferedInputStream(System.in);
public int read()
{
if (-1 == numChars)
{
throw new InputMismatchException();
}
if (curChar >= numChars)
{
curChar = 0;
try
{
numChars = bis.read(buf);
}
catch (IOException e)
{
throw new InputMismatchException();
}
if (numChars <= 0)
{
return -1;
}
}
return buf[curChar++];
}
public int nextInt()
{
int c = read();
while (isSpaceChar(c))
{
c = read();
}
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = read();
}
int res = 0;
do
{
if (c < '0' || c > '9')
{
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong()
{
int c = read();
while (isSpaceChar(c))
{
c = read();
}
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = read();
}
long 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 double nextDouble()
{
int c = read();
while (isSpaceChar(c))
{
c = read();
}
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = read();
}
double res = 0;
while (!isSpaceChar(c) && c != '.')
{
if (c == 'e' || c == 'E')
{
return res * Math.pow(10, nextInt());
}
if (c < '0' || c > '9')
{
throw new InputMismatchException();
}
res *= 10;
res += c & 15;
c = read();
}
if (c == '.')
{
c = read();
double m = 1;
while (!isSpaceChar(c))
{
if (c == 'e' || c == 'E')
{
return res * Math.pow(10, nextInt());
}
if (c < '0' || c > '9')
{
throw new InputMismatchException();
}
m /= 10;
res += (c & 15) * m;
c = read();
}
}
return res * sgn;
}
public String next()
{
int c = read();
while (isSpaceChar(c))
{
c = read();
}
StringBuilder res = new StringBuilder();
do
{
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
private boolean isSpaceChar(int c)
{
return ' ' == c || '\n' == c || '\r' == c || '\t' == c || -1 == c;
}
}
}
|
When Sasha was studying in the seventh grade, he started listening to music a lot. In order to evaluate which songs he likes more, he introduced the notion of the song's prettiness. The title of the song is a word consisting of uppercase Latin letters. The prettiness of the song is the prettiness of its title.
Let's define the simple prettiness of a word as the ratio of the number of vowels in the word to the number of all letters in the word.
Let's define the prettiness of a word as the sum of simple prettiness of all the substrings of the word.
More formally, let's define the function vowel(c) which is equal to 1, if c is a vowel, and to 0 otherwise. Let si be the i-th character of string s, and si..j be the substring of word s, staring at the i-th character and ending at the j-th character (sisi + 1... sj, i ≤ j).
Then the simple prettiness of s is defined by the formula:
<image>
The prettiness of s equals
<image>
Find the prettiness of the given song title.
We assume that the vowels are I, E, A, O, U, Y.
Input
The input contains a single string s (1 ≤ |s| ≤ 5·105) — the title of the song.
Output
Print the prettiness of the song with the absolute or relative error of at most 10 - 6.
Examples
Input
IEAIAIO
Output
28.0000000
Input
BYOB
Output
5.8333333
Input
YISVOWEL
Output
17.0500000
Note
In the first sample all letters are vowels. The simple prettiness of each substring is 1. The word of length 7 has 28 substrings. So, the prettiness of the song equals to 28.
|
#include <bits/stdc++.h>
using namespace std;
string s;
long long int cnt[500005];
double avg = 0.0;
bool check(char c) {
if (c == 'I' || c == 'E' || c == 'A' || c == 'O' || c == 'U' || c == 'Y')
return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> s;
int n = int((s).length());
s = "#" + s;
for (int i = 1; i <= n; i++) {
cnt[i] = cnt[i - 1];
if (check(s[i])) cnt[i]++;
}
long long int cur = cnt[n];
avg = 0.0;
for (int m = int(1); m <= int(n); ++m) {
avg += cur / (m + 0.0);
if (m > n - m + 1) {
cur -= cnt[m] - cnt[n - m];
} else {
cur += cnt[n - m] - cnt[m];
}
}
printf("%.9f\n", avg);
return 0;
}
|
An exam for n students will take place in a long and narrow room, so the students will sit in a line in some order. The teacher suspects that students with adjacent numbers (i and i + 1) always studied side by side and became friends and if they take an exam sitting next to each other, they will help each other for sure.
Your task is to choose the maximum number of students and make such an arrangement of students in the room that no two students with adjacent numbers sit side by side.
Input
A single line contains integer n (1 ≤ n ≤ 5000) — the number of students at an exam.
Output
In the first line print integer k — the maximum number of students who can be seated so that no two students with adjacent numbers sit next to each other.
In the second line print k distinct integers a1, a2, ..., ak (1 ≤ ai ≤ n), where ai is the number of the student on the i-th position. The students on adjacent positions mustn't have adjacent numbers. Formally, the following should be true: |ai - ai + 1| ≠ 1 for all i from 1 to k - 1.
If there are several possible answers, output any of them.
Examples
Input
6
Output
6
1 5 3 6 2 4
Input
3
Output
2
1 3
|
n = int(input())
if n ==1:
print(1)
print(1)
else:
odd = [int(k) for k in range(n+1) if k % 2 != 0]
odd.reverse()
even = [int(k) for k in range(1,n+1) if k % 2 == 0]
even.reverse()
odd_len = len(odd)
#even.reverse()
if abs(odd[odd_len-1]-even[0]) == 1:
even = even[1:]
num = odd + even
print(len(num))
num =[str(k) for k in num]
print(" ".join(num))
|
Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to <image>. Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it.
He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.
Input
The first and the single line of the input contains 6 space-separated integers a1, a2, a3, a4, a5 and a6 (1 ≤ ai ≤ 1000) — the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.
Output
Print a single integer — the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.
Examples
Input
1 1 1 1 1 1
Output
6
Input
1 2 1 2 1 2
Output
13
Note
This is what Gerald's hexagon looks like in the first sample:
<image>
And that's what it looks like in the second sample:
<image>
|
import java.util.*;
public class sd {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
int[] h = new int[6];
for(int i=0;i<6;i++){
h[i] = in.nextInt();
}
int t=0,s=0;
s = h[1] + h[2]-1;
t = h[0] + h[3];
int k = Math.min(h[0], h[3]);
int p = 0,l=0;
if(h[3]>=h[0]){
for(int j=1;j<=Math.min(h[1], h[5]);j++){
t += 2*(k+j);
p = k+j;
s--;
}
for(int j=Math.min(h[1], h[5])+1;j<=Math.max(h[1], h[5]);j++){
t += 2*p;
s--;
}
while(s > 0){
p--;
t += 2*p;
s--;
}
}
else{
for(int j=1;j<=Math.min(h[2], h[4]);j++){
t += 2*(k+j);
p = k+j;
s--;
}
for(int j=Math.min(h[2], h[4])+1;j<=Math.max(h[2], h[4]);j++){
t += 2*(p);
s--;
}
while(s > 0){
p--;
t += 2*p;
s--;
}
}
System.out.println(t);
}
}
|
Dima loves representing an odd number as the sum of multiple primes, and Lisa loves it when there are at most three primes. Help them to represent the given number as the sum of at most than three primes.
More formally, you are given an odd numer n. Find a set of numbers pi (1 ≤ i ≤ k), such that
1. 1 ≤ k ≤ 3
2. pi is a prime
3. <image>
The numbers pi do not necessarily have to be distinct. It is guaranteed that at least one possible solution exists.
Input
The single line contains an odd number n (3 ≤ n < 109).
Output
In the first line print k (1 ≤ k ≤ 3), showing how many numbers are in the representation you found.
In the second line print numbers pi in any order. If there are multiple possible solutions, you can print any of them.
Examples
Input
27
Output
3
5 11 11
Note
A prime is an integer strictly larger than one that is divisible only by one and by itself.
|
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
import java.util.concurrent.ArrayBlockingQueue;
public class Main {
Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
new Main();
}
public Main() {
new D().doIt();
}
class D{
ArrayList<Integer> array = new ArrayList<Integer>();
int MAX = 1000000;
boolean [] isprime = new boolean[MAX + 1];
void eratos(){
Arrays.fill(isprime, true);
isprime[0] = false;
isprime[1] = false;
for(int i = 0; i * i <= MAX; i++){
if(isprime[i]){
array.add(i);
for(int j = i * 2; j <= MAX; j+= i){
isprime[j] = false;
}
}
}
}
boolean is_prime(int n){
int i = 2;
while(i * i <= n){
if(n % i == 0)return false;
i += 1;
}
return true;
}
void doIt(){
int n = sc.nextInt();
eratos();
if(is_prime(n)){
System.out.println(1);
System.out.println(n);
}else{
for(int i = 0;i < array.size();i++){
int n2 = n - array.get(i);
if(n2 < 2)break;
else if(is_prime(n2)){
System.out.println(2);
System.out.println(n2+" "+array.get(i));
System.exit(0);
}
for(int j = 0;j < array.size();j++){
int n3 = n2 - array.get(j);
if(n3 < 2)break;
else if(is_prime(n3)){
System.out.println(3);
System.out.println(n3+" "+array.get(i)+" "+array.get(j));
System.exit(0);
}
}
}
}
}
}
}
|
Student Vladislav came to his programming exam completely unprepared as usual. He got a question about some strange algorithm on a graph — something that will definitely never be useful in real life. He asked a girl sitting next to him to lend him some cheat papers for this questions and found there the following definition:
The minimum spanning tree T of graph G is such a tree that it contains all the vertices of the original graph G, and the sum of the weights of its edges is the minimum possible among all such trees.
Vladislav drew a graph with n vertices and m edges containing no loops and multiple edges. He found one of its minimum spanning trees and then wrote for each edge its weight and whether it is included in the found tree or not. Unfortunately, the piece of paper where the graph was painted is gone and the teacher is getting very angry and demands to see the original graph. Help Vladislav come up with a graph so that the information about the minimum spanning tree remains correct.
Input
The first line of the input contains two integers n and m (<image>) — the number of vertices and the number of edges in the graph.
Each of the next m lines describes an edge of the graph and consists of two integers aj and bj (1 ≤ aj ≤ 109, bj = {0, 1}). The first of these numbers is the weight of the edge and the second number is equal to 1 if this edge was included in the minimum spanning tree found by Vladislav, or 0 if it was not.
It is guaranteed that exactly n - 1 number {bj} are equal to one and exactly m - n + 1 of them are equal to zero.
Output
If Vladislav has made a mistake and such graph doesn't exist, print - 1.
Otherwise print m lines. On the j-th line print a pair of vertices (uj, vj) (1 ≤ uj, vj ≤ n, uj ≠ vj), that should be connected by the j-th edge. The edges are numbered in the same order as in the input. The graph, determined by these edges, must be connected, contain no loops or multiple edges and its edges with bj = 1 must define the minimum spanning tree. In case there are multiple possible solutions, print any of them.
Examples
Input
4 5
2 1
3 1
4 0
1 1
5 0
Output
2 4
1 4
3 4
3 1
3 2
Input
3 3
1 0
2 1
3 1
Output
-1
|
#include <bits/stdc++.h>
using namespace std;
const int MAXn = 100 * 1000;
pair<pair<int, int>, int> w[MAXn + 5];
pair<int, int> ans[MAXn + 5];
int last[MAXn + 5];
bool cmp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
if (a.first.first < b.first.first)
return true;
else if (a.first.first == b.first.first && a.first.second > b.first.second)
return true;
return false;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &w[i].first.first, &w[i].first.second);
w[i].second = i + 1;
}
sort(w, w + m, cmp);
int size = 0;
bool poss = true;
for (int i = 0; i < n; i++) last[i] = -1;
for (int i = 0; i < m && poss; i++) {
if (w[i].first.second) {
ans[w[i].second] = make_pair(size + 1, size + 2);
size++;
} else {
poss = false;
for (int j = 0; j <= size && !poss; j++)
for (int k = last[j] + 1; k <= size && !poss; k++)
if (j != k && j + 1 != k && j - 1 != k) {
ans[w[i].second] = make_pair(j + 1, k + 1);
last[j] = k;
last[k] = j;
poss = true;
}
}
}
if (!poss)
cout << -1 << endl;
else
for (int i = 1; i <= m; i++) printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
|
Consider the decimal presentation of an integer. Let's call a number d-magic if digit d appears in decimal presentation of the number on even positions and nowhere else.
For example, the numbers 1727374, 17, 1 are 7-magic but 77, 7, 123, 34, 71 are not 7-magic. On the other hand the number 7 is 0-magic, 123 is 2-magic, 34 is 4-magic and 71 is 1-magic.
Find the number of d-magic numbers in the segment [a, b] that are multiple of m. Because the answer can be very huge you should only find its value modulo 109 + 7 (so you should find the remainder after dividing by 109 + 7).
Input
The first line contains two integers m, d (1 ≤ m ≤ 2000, 0 ≤ d ≤ 9) — the parameters from the problem statement.
The second line contains positive integer a in decimal presentation (without leading zeroes).
The third line contains positive integer b in decimal presentation (without leading zeroes).
It is guaranteed that a ≤ b, the number of digits in a and b are the same and don't exceed 2000.
Output
Print the only integer a — the remainder after dividing by 109 + 7 of the number of d-magic numbers in segment [a, b] that are multiple of m.
Examples
Input
2 6
10
99
Output
8
Input
2 0
1
9
Output
4
Input
19 7
1000
9999
Output
6
Note
The numbers from the answer of the first example are 16, 26, 36, 46, 56, 76, 86 and 96.
The numbers from the answer of the second example are 2, 4, 6 and 8.
The numbers from the answer of the third example are 1767, 2717, 5757, 6707, 8797 and 9747.
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(int a) {
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(int a) {
if (a < 0) {
a = -a;
putchar('-');
}
write(a);
puts("");
}
const int N = 2005, mod = 1000000007;
string a, b, quan;
int dp[N][N][2][2], d, m;
int dfs(int pos, int yu, bool flag, bool fff, bool fla) {
if (pos < 0) return yu == 0;
if (!flag && dp[pos][yu][fff][fla] != -1) return dp[pos][yu][fff][fla];
int meiju = flag ? quan[quan.length() - pos - 1] - '0' : 9, ans = 0;
if (!fla) {
for (int i = 0; i <= meiju; i++)
if (i != d || (d == 0 && !fff)) {
ans = (ans + dfs(pos - 1, (yu * 10 + i) % m, flag && i == meiju,
fff || i, (fla ^ 1) && (fff || i))) %
mod;
}
if (!flag) dp[pos][yu][fff][fla] = ans;
return ans;
} else {
for (int i = 0; i <= meiju; i++)
if (i == d) {
ans = (ans + dfs(pos - 1, (yu * 10 + i) % m, flag && i == meiju,
fff || i, (fla ^ 1) && (fff || i))) %
mod;
}
if (!flag) dp[pos][yu][fff][fla] = ans;
return ans;
}
}
int calc(string x) {
quan = x;
memset(dp, -1, sizeof(dp));
return dfs(x.length() - 1, 0, 1, 0, 0);
}
int main() {
m = read();
d = read();
cin >> a >> b;
for (int i = a.length() - 1;; i--) {
if (a[i] == '0')
a[i] = '9';
else {
a[i]--;
break;
}
}
if (a[0] == '0' && a.length() > 1) a.erase(a.begin());
cout << (calc(b) - calc(a) + mod) % mod << endl;
}
|
Johnny is playing a well-known computer game. The game are in some country, where the player can freely travel, pass quests and gain an experience.
In that country there are n islands and m bridges between them, so you can travel from any island to any other. In the middle of some bridges are lying ancient powerful artifacts. Johnny is not interested in artifacts, but he can get some money by selling some artifact.
At the start Johnny is in the island a and the artifact-dealer is in the island b (possibly they are on the same island). Johnny wants to find some artifact, come to the dealer and sell it. The only difficulty is that bridges are too old and destroying right after passing over them. Johnnie's character can't swim, fly and teleport, so the problem became too difficult.
Note that Johnny can't pass the half of the bridge, collect the artifact and return to the same island.
Determine if Johnny can find some artifact and sell it.
Input
The first line contains two integers n and m (1 ≤ n ≤ 3·105, 0 ≤ m ≤ 3·105) — the number of islands and bridges in the game.
Each of the next m lines contains the description of the bridge — three integers xi, yi, zi (1 ≤ xi, yi ≤ n, xi ≠ yi, 0 ≤ zi ≤ 1), where xi and yi are the islands connected by the i-th bridge, zi equals to one if that bridge contains an artifact and to zero otherwise. There are no more than one bridge between any pair of islands. It is guaranteed that it's possible to travel between any pair of islands.
The last line contains two integers a and b (1 ≤ a, b ≤ n) — the islands where are Johnny and the artifact-dealer respectively.
Output
If Johnny can find some artifact and sell it print the only word "YES" (without quotes). Otherwise print the word "NO" (without quotes).
Examples
Input
6 7
1 2 0
2 3 0
3 1 0
3 4 1
4 5 0
5 6 0
6 4 0
1 6
Output
YES
Input
5 4
1 2 0
2 3 0
3 4 0
2 5 1
1 4
Output
NO
Input
5 6
1 2 0
2 3 0
3 1 0
3 4 0
4 5 1
5 3 0
1 2
Output
YES
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int MOD = 1e9 + 7;
const int N = 3e5 + 10;
int n, m, st, en, w[N], v[N][2];
vector<int> e[N];
vector<pair<int, int> > v2[N];
int low[N], num[N], t[N], br[N];
queue<int> q;
int good[N], t2[N];
void prepare() {
scanf("%d%d", &n, &m);
int x, y;
for (auto i = (1); i <= (m); i++) {
scanf("%d%d%d", &x, &y, w + i);
e[x].push_back(i);
e[y].push_back(i);
v[i][0] = x;
v[i][1] = y;
}
scanf("%d%d", &st, &en);
}
void DFS(int x, int le) {
static int top = 0;
low[x] = num[x] = ++top;
for (auto i : e[x])
if (i != le) {
int y = v[i][0] + v[i][1] - x;
if (!num[y]) {
t[y] = i;
DFS(y, i);
}
low[x] = min(low[x], low[y]);
}
}
void BFS(int st) {
static int n1 = 0;
num[st] = ++n1;
q.push(st);
while (!q.empty()) {
int x = q.front();
q.pop();
for (auto i : e[x])
if (!br[i]) {
int y = v[i][0] + v[i][1] - x;
if (w[i]) good[n1] = 1;
if (!num[y]) {
num[y] = n1;
q.push(y);
}
}
}
}
int solve() {
DFS(st, 0);
for (auto i = (1); i <= (n); i++)
if (low[i] >= num[i]) br[t[i]] = 1;
memset(num, 0, sizeof(num));
for (auto i = (1); i <= (n); i++)
if (!num[i]) BFS(i);
for (auto i = (1); i <= (m); i++)
if (br[i]) {
int x = num[v[i][0]], y = num[v[i][1]];
v2[x].push_back(pair<int, int>(y, w[i]));
v2[y].push_back(pair<int, int>(x, w[i]));
}
st = num[st], en = num[en];
q.push(st);
memset(t2, -1, sizeof(t2));
t2[st] = good[st];
while (!q.empty()) {
int x = q.front();
q.pop();
for (auto i : v2[x])
if (t2[i.first] == -1) {
t2[i.first] = t2[x] | i.second | good[i.first];
q.push(i.first);
}
}
return t2[en];
}
int main() {
prepare();
if (solve())
cout << "YES";
else
cout << "NO";
}
|
Little Joty has got a task to do. She has a line of n tiles indexed from 1 to n. She has to paint them in a strange pattern.
An unpainted tile should be painted Red if it's index is divisible by a and an unpainted tile should be painted Blue if it's index is divisible by b. So the tile with the number divisible by a and b can be either painted Red or Blue.
After her painting is done, she will get p chocolates for each tile that is painted Red and q chocolates for each tile that is painted Blue.
Note that she can paint tiles in any order she wants.
Given the required information, find the maximum number of chocolates Joty can get.
Input
The only line contains five integers n, a, b, p and q (1 ≤ n, a, b, p, q ≤ 109).
Output
Print the only integer s — the maximum number of chocolates Joty can get.
Note that the answer can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
5 2 3 12 15
Output
39
Input
20 2 3 3 5
Output
51
|
import math
n, red, blue, red_cost, blue_cost = map(int, input().split())
reds = n//red - n//((red*blue)//math.gcd(red,blue))
blues = n//blue - n//((red*blue)//math.gcd(red,blue))
ans = reds*red_cost + blues*blue_cost + max(blue_cost, red_cost)*(n//((red*blue)//math.gcd(red,blue)))
print(int(ans))
|
Again, there are hard times in Berland! Many towns have such tensions that even civil war is possible.
There are n towns in Reberland, some pairs of which connected by two-way roads. It is not guaranteed that it is possible to reach one town from any other town using these roads.
Towns s and t announce the final break of any relationship and intend to rule out the possibility of moving between them by the roads. Now possibly it is needed to close several roads so that moving from s to t using roads becomes impossible. Each town agrees to spend money on closing no more than one road, therefore, the total number of closed roads will be no more than two.
Help them find set of no more than two roads such that there will be no way between s and t after closing these roads. For each road the budget required for its closure was estimated. Among all sets find such that the total budget for the closure of a set of roads is minimum.
Input
The first line of the input contains two integers n and m (2 ≤ n ≤ 1000, 0 ≤ m ≤ 30 000) — the number of towns in Berland and the number of roads.
The second line contains integers s and t (1 ≤ s, t ≤ n, s ≠ t) — indices of towns which break up the relationships.
Then follow m lines, each of them contains three integers xi, yi and wi (1 ≤ xi, yi ≤ n, 1 ≤ wi ≤ 109) — indices of towns connected by the i-th road, and the budget on its closure.
All roads are bidirectional. It is allowed that the pair of towns is connected by more than one road. Roads that connect the city to itself are allowed.
Output
In the first line print the minimum budget required to break up the relations between s and t, if it is allowed to close no more than two roads.
In the second line print the value c (0 ≤ c ≤ 2) — the number of roads to be closed in the found solution.
In the third line print in any order c diverse integers from 1 to m — indices of closed roads. Consider that the roads are numbered from 1 to m in the order they appear in the input.
If it is impossible to make towns s and t disconnected by removing no more than 2 roads, the output should contain a single line -1.
If there are several possible answers, you may print any of them.
Examples
Input
6 7
1 6
2 1 6
2 3 5
3 4 9
4 6 4
4 6 5
4 5 1
3 1 3
Output
8
2
2 7
Input
6 7
1 6
2 3 1
1 2 2
1 3 3
4 5 4
3 6 5
4 6 6
1 5 7
Output
9
2
4 5
Input
5 4
1 5
2 1 3
3 2 1
3 4 4
4 5 2
Output
1
1
2
Input
2 3
1 2
1 2 734458840
1 2 817380027
1 2 304764803
Output
-1
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010, M = 30010;
vector<pair<int, int> > g[N];
int cost[M];
int disc[N], low[N];
int p[N];
int n, m;
int s, t;
int asfasdf;
int reach_t[N];
int traversed[M];
const int oo = 0x3f3f3f3f;
int ret;
int retb;
void tarjan(int u, int ign) {
disc[u] = low[u] = asfasdf++;
reach_t[u] = (u == t);
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, e = g[u][i].second;
if (e == ign or v == u or e == p[u]) continue;
if (disc[v] == -1) {
p[v] = e;
traversed[e] = 1;
tarjan(v, ign);
reach_t[u] = reach_t[u] or reach_t[v];
low[u] = min(low[u], low[v]);
} else
low[u] = min(low[u], disc[v]);
if (low[v] > disc[u] and reach_t[v]) {
if (cost[e] < ret) {
ret = cost[e];
retb = e;
}
}
}
}
int main() {
scanf("%d %d %d %d", &n, &m, &s, &t);
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
cost[i] = w;
g[u].push_back(pair<int, int>(v, i));
g[v].push_back(pair<int, int>(u, i));
}
memset(p, -1, sizeof(p));
memset(disc, -1, sizeof(disc));
ret = oo;
retb = -1;
tarjan(s, -2);
vector<int> vt;
for (int i = 0; i < m; i++) {
if (traversed[i]) vt.push_back(i);
}
if (!reach_t[s]) {
printf("0\n0\n");
return 0;
}
int ans = 2 * oo;
vector<int> vans;
if (retb != -1) {
ans = ret;
vans.push_back(retb);
}
for (int i = 0; i < vt.size(); i++) {
memset(p, -1, sizeof(p));
memset(disc, -1, sizeof(disc));
ret = oo;
retb = -1;
int e = vt[i];
tarjan(s, e);
if (retb != -1 and ret + cost[e] < ans) {
ans = ret + cost[e];
vans.clear();
vans.push_back(e);
vans.push_back(retb);
}
}
if (vans.empty()) {
printf("-1\n");
return 0;
}
printf("%d\n%d\n", ans, (int)vans.size());
for (int i = 0; i < vans.size(); i++)
printf("%d%c", vans[i] + 1, " \n"[i == vans.size() - 1]);
return 0;
}
|
Unfortunately, the formal description of the task turned out to be too long, so here is the legend.
Research rover finally reached the surface of Mars and is ready to complete its mission. Unfortunately, due to the mistake in the navigation system design, the rover is located in the wrong place.
The rover will operate on the grid consisting of n rows and m columns. We will define as (r, c) the cell located in the row r and column c. From each cell the rover is able to move to any cell that share a side with the current one.
The rover is currently located at cell (1, 1) and has to move to the cell (n, m). It will randomly follow some shortest path between these two cells. Each possible way is chosen equiprobably.
The cargo section of the rover contains the battery required to conduct the research. Initially, the battery charge is equal to s units of energy.
Some of the cells contain anomaly. Each time the rover gets to the cell with anomaly, the battery looses half of its charge rounded down. Formally, if the charge was equal to x before the rover gets to the cell with anomaly, the charge will change to <image>.
While the rover picks a random shortest path to proceed, compute the expected value of the battery charge after it reaches cell (n, m). If the cells (1, 1) and (n, m) contain anomaly, they also affect the charge of the battery.
Input
The first line of the input contains four integers n, m, k and s (1 ≤ n, m ≤ 100 000, 0 ≤ k ≤ 2000, 1 ≤ s ≤ 1 000 000) — the number of rows and columns of the field, the number of cells with anomaly and the initial charge of the battery respectively.
The follow k lines containing two integers ri and ci (1 ≤ ri ≤ n, 1 ≤ ci ≤ m) — coordinates of the cells, containing anomaly. It's guaranteed that each cell appears in this list no more than once.
Output
The answer can always be represented as an irreducible fraction <image>. Print the only integer P·Q - 1 modulo 109 + 7.
Examples
Input
3 3 2 11
2 1
2 3
Output
333333342
Input
4 5 3 17
1 2
3 3
4 1
Output
514285727
Input
1 6 2 15
1 1
1 5
Output
4
Note
In the first sample, the rover picks one of the following six routes:
1. <image>, after passing cell (2, 3) charge is equal to 6.
2. <image>, after passing cell (2, 3) charge is equal to 6.
3. <image>, charge remains unchanged and equals 11.
4. <image>, after passing cells (2, 1) and (2, 3) charge equals 6 and then 3.
5. <image>, after passing cell (2, 1) charge is equal to 6.
6. <image>, after passing cell (2, 1) charge is equal to 6.
Expected value of the battery charge is calculated by the following formula:
<image>.
Thus P = 19, and Q = 3.
3 - 1 modulo 109 + 7 equals 333333336.
19·333333336 = 333333342 (mod 109 + 7)
|
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
#pragma GCC target("avx,avx2")
using namespace std;
template <class t>
inline t read(t &x) {
char c = getchar();
bool f = 0;
x = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
template <class t, class... A>
inline void read(t &x, A &...a) {
read(x);
read(a...);
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const int mod = 1e9 + 7, N = 2e5 + 5;
pair<int, int> a[N];
int fac[N << 1], inv[N << 1], n, m, nm, ans, s, f[N][23];
int fpow(int first, int second) {
int res = 1;
for (; second; second >>= 1, first = 1ll * first * first % mod)
if (second & 1) res = 1ll * res * first % mod;
return res;
}
int C(int n, int m) { return 1ll * fac[n] * inv[m] % mod * inv[n - m] % mod; }
int calc(int first, int second) {
return C(
a[second].first - a[first].first + a[second].second - a[first].second,
a[second].first - a[first].first);
}
signed main() {
read(n, m, nm, s);
s <<= 1;
fac[0] = 1;
for (int i = 1; i <= n + m; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
inv[n + m] = fpow(fac[n + m], mod - 2);
for (int i = n + m - 1; ~i; i--) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
for (int i = 1; i <= nm; i++) read(a[i].first, a[i].second);
a[++nm] = pair<int, int>(1, 1);
a[++nm] = pair<int, int>(n, m);
sort(a + 1, a + 1 + nm);
f[1][0] = 1;
for (int i = 2; i <= nm; i++) {
f[i][1] = calc(1, i);
for (int j = 2; j < 22; j++)
for (int k = 1; k < i; k++)
if (a[i].second >= a[k].second)
f[i][j] = (f[i][j] +
((1ll * (f[k][j - 1] - f[k][j]) * calc(k, i) % mod + mod) %
mod)) %
mod;
}
for (int i = 1; i < 22; i++) {
s = s + 1 >> 1;
ans = (ans + (1ll * (f[nm][i] - f[nm][i + 1]) * s % mod + mod) % mod) % mod;
}
write(1ll * ans * fpow(calc(1, nm), mod - 2) % mod);
}
|
One day, Hongcow goes to the store and sees a brand new deck of n special cards. Each individual card is either red or blue. He decides he wants to buy them immediately. To do this, he needs to play a game with the owner of the store.
This game takes some number of turns to complete. On a turn, Hongcow may do one of two things:
* Collect tokens. Hongcow collects 1 red token and 1 blue token by choosing this option (thus, 2 tokens in total per one operation).
* Buy a card. Hongcow chooses some card and spends tokens to purchase it as specified below.
The i-th card requires ri red resources and bi blue resources. Suppose Hongcow currently has A red cards and B blue cards. Then, the i-th card will require Hongcow to spend max(ri - A, 0) red tokens, and max(bi - B, 0) blue tokens. Note, only tokens disappear, but the cards stay with Hongcow forever. Each card can be bought only once.
Given a description of the cards and their costs determine the minimum number of turns Hongcow needs to purchase all cards.
Input
The first line of input will contain a single integer n (1 ≤ n ≤ 16).
The next n lines of input will contain three tokens ci, ri and bi. ci will be 'R' or 'B', denoting the color of the card as red or blue. ri will be an integer denoting the amount of red resources required to obtain the card, and bi will be an integer denoting the amount of blue resources required to obtain the card (0 ≤ ri, bi ≤ 107).
Output
Output a single integer, denoting the minimum number of turns needed to acquire all the cards.
Examples
Input
3
R 0 1
B 1 0
R 1 1
Output
4
Input
3
R 3 0
R 2 0
R 1 0
Output
6
Note
For the first sample, Hongcow's four moves are as follows:
1. Collect tokens
2. Buy card 1
3. Buy card 2
4. Buy card 3
Note, at the fourth step, Hongcow is able to buy card 3 because Hongcow already has one red and one blue card, so we don't need to collect tokens.
For the second sample, one optimal strategy is as follows:
1. Collect tokens
2. Collect tokens
3. Buy card 2
4. Collect tokens
5. Buy card 3
6. Buy card 1
At the fifth step, even though Hongcow has a red token, Hongcow doesn't actually need to spend it, since Hongcow has a red card already.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
int N;
cin >> N;
vector<bool> color(N);
vector<int> r(N), b(N);
for (int i = 0; i < N; i++) {
string t;
cin >> t >> r[i] >> b[i];
color[i] = (t == "B");
}
int MSAVE = 0;
for (int i = 0; i < N; i++) MSAVE += i;
vector<vector<int> > dp(1 << N, vector<int>(MSAVE + 1, -1));
dp[0][0] = 0;
for (int m = 0; m < (1 << N); m++) {
int red = 0, blue = 0;
for (int i = 0; i < N; i++) {
if ((m >> i) & 1) {
if (color[i])
blue++;
else
red++;
}
}
for (int rs = 0; rs <= MSAVE; rs++) {
if (dp[m][rs] == -1) continue;
for (int t = 0; t < N; t++) {
if ((m >> t) & 1) continue;
int nrs = rs, nbs = dp[m][rs];
nbs += min(blue, b[t]);
nrs += min(red, r[t]);
int &upd = dp[m ^ (1 << t)][nrs];
upd = max(upd, nbs);
}
}
}
int blue_need = 0, red_need = 0;
for (int c : r) red_need += c;
for (int c : b) blue_need += c;
int ans = max(blue_need, red_need);
int fm = (1 << N) - 1;
for (int rs = 0; rs <= MSAVE; rs++)
if (dp[fm][rs] != -1) {
ans = min(ans, max(blue_need - dp[fm][rs], red_need - rs));
}
cout << ans + N << endl;
return 0;
}
|
Student Arseny likes to plan his life for n days ahead. He visits a canteen every day and he has already decided what he will order in each of the following n days. Prices in the canteen do not change and that means Arseny will spend ci rubles during the i-th day.
There are 1-ruble coins and 100-ruble notes in circulation. At this moment, Arseny has m coins and a sufficiently large amount of notes (you can assume that he has an infinite amount of them). Arseny loves modern technologies, so he uses his credit card everywhere except the canteen, but he has to pay in cash in the canteen because it does not accept cards.
Cashier always asks the student to pay change-free. However, it's not always possible, but Arseny tries to minimize the dissatisfaction of the cashier. Cashier's dissatisfaction for each of the days is determined by the total amount of notes and coins in the change. To be precise, if the cashier gives Arseny x notes and coins on the i-th day, his dissatisfaction for this day equals x·wi. Cashier always gives change using as little coins and notes as possible, he always has enough of them to be able to do this.
<image> "Caution! Angry cashier"
Arseny wants to pay in such a way that the total dissatisfaction of the cashier for n days would be as small as possible. Help him to find out how he needs to pay in each of the n days!
Note that Arseny always has enough money to pay, because he has an infinite amount of notes. Arseny can use notes and coins he received in change during any of the following days.
Input
The first line contains two integers n and m (1 ≤ n ≤ 105, 0 ≤ m ≤ 109) — the amount of days Arseny planned his actions for and the amount of coins he currently has.
The second line contains a sequence of integers c1, c2, ..., cn (1 ≤ ci ≤ 105) — the amounts of money in rubles which Arseny is going to spend for each of the following days.
The third line contains a sequence of integers w1, w2, ..., wn (1 ≤ wi ≤ 105) — the cashier's dissatisfaction coefficients for each of the following days.
Output
In the first line print one integer — minimum possible total dissatisfaction of the cashier.
Then print n lines, the i-th of then should contain two numbers — the amount of notes and the amount of coins which Arseny should use to pay in the canteen on the i-th day.
Of course, the total amount of money Arseny gives to the casher in any of the days should be no less than the amount of money he has planned to spend. It also shouldn't exceed 106 rubles: Arseny never carries large sums of money with him.
If there are multiple answers, print any of them.
Examples
Input
5 42
117 71 150 243 200
1 1 1 1 1
Output
79
1 17
1 0
2 0
2 43
2 0
Input
3 0
100 50 50
1 3 2
Output
150
1 0
1 0
0 50
Input
5 42
117 71 150 243 200
5 4 3 2 1
Output
230
1 17
1 0
1 50
3 0
2 0
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, c[N], w[N];
pair<int, int> ans[N];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> c[i];
for (int i = 0; i < n; i++) cin >> w[i];
set<pair<int, int> > s;
long long res = 0;
for (int i = 0; i < n; i++) {
int C = c[i] % 100, W = w[i];
ans[i].first = c[i] / 100;
ans[i].second = C;
m -= C;
if (C) s.insert(make_pair(W * (100 - C), i));
while (m < 0) {
pair<int, int> p = (*s.begin());
s.erase(p);
int idx = p.second;
m += 100;
res += p.first;
ans[idx].second = 0;
ans[idx].first++;
}
}
cout << res << "\n";
for (int i = 0; i < n; i++)
cout << ans[i].first << " " << ans[i].second << "\n";
}
|
A tree is an undirected connected graph without cycles. The distance between two vertices is the number of edges in a simple path between them.
Limak is a little polar bear. He lives in a tree that consists of n vertices, numbered 1 through n.
Limak recently learned how to jump. He can jump from a vertex to any vertex within distance at most k.
For a pair of vertices (s, t) we define f(s, t) as the minimum number of jumps Limak needs to get from s to t. Your task is to find the sum of f(s, t) over all pairs of vertices (s, t) such that s < t.
Input
The first line of the input contains two integers n and k (2 ≤ n ≤ 200 000, 1 ≤ k ≤ 5) — the number of vertices in the tree and the maximum allowed jump distance respectively.
The next n - 1 lines describe edges in the tree. The i-th of those lines contains two integers ai and bi (1 ≤ ai, bi ≤ n) — the indices on vertices connected with i-th edge.
It's guaranteed that the given edges form a tree.
Output
Print one integer, denoting the sum of f(s, t) over all pairs of vertices (s, t) such that s < t.
Examples
Input
6 2
1 2
1 3
2 4
2 5
4 6
Output
20
Input
13 3
1 2
3 2
4 2
5 2
3 6
10 6
6 7
6 13
5 8
5 9
9 11
11 12
Output
114
Input
3 5
2 1
3 1
Output
3
Note
In the first sample, the given tree has 6 vertices and it's displayed on the drawing below. Limak can jump to any vertex within distance at most 2. For example, from the vertex 5 he can jump to any of vertices: 1, 2 and 4 (well, he can also jump to the vertex 5 itself).
<image>
There are <image> pairs of vertices (s, t) such that s < t. For 5 of those pairs Limak would need two jumps: (1, 6), (3, 4), (3, 5), (3, 6), (5, 6). For other 10 pairs one jump is enough. So, the answer is 5·2 + 10·1 = 20.
In the third sample, Limak can jump between every two vertices directly. There are 3 pairs of vertices (s < t), so the answer is 3·1 = 3.
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.StringTokenizer;
public class C implements Runnable {
List<Integer>[] r;
long[][] down;
int n, k;
long sum;
long[] rem;
long dfs(int q, int p) {
long res = 0;
for (int z : r[q]) {
if (z != p) {
res += dfs(z, q);
for (int i = 0; i < k; i++) down[q][i] += down[z][(i + k - 1) % k];
}
}
res++;
if (p != -1) sum += res * (n - res);
long[] tmp = new long[k];
for (int z : r[q]) {
if (z != p) {
for (int i = 0; i < k; i++) down[q][i] -= down[z][(i + k - 1) % k];
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
tmp[(i + j + 1) % k] += down[q][i] * down[z][j];
}
}
for (int i = 0; i < k; i++) down[q][i] += down[z][(i + k - 1) % k];
}
}
for (int i = 0; i < k; i++) rem[i] += tmp[i] / 2 + down[q][i];
down[q][0]++;
return res;
}
void dfs2(int q, int p, int[] a) {
if (p != -1) {
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
rem[(i + j + 1) % k] += a[i] * down[q][j];
}
}
}
int[] t = new int[k];
for (int i = 0; i < k; i++) t[i] = a[(i + k - 1) % k];
for (int i = 0; i < k; i++) t[i] += down[q][i];
for (int z : r[q]) {
if (z != p) {
for (int i = 0; i < k; i++) t[i] -= down[z][(i + k - 1) % k];
dfs2(z, q, t);
for (int i = 0; i < k; i++) t[i] += down[z][(i + k - 1) % k];
}
}
}
void solve() throws IOException {
n = nextInt();
k = nextInt();
r = new ArrayList[n + 1];
for (int i = 1; i <= n; i++) r[i] = new ArrayList<>();
for (int i = 0; i < n - 1; i++) {
int a = nextInt(), b = nextInt();
r[a].add(b); r[b].add(a);
}
down = new long[n + 1][k];
sum = 0;
rem = new long[k];
dfs(1, -1);
// dfs2(1, -1, new int[k]);
for (int i = 1; i < k; i++) {
sum += rem[i] * (k - i);
}
out.println(sum / k);
}
public static void main(String[] args) {
new Thread(null, new C(), "name", 1 << 27).start();
}
@Override
public void run() {
try {
solve();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
} finally {
out.close();
}
}
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
StringTokenizer st;
String nextToken() throws IOException {
while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(in.readLine());
return st.nextToken();
}
int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
}
|
Sagheer is walking in the street when he comes to an intersection of two roads. Each road can be represented as two parts where each part has 3 lanes getting into the intersection (one for each direction) and 3 lanes getting out of the intersection, so we have 4 parts in total. Each part has 4 lights, one for each lane getting into the intersection (l — left, s — straight, r — right) and a light p for a pedestrian crossing.
<image>
An accident is possible if a car can hit a pedestrian. This can happen if the light of a pedestrian crossing of some part and the light of a lane that can get to or from that same part are green at the same time.
Now, Sagheer is monitoring the configuration of the traffic lights. Your task is to help him detect whether an accident is possible.
Input
The input consists of four lines with each line describing a road part given in a counter-clockwise order.
Each line contains four integers l, s, r, p — for the left, straight, right and pedestrian lights, respectively. The possible values are 0 for red light and 1 for green light.
Output
On a single line, print "YES" if an accident is possible, and "NO" otherwise.
Examples
Input
1 0 0 1
0 1 0 0
0 0 1 0
0 0 0 1
Output
YES
Input
0 1 1 0
1 0 1 0
1 1 0 0
0 0 0 1
Output
NO
Input
1 0 0 0
0 0 0 1
0 0 0 0
1 0 1 0
Output
NO
Note
In the first example, some accidents are possible because cars of part 1 can hit pedestrians of parts 1 and 4. Also, cars of parts 2 and 3 can hit pedestrians of part 4.
In the second example, no car can pass the pedestrian crossing of part 4 which is the only green pedestrian light. So, no accident can occur.
|
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws FileNotFoundException {
ConsoleIO io = new ConsoleIO(new InputStreamReader(System.in), new PrintWriter(System.out));
//String test = "A-large-practice";
//ConsoleIO io = new ConsoleIO(new FileReader("D:\\Dropbox\\code\\practice\\jb\\src\\" + test + ".in"), new PrintWriter(new File("D:\\Dropbox\\code\\practice\\jb\\src\\" + test + "-out.txt")));
new Main(io).solve();
io.close();
}
ConsoleIO io;
Main(ConsoleIO io) {
this.io = io;
}
List<List<Integer>> gr = new ArrayList<>();
long MOD = 1_000_000_007;
int N, K;
public void solve() {
int[] c = new int[4];
for(int i = 0;i<4;i++) {
for (int j = 0; j < 4; j++) {
int v = io.ri();
c[i] |= v << j;
}
}
for(int i = 0;i<4;i++){
if(c[i] >> 3 > 0){
if(c[i]!= 8){
io.writeLine("YES");
return;
}
for(int j = 1;j<4;j++){
int k = (i+j)%4;
if((c[k] & (1<<(j-1))) > 0){
io.writeLine("YES");
return;
}
}
}
}
io.writeLine("NO");
}
}
class ConsoleIO {
BufferedReader br;
PrintWriter out;
public ConsoleIO(Reader reader, PrintWriter writer){br = new BufferedReader(reader);out = writer;}
public void flush(){this.out.flush();}
public void close(){this.out.close();}
public void writeLine(String s) {this.out.println(s);}
public void writeInt(int a) {this.out.print(a);this.out.print(' ');}
public void writeWord(String s){
this.out.print(s);
}
public void writeIntArray(int[] a, int k, String separator) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < k; i++) {
if (i > 0) sb.append(separator);
sb.append(a[i]);
}
this.writeLine(sb.toString());
}
public int read(char[] buf, int len){try {return br.read(buf,0,len);}catch (Exception ex){ return -1; }}
public String readLine() {try {return br.readLine();}catch (Exception ex){ return "";}}
public long[] readLongArray() {
String[]n=this.readLine().trim().split("\\s+");long[]r=new long[n.length];
for(int i=0;i<n.length;i++)r[i]=Long.parseLong(n[i]);
return r;
}
public int[] readIntArray() {
String[]n=this.readLine().trim().split("\\s+");int[]r=new int[n.length];
for(int i=0;i<n.length;i++)r[i]=Integer.parseInt(n[i]);
return r;
}
public int[] readIntArray(int n) {
int[] res = new int[n];
char[] all = this.readLine().toCharArray();
int cur = 0;boolean have = false;
int k = 0;
boolean neg = false;
for(int i = 0;i<all.length;i++){
if(all[i]>='0' && all[i]<='9'){
cur = cur*10+all[i]-'0';
have = true;
}else if(all[i]=='-') {
neg = true;
}
else if(have){
res[k++] = neg?-cur:cur;
cur = 0;
have = false;
neg = false;
}
}
if(have)res[k++] = neg?-cur:cur;
return res;
}
public int ri() {
try {
int r = 0;
boolean start = false;
boolean neg = false;
while (true) {
int c = br.read();
if (c >= '0' && c <= '9') {
r = r * 10 + c - '0';
start = true;
} else if (!start && c == '-') {
start = true;
neg = true;
} else if (start || c == -1) return neg ? -r : r;
}
} catch (Exception ex) {
return -1;
}
}
public long readLong() {
try {
long r = 0;
boolean start = false;
boolean neg = false;
while (true) {
int c = br.read();
if (c >= '0' && c <= '9') {
r = r * 10 + c - '0';
start = true;
} else if (!start && c == '-') {
start = true;
neg = true;
} else if (start || c == -1) return neg ? -r : r;
}
} catch (Exception ex) {
return -1;
}
}
public String readWord() {
try {
boolean start = false;
StringBuilder sb = new StringBuilder();
while (true) {
int c = br.read();
if (c!= ' ' && c!= '\r' && c!='\n' && c!='\t') {
sb.append((char)c);
start = true;
} else if (start || c == -1) return sb.toString();
}
} catch (Exception ex) {
return "";
}
}
public char readSymbol() {
try {
while (true) {
int c = br.read();
if (c != ' ' && c != '\r' && c != '\n' && c != '\t') {
return (char) c;
}
}
} catch (Exception ex) {
return 0;
}
}
//public char readChar(){try {return (char)br.read();}catch (Exception ex){ return 0; }}
}
class Pair {
public Pair(int a, int b) {this.a = a;this.b = b;}
public int a;
public int b;
}
class PairLL {
public PairLL(long a, long b) {this.a = a;this.b = b;}
public long a;
public long b;
}
class Triple {
public Triple(int a, int b, int c) {this.a = a;this.b = b;this.c = c;}
public int a;
public int b;
public int c;
}
|
You are given an image, that can be represented with a 2-d n by m grid of pixels. Each pixel of the image is either on or off, denoted by the characters "0" or "1", respectively. You would like to compress this image. You want to choose an integer k > 1 and split the image into k by k blocks. If n and m are not divisible by k, the image is padded with only zeros on the right and bottom so that they are divisible by k. Each pixel in each individual block must have the same value. The given image may not be compressible in its current state. Find the minimum number of pixels you need to toggle (after padding) in order for the image to be compressible for some k. More specifically, the steps are to first choose k, then the image is padded with zeros, then, we can toggle the pixels so it is compressible for this k. The image must be compressible in that state.
Input
The first line of input will contain two integers n, m (2 ≤ n, m ≤ 2 500), the dimensions of the image.
The next n lines of input will contain a binary string with exactly m characters, representing the image.
Output
Print a single integer, the minimum number of pixels needed to toggle to make the image compressible.
Example
Input
3 5
00100
10110
11001
Output
5
Note
We first choose k = 2.
The image is padded as follows:
001000
101100
110010
000000
We can toggle the image to look as follows:
001100
001100
000000
000000
We can see that this image is compressible for k = 2.
|
#include <bits/stdc++.h>
using namespace std;
const int M = 2505;
char S[M][M];
int n, m, sum[M][M];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", S[i] + 1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) sum[i][j] = (S[i][j] == '1') + sum[i][j - 1];
for (int j = 1; j <= m; j++) sum[i][j] += sum[i - 1][j];
}
int ans = n * m;
for (int i = 2, up = max(n, m); i <= up; i++) {
int cnt = 0, mar = i * i;
for (int j = 1; j <= n; j += i)
for (int k = 1; k <= m; k += i) {
int tmp = sum[min(j + i - 1, n)][min(k + i - 1, m)] +
sum[j - 1][k - 1] - sum[j - 1][min(k + i - 1, m)] -
sum[min(j + i - 1, n)][k - 1];
cnt += min(tmp, mar - tmp);
}
if (cnt < ans) ans = cnt;
}
printf("%d\n", ans);
return 0;
}
|
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e6 + 2, inf = 1e9 + 7;
void _run();
void no() { cout << "-1\n", exit(0); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
_run();
return 0;
}
string rs[N];
void _run() {
int n;
cin >> n;
string s[n + 1];
for (int i = 1; i <= n; i++) cin >> s[i];
vector<pair<pair<int, string>, int> > vec;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 9; j++) {
string cur = "";
for (int k = j; k < 9; k++) {
cur += s[i][k];
vec.push_back(make_pair(make_pair((int)cur.size(), cur), i));
}
}
}
sort(vec.begin(), vec.end());
map<int, int> M;
string prv = "";
set<pair<string, int> > st;
for (auto x : vec) {
if (x.first.second != prv) {
if (st.size() == 1) {
auto it = *st.begin();
if (rs[it.second].size() == 0) rs[it.second] = it.first;
}
st.clear();
st.insert(make_pair(x.first.second, x.second));
prv = x.first.second;
} else
st.insert(make_pair(x.first.second, x.second));
}
if (st.size() == 1) {
auto it = *st.begin();
if (rs[it.second].size() == 0) rs[it.second] = it.first;
}
for (int i = 1; i <= n; i++) cout << rs[i] << "\n";
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.