input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
You are given an array a consisting of n positive integers.
Initially, you have an integer x = 0. During one move, you can do one of the following two operations:
1. Choose exactly one i from 1 to n and increase a_i by x (a_i := a_i + x), then increase x by 1 (x := x + 1).
2. Just increase x by 1 (x := x + 1).
The first operation can be applied no more than once to each i from 1 to n.
Your task is to find the minimum number of moves required to obtain such an array that each its element is divisible by k (the value k is given).
You have to answer t independent test cases.
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 length of a and the required divisior. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of a.
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 minimum number of moves required to obtain such an array that each its element is divisible by k.
Example
Input
5
4 3
1 2 1 3
10 6
8 7 1 8 3 7 5 10 8 9
5 10
20 100 50 20 100500
10 25
24 24 24 24 24 24 24 24 24 24
8 8
1 2 3 4 5 6 7 8
Output
6
18
0
227
8
Note
Consider the first test case of the example:
1. x=0, a = [1, 2, 1, 3]. Just increase x;
2. x=1, a = [1, 2, 1, 3]. Add x to the second element and increase x;
3. x=2, a = [1, 3, 1, 3]. Add x to the third element and increase x;
4. x=3, a = [1, 3, 3, 3]. Add x to the fourth element and increase x;
5. x=4, a = [1, 3, 3, 6]. Just increase x;
6. x=5, a = [1, 3, 3, 6]. Add x to the first element and increase x;
7. x=6, a = [6, 3, 3, 6]. We obtained the required array.
Note that you can't add x to the same element more than once.
|
from collections import Counter as Cnt
for _ in range(int(input())):
n, k = map(int, input().split())
a = [(int(x) % k) for x in input().split() if int(x) % k != 0]
if not a:
print(0)
else:
c = Cnt(a)
print(max(1 - x + k * c[x] for x in c))
|
Ziota found a video game called "Monster Invaders".
Similar to every other shooting RPG game, "Monster Invaders" involves killing monsters and bosses with guns.
For the sake of simplicity, we only consider two different types of monsters and three different types of guns.
Namely, the two types of monsters are:
* a normal monster with 1 hp.
* a boss with 2 hp.
And the three types of guns are:
* Pistol, deals 1 hp in damage to one monster, r_1 reloading time
* Laser gun, deals 1 hp in damage to all the monsters in the current level (including the boss), r_2 reloading time
* AWP, instantly kills any monster, r_3 reloading time
The guns are initially not loaded, and the Ziota can only reload 1 gun at a time.
The levels of the game can be considered as an array a_1, a_2, …, a_n, in which the i-th stage has a_i normal monsters and 1 boss. Due to the nature of the game, Ziota cannot use the Pistol (the first type of gun) or AWP (the third type of gun) to shoot the boss before killing all of the a_i normal monsters.
If Ziota damages the boss but does not kill it immediately, he is forced to move out of the current level to an arbitrary adjacent level (adjacent levels of level i (1 < i < n) are levels i - 1 and i + 1, the only adjacent level of level 1 is level 2, the only adjacent level of level n is level n - 1). Ziota can also choose to move to an adjacent level at any time. Each move between adjacent levels are managed by portals with d teleportation time.
In order not to disrupt the space-time continuum within the game, it is strictly forbidden to reload or shoot monsters during teleportation.
Ziota starts the game at level 1. The objective of the game is rather simple, to kill all the bosses in all the levels. He is curious about the minimum time to finish the game (assuming it takes no time to shoot the monsters with a loaded gun and Ziota has infinite ammo on all the three guns). Please help him find this value.
Input
The first line of the input contains five integers separated by single spaces: n (2 ≤ n ≤ 10^6) — the number of stages, r_1, r_2, r_3 (1 ≤ r_1 ≤ r_2 ≤ r_3 ≤ 10^9) — the reload time of the three guns respectively, d (1 ≤ d ≤ 10^9) — the time of moving between adjacent levels.
The second line of the input contains n integers separated by single spaces a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^6, 1 ≤ i ≤ n).
Output
Print one integer, the minimum time to finish the game.
Examples
Input
4 1 3 4 3
3 2 5 1
Output
34
Input
4 2 4 4 1
4 5 1 2
Output
31
Note
In the first test case, the optimal strategy is:
* Use the pistol to kill three normal monsters and AWP to kill the boss (Total time 1⋅3+4=7)
* Move to stage two (Total time 7+3=10)
* Use the pistol twice and AWP to kill the boss (Total time 10+1⋅2+4=16)
* Move to stage three (Total time 16+3=19)
* Use the laser gun and forced to move to either stage four or two, here we move to stage four (Total time 19+3+3=25)
* Use the pistol once, use AWP to kill the boss (Total time 25+1⋅1+4=30)
* Move back to stage three (Total time 30+3=33)
* Kill the boss at stage three with the pistol (Total time 33+1=34)
Note that here, we do not finish at level n, but when all the bosses are killed.
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, c = getchar();
for (; !(c > 47 && c < 58); c = getchar())
;
for (; (c > 47 && c < 58); c = getchar()) x = x * 10 + c - 48;
return x;
}
void upd(long long &a, long long b) { a = (a < b) ? a : b; }
const int N = 1e6 + 5;
long long f[N][2];
int n, r1, r2, r3, d, a[N];
int main() {
n = read(), r1 = read(), r2 = read(), r3 = read(), d = read();
for (int i = 1; i <= n; a[i++] = read())
;
for (int i = 2; i <= n; ++i) f[i][0] = f[i][1] = 1e18;
f[1][0] = 1ll * r1 * a[1] + r3;
f[1][1] = min(0ll + r2, 1ll * r1 * a[1] + r1);
for (int i = 1; i < n; ++i) {
upd(f[i + 1][0], f[i][0] + d + 1ll * r1 * a[i + 1] + r3);
upd(f[i + 1][1], f[i][0] + d + min(0ll + r2, 1ll * r1 * a[i + 1] + r1));
upd(f[i + 1][0], f[i][1] + d + 1ll * r1 * a[i + 1] + r3 + 2 * d + r1);
upd(f[i + 1][0], f[i][1] + d + 1ll * r1 * a[i + 1] + r1 + d + r1 + d + r1);
upd(f[i + 1][0], f[i][1] + d + r2 + d + r1 + d + r1);
upd(f[i + 1][1], f[i][1] + d + r2 + d + r1 + d);
upd(f[i + 1][1], f[i][1] + d + 1ll * r1 * a[i + 1] + r1 + d + r1 + d);
if (i == n - 1) {
upd(f[i + 1][0], f[i][1] + d + 1ll * r1 * a[i + 1] + r3 + d + r1);
}
}
cout << f[n][0] << endl;
}
|
In order to celebrate Twice's 5th anniversary, Tzuyu and Sana decided to play a game.
Tzuyu gave Sana two integers a and b and a really important quest.
In order to complete the quest, Sana has to output the smallest possible value of (a ⊕ x) + (b ⊕ x) for any given x, where ⊕ denotes the [bitwise XOR operation](http://en.wikipedia.org/wiki/Bitwise_operation#XOR).
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^{4}). Description of the test cases follows.
The only line of each test case contains two integers a and b (1 ≤ a, b ≤ 10^{9}).
Output
For each testcase, output the smallest possible value of the given expression.
Example
Input
6
6 12
4 9
59 832
28 14
4925 2912
1 1
Output
10
13
891
18
6237
0
Note
For the first test case Sana can choose x=4 and the value will be (6 ⊕ 4) + (12 ⊕ 4) = 2 + 8 = 10. It can be shown that this is the smallest possible value.
|
import math
t = int(input())
for _ in range(t):
a,b = [int(x) for x in input().split()]
x = 1
ans = 0
while(x<=a or x<=b):
if (x&a!=x&b):
ans+=x
x*=2
print(ans)
|
Let's consider a (10^9+1) × (10^9+1) field. The rows are numbered with integers from 0 to 10^9 and the columns are numbered with integers from 0 to 10^9. Let's define as (x, y) the cell located in the x-th row and y-th column.
Let's call a cell (x, y) good if x \& y = 0, there \& is the [bitwise and](https://en.wikipedia.org/wiki/Bitwise_operation#AND) operation.
Let's build a graph where vertices will be all good cells of the field and we will make an edge between all pairs of adjacent by side good cells. It can be proved that this graph will be a tree — connected graph without cycles. Let's hang this tree on vertex (0, 0), so we will have a rooted tree with root (0, 0).
Two players will play the game. Initially, some good cells are black and others are white. Each player on his turn chooses a black good cell and a subset of its ancestors (possibly empty) and inverts their colors (from white to black and vice versa). The player who can't move (because all good cells are white) loses. It can be proved that the game is always finite.
Initially, all cells are white. You are given m pairs of cells. For each pair color all cells in a simple path between them as black. Note that we do not invert their colors, we paint them black.
Sohrab and Mashtali are going to play this game. Sohrab is the first player and Mashtali is the second.
Mashtali wants to win and decided to cheat. He can make the following operation multiple times before the game starts: choose a cell and invert colors of all vertices on the path between it and the root of the tree.
Mammad who was watching them wondered: "what is the minimum number of operations Mashtali should do to have a winning strategy?".
Find the answer to this question for the initial painting of the tree. It can be proved that at least one possible way to cheat always exists.
Input
The first line contains one integer m (1 ≤ m ≤ 10^5).
Each of the next m lines contains four integers x_{1}, y_{1}, x_{2}, y_{2} (0 ≤ x_i, y_i ≤ 10^9, x_i \& y_i = 0). You should color all cells on the path between vertices (x_1, y_1) and (x_2, y_2) as black.
Output
Print a single integer — the minimum number of cheating operations the second player can do.
Examples
Input
1
7 0 0 7
Output
1
Input
3
1 2 3 4
3 4 1 2
2 1 3 4
Output
3
Input
2
0 1 0 8
1 0 8 0
Output
0
Note
In the first test, you can make one cheating operation with the root of the tree. After that, the second player can win because he can use a symmetric strategy.
In the second test, you can make cheating operations with cells (0, 2), (0, 0), (3, 4).
In the third test, the second player already has the winning strategy and doesn't need to make any cheating operations.
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct outputer;
struct outputable {};
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int N = 100000;
const int M = 30;
struct Input {
int n;
pair<uint32_t, uint32_t> st[N], fn[N];
bool read() {
if (!(cin >> n)) {
return 0;
}
for (int i = int(0); i < int(n); ++i) {
scanf("%u%u%u%u", &st[i].first, &st[i].second, &fn[i].first,
&fn[i].second);
}
return 1;
}
void init(const Input& input) { *this = input; }
};
struct Data : Input {
int ans;
void write() { cout << ans << endl; }
};
namespace Main {
const int K = 4 * N;
inline int get_last_one(uint32_t x) {
int res = -1;
for (int i = int(5) - 1; i >= int(0); --i) {
if (x & -(1u << (res + (1 << i)))) {
res += 1 << i;
}
}
return res;
}
inline pair<uint32_t, uint32_t> cut(pair<uint32_t, uint32_t> a, int d) {
return pair<uint32_t, uint32_t>(a.first & -(1u << (d + 1)),
a.second & -(1u << (d + 1)));
}
inline pair<uint32_t, uint32_t> common(pair<uint32_t, uint32_t> a,
pair<uint32_t, uint32_t> b) {
int d =
max(get_last_one(a.first ^ b.first), get_last_one(a.second ^ b.second));
if (d == -1) {
return a;
}
if ((a.first & (1u << d)) && (b.second & (1u << d))) {
return cut(a, d);
}
if ((a.second & (1u << d)) && (b.first & (1u << d))) {
return cut(a, d);
}
if (a.first & (1 << d)) {
return cut(b, get_last_one(b.second & ((1u << d) - 1)));
}
if (a.second & (1 << d)) {
return cut(b, get_last_one(b.first & ((1u << d) - 1)));
}
if (b.first & (1 << d)) {
return cut(a, get_last_one(a.second & ((1u << d) - 1)));
}
if (b.second & (1 << d)) {
return cut(a, get_last_one(a.first & ((1u << d) - 1)));
}
assert(0);
}
inline uint64_t ord(pair<uint32_t, uint32_t> a) {
uint64_t res = 0;
for (int i = int(30) - 1; i >= int(0); --i) {
if (!a.second) {
return res + a.first;
}
if (a.first & (1u << i)) {
a.first -= 1u << i;
res += 1u << i;
continue;
}
if (a.second & (1u << i)) {
a.second -= 1u << i;
res += 1ull << (i + i + 1);
continue;
}
res += 1ull << (i + i);
}
return res;
}
struct Solution : Data {
int v_cnt;
pair<uint32_t, uint32_t> a[K];
map<pair<uint32_t, uint32_t>, int> num;
int pr[K];
int lvl[K];
int inc[K], dec[K];
pair<uint64_t, pair<uint32_t, uint32_t> > tmp[K];
void sort_unique() {
for (int i = int(0); i < int(v_cnt); ++i) {
tmp[i] = make_pair(ord(a[i]), a[i]);
};
sort(tmp, tmp + v_cnt);
v_cnt = unique(tmp, tmp + v_cnt) - tmp;
for (int i = int(0); i < int(v_cnt); ++i) {
a[i] = tmp[i].second;
}
}
set<int> bounds;
void flip(int x) {
if (bounds.count(x)) {
bounds.erase(x);
} else {
bounds.insert(x);
}
}
void solve() {
for (int i = int(0); i < int(n); ++i) {
a[v_cnt++] = st[i];
a[v_cnt++] = fn[i];
};
sort_unique();
;
for (int i = int(v_cnt - 1) - 1; i >= int(0); --i) {
a[v_cnt++] = common(a[i], a[i + 1]);
};
sort_unique();
;
for (int i = int(0); i < int(v_cnt); ++i) {
num[a[i]] = i;
lvl[i] = a[i].first + a[i].second;
}
{
vector<int> q;
q.emplace_back(0);
pr[0] = -1;
for (int i = int(1); i < int(v_cnt); ++i) {
while (common(a[q.back()], a[i]) != a[q.back()]) {
q.pop_back();
assert(((int)(q).size()));
}
pr[i] = q.back();
q.emplace_back(i);
}
}
memset(inc, 0, sizeof inc);
memset(dec, 0, sizeof dec);
for (int i = int(0); i < int(n); ++i) {
inc[num[st[i]]]++;
inc[num[fn[i]]]++;
dec[num[common(st[i], fn[i])]] += 2;
};
;
;
;
for (int i = int(v_cnt) - 1; i >= int(0); --i) {
if (inc[i]) {
flip(lvl[i]);
flip(lvl[i] + 1);
}
inc[i] -= dec[i];
if (inc[i]) {
assert(i);
flip(lvl[pr[i]] + 1);
flip(lvl[i]);
inc[pr[i]] += inc[i];
}
}
bounds.erase(0);
ans = ((int)(bounds).size());
}
void clear() { *this = Solution(); }
};
} // namespace Main
Main::Solution sol;
int main() {
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
|
Only a few know that Pan and Apollo weren't only battling for the title of the GOAT musician. A few millenniums later, they also challenged each other in math (or rather in fast calculations). The task they got to solve is the following:
Let x_1, x_2, …, x_n be the sequence of n non-negative integers. Find this value: $$$∑_{i=1}^n ∑_{j=1}^n ∑_{k=1}^n (x_i \& x_j) ⋅ (x_j | x_k)$$$
Here \& denotes the [bitwise and,](https://en.wikipedia.org/wiki/Bitwise_operation#AND) and | denotes the [bitwise or.](https://en.wikipedia.org/wiki/Bitwise_operation#OR)
Pan and Apollo could solve this in a few seconds. Can you do it too? For convenience, find the answer modulo 10^9 + 7.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 1 000) denoting the number of test cases, then t test cases follow.
The first line of each test case consists of a single integer n (1 ≤ n ≤ 5 ⋅ 10^5), the length of the sequence. The second one contains n non-negative integers x_1, x_2, …, x_n (0 ≤ x_i < 2^{60}), elements of the sequence.
The sum of n over all test cases will not exceed 5 ⋅ 10^5.
Output
Print t lines. The i-th line should contain the answer to the i-th text case.
Example
Input
8
2
1 7
3
1 2 4
4
5 5 5 5
5
6 2 2 1 0
1
0
1
1
6
1 12 123 1234 12345 123456
5
536870912 536870911 1152921504606846975 1152921504606846974 1152921504606846973
Output
128
91
1600
505
0
1
502811676
264880351
|
import sys
testing = len(sys.argv) == 4 and sys.argv[3] == "myTest"
if testing:
cmd = sys.stdout
from time import time
start_time = int(round(time() * 1000))
input = open(sys.argv[1], 'r').readline
sys.stdout = open(sys.argv[2], 'w')
else:
input = sys.stdin.readline
mod = 10**9+7
# from math import ceil
# from collections import defaultdict as dd
# from heapq import *
############ ---- I/O Functions ---- ############
def intin():
return(int(input()))
def intlin():
return(list(map(int,input().split())))
def chrin():
s = input()
return(list(s[:len(s) - 1]))
def strin():
s = input()
return s[:len(s) - 1]
def intlout(l, sep=" "):
print(sep.join(map(str, l)))
def main():
n = intin()
a = intlin()
b = [format(x,'b')[::-1] for x in a]
lens = [len(x) for x in b]
maxK = max(lens)
bcnt = [0]*maxK
for i in xrange(n):
x = b[i]
for k in xrange(lens[i]):
if x[k]=='1':
bcnt[k] += 1
kpowb = [(((1<<k)%mod)*bcnt[k])%mod for k in xrange(maxK)]
summ = sum(kpowb)%mod # sum(a)
ans = 0
for j in xrange(n):
x = b[j]
tmp = 0
for k in xrange(lens[j]):
if x[k] == '1':
tmp += kpowb[k]
tmp %= mod
ans = (ans + (tmp*(((a[j]%mod)*n)%mod + summ - tmp)%mod)%mod)%mod
# print(ans)
return(ans)
if __name__ == "__main__":
ans = []
for _ in xrange(intin()):
ans.append(main())
# main()
# print("YES" if main() else "NO")
intlout(ans,'\n')
# main()
if testing:
sys.stdout = cmd
print(int(round(time() * 1000)) - start_time)
|
Polycarp was gifted an array a of length n. Polycarp considers an array beautiful if there exists a number C, such that each number in the array occurs either zero or C times. Polycarp wants to remove some elements from the array a to make it beautiful.
For example, if n=6 and a = [1, 3, 2, 1, 4, 2], then the following options are possible to make the array a array beautiful:
* Polycarp removes elements at positions 2 and 5, array a becomes equal to [1, 2, 1, 2];
* Polycarp removes elements at positions 1 and 6, array a becomes equal to [3, 2, 1, 4];
* Polycarp removes elements at positions 1, 2 and 6, array a becomes equal to [2, 1, 4];
Help Polycarp determine the minimum number of elements to remove from the array a to make it beautiful.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output one integer — the minimum number of elements that Polycarp has to remove from the array a to make it beautiful.
Example
Input
3
6
1 3 2 1 4 2
4
100 100 4 100
8
1 2 3 3 3 2 6 6
Output
2
1
2
|
#include <iostream>
#include <algorithm>
using namespace std;
#ifndef ONLINE_JUDGE
#include <fstream>
#define cin fin
#define cout fout
ifstream fin ("test.in");
ofstream fout ("test.out");
#endif
int t, n, a[200001], f[200001], nra, p[100001], k;
int rasp (int mij) {
int r = 0;
for (int i = 1; i <= k; i++) {
if (p[i] - mij < 0)
r += p[i] * f[p[i]];
else
r += (p[i] - mij) * f[p[i]];
}
return r;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
for (int tt = 1; tt <= t; tt++) {
cin >> n; int r = n + 1; k = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i]; f[i] = 0;
}
sort (a + 1, a + n + 1);
nra = 0; a[0] = a[1]; a[n + 1] = a[n] + 1;
for (int i = 1; i <= n + 1; i++) {
if (a[i] == a[i - 1])
nra++;
else {
f[nra]++;
nra = 1;
}
}
for (int i = 1; i <= n; i++)
if (f[i])
p[++k] = i;
for (int i = 1; i <= k; i++)
r = min (r, rasp(p[i]));
cout << r << '\n';
}
return 0;
}
|
A sequence of n non-negative integers (n ≥ 2) a_1, a_2, ..., a_n is called good if for all i from 1 to n-1 the following condition holds true: $$$a_1 \: \& \: a_2 \: \& \: ... \: \& \: a_i = a_{i+1} \: \& \: a_{i+2} \: \& \: ... \: \& \: a_n, where \&$$$ denotes the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND).
You are given an array a of size n (n ≥ 2). Find the number of permutations p of numbers ranging from 1 to n, for which the sequence a_{p_1}, a_{p_2}, ... ,a_{p_n} is good. Since this number can be large, output it modulo 10^9+7.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4), denoting the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the size of the array.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — the elements of the array.
It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
Output t lines, where the i-th line contains the number of good permutations in the i-th test case modulo 10^9 + 7.
Example
Input
4
3
1 1 1
5
1 2 3 4 5
5
0 2 0 3 0
4
1 3 5 1
Output
6
0
36
4
Note
In the first test case, since all the numbers are equal, whatever permutation we take, the sequence is good. There are a total of 6 permutations possible with numbers from 1 to 3: [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1].
In the second test case, it can be proved that no permutation exists for which the sequence is good.
In the third test case, there are a total of 36 permutations for which the sequence is good. One of them is the permutation [1,5,4,2,3] which results in the sequence s=[0,0,3,2,0]. This is a good sequence because
* s_1 = s_2 \: \& \: s_3 \: \& \: s_4 \: \& \: s_5 = 0,
* s_1 \: \& \: s_2 = s_3 \: \& \: s_4 \: \& \: s_5 = 0,
* s_1 \: \& \: s_2 \: \& \: s_3 = s_4 \: \& \: s_5 = 0,
* s_1 \: \& \: s_2 \: \& \: s_3 \: \& \: s_4 = s_5 = 0.
|
import java.io.*;
import java.util.*;
public class Main {
static long mod=1_000_000_000+7;
static long[] facts=new long[3_000_00];
static long mul(long a, long b) {
return a*b%mod;
}
static long add(long a, long b) {
return (a+b)%mod;
}
static void precomp() {
facts[0]=1;
for (int i=1; i<facts.length; i++) facts[i]=mul(facts[i-1], i);
}
static long exp(long base, long pow) {
if (pow==0) return 1;
long half=exp(base, pow/2);
if (pow%2==0) return mul(half, half);
return mul(half, mul(half, base));
}
static long modInv(long x) {
return exp(x, mod-2);
}
static long nCk(int n, int k) {
if(n<k) return 0;
return mul(facts[n], mul(modInv(facts[k]), modInv(facts[n-k])));
}
public static void main(String[] args) throws IOException
{
FastScanner f = new FastScanner();
int t=1;
t=f.nextInt();
precomp();
PrintWriter out=new PrintWriter(System.out);
for(int tt=0;tt<t;tt++) {
int n= f.nextInt();
int[] l=f.readArray(n);
int and=l[0];
for(int i=1;i<n;i++) {
and=and&l[i];
}
int count=0;
for(int i=0;i<n;i++) {
if(l[i]==and) count++;
}
System.out.println(mul(mul(nCk(count,2),2),facts[n-2]));
}
out.close();
}
static void sort(long[] p) {
ArrayList<Integer> q = new ArrayList<>();
for (long i: p) q.add((int) i);
Collections.sort(q);
for (int i = 0; i < p.length; i++) p[i] = q.get(i);
}
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
long[] readLongArray(int n) {
long[] a=new long[n];
for (int i=0; i<n; i++) a[i]=nextLong();
return a;
}
}
}
//Some things to notice
//Check for the overflow
//Binary Search
//Bitmask
//runtime error most of the time is due to array index out of range
|
You are given a tree consisting of n nodes. You generate an array from the tree by marking nodes one by one.
Initially, when no nodes are marked, a node is equiprobably chosen and marked from the entire tree.
After that, until all nodes are marked, a node is equiprobably chosen and marked from the set of unmarked nodes with at least one edge to a marked node.
It can be shown that the process marks all nodes in the tree.
The final array a is the list of the nodes' labels in order of the time each node was marked.
Find the expected number of inversions in the array that is generated by the tree and the aforementioned process.
The number of inversions in an array a is the number of pairs of indices (i, j) such that i < j and a_i > a_j. For example, the array [4, 1, 3, 2] contains 4 inversions: (1, 2), (1, 3), (1, 4), (3, 4).
Input
The first line contains a single integer n (2 ≤ n ≤ 200) — the number of nodes in the tree.
The next n - 1 lines each contains two integers x and y (1 ≤ x, y ≤ n; x ≠ y), denoting an edge between node x and y.
It's guaranteed that the given edges form a tree.
Output
Output the expected number of inversions in the generated array modulo 10^9+7.
Formally, let M = 10^9+7. It can be shown that the answer can be expressed as an irreducible fraction p/q, where p and q are integers and q not ≡ 0 \pmod{M}. Output the integer equal to p ⋅ q^{-1} mod M. In other words, output such an integer x that 0 ≤ x < M and x ⋅ q ≡ p \pmod{M}.
Examples
Input
3
1 2
1 3
Output
166666669
Input
6
2 1
2 3
6 1
1 4
2 5
Output
500000009
Input
5
1 2
1 3
1 4
2 5
Output
500000007
Note
This is the tree from the first sample:
<image>
For the first sample, the arrays are almost fixed. If node 2 is chosen initially, then the only possible array is [2, 1, 3] (1 inversion). If node 3 is chosen initially, then the only possible array is [3, 1, 2] (2 inversions). If node 1 is chosen initially, the arrays [1, 2, 3] (0 inversions) and [1, 3, 2] (1 inversion) are the only possibilities and equiprobable. In total, the expected number of inversions is 1/3⋅ 1 + 1/3 ⋅ 2 + 1/3 ⋅ (1/2 ⋅ 0 + 1/2 ⋅ 1) = 7/6.
166666669 ⋅ 6 = 7 \pmod {10^9 + 7}, so the answer is 166666669.
This is the tree from the second sample:
<image>
This is the tree from the third sample:
<image>
|
#include <iostream>
#include <vector>
#define ll long long
#define pb push_back
using namespace std;
int const N=210,mod=1e9+7;
int n;
int inv[N],dp[N][N],lca[N][N],dep[N];
vector<int> g[N],s[N];
void dfs(int cur,int fa){//cur=current, fa=father(don't go to fa)
s[cur]={cur};dep[cur]=(fa>=0)?dep[fa]+1:1;
for(int child:g[cur]){
if(child==fa)continue;
dfs(child,cur);
for(int x:s[child]){
for(int y:s[cur]){
lca[x][y]=lca[y][x]=cur;
}
}
for(int x:s[child])s[cur].pb(x);
}
}
void add(int& a,int b){
a+=b;
if(a>=mod)a-=mod;
}
int main(){
cin>>n;
inv[0]=inv[1]=1;
for(int i=2;i<=n;++i)inv[i]=(ll)inv[mod%i]*(mod-mod/i)%mod;//https://yuihuang.com/modular-multiplicative-inverse/
//dp[i][j] means the possibility to reach the node which is i steps away before to reach the node which is j steps away.
for(int i=0;i<=n;++i)dp[i][0]=0,dp[0][i]=1;//don't care dp[0][0], I won't use it
for(int i=1;i<=n;++i)
for(int j=1;j<=n;++j)
dp[i][j]=(ll)(dp[i-1][j]+dp[i][j-1])*inv[2]%mod;
int u,v;
for(int i=1;i<n;++i){
cin>>u>>v;
--u;--v;
g[u].pb(v);g[v].pb(u);
}
int ans=0;
for(int rt=0;rt<n;++rt){
dfs(rt,-1);//find lca of every two nodes(rt as the root) and depth of every node
for(int x=0;x<n;++x){
for(int y=x+1;y<n;++y){//x<y, so add the possibility to reach y before to reach x
add(ans,dp[dep[y]-dep[lca[x][y]]][dep[x]-dep[lca[x][y]]]);
}
}
}
cout<<((ll)ans*inv[n]%mod)<<'\n';
}
/*
* Reference:
* https://codeforces.com/contest/1540/submission/121177611
* https://www.cnblogs.com/liankewei/p/14939849.html
* https://yuihuang.com/modular-multiplicative-inverse/
*/
|
In some country live wizards. They like to make weird bets.
Two wizards draw an acyclic directed graph with n vertices and m edges (the graph's vertices are numbered from 1 to n). A source is a vertex with no incoming edges, and a sink is the vertex with no outgoing edges. Note that a vertex could be the sink and the source simultaneously. In the wizards' graph the number of the sinks and the sources is the same.
Wizards numbered the sources in the order of increasing numbers of the vertices from 1 to k. The sinks are numbered from 1 to k in the similar way.
To make a bet, they, as are real wizards, cast a spell, which selects a set of k paths from all sources to the sinks in such a way that no two paths intersect at the vertices. In this case, each sink has exactly one path going to it from exactly one source. Let's suppose that the i-th sink has a path going to it from the ai's source. Then let's call pair (i, j) an inversion if i < j and ai > aj. If the number of inversions among all possible pairs (i, j), such that (1 ≤ i < j ≤ k), is even, then the first wizard wins (the second one gives him one magic coin). Otherwise, the second wizard wins (he gets one magic coin from the first one).
Our wizards are captured with feverish excitement, so they kept choosing new paths again and again for so long that eventually they have chosen every possible set of paths for exactly once. The two sets of non-intersecting pathes are considered to be different, if and only if there is an edge, which lies at some path in one set and doesn't lie at any path of another set. To check their notes, they asked you to count the total winnings of the first player for all possible sets of paths modulo a prime number p.
Input
The first line contains three space-separated integers n, m, p (1 ≤ n ≤ 600, 0 ≤ m ≤ 105, 2 ≤ p ≤ 109 + 7). It is guaranteed that p is prime number.
Next m lines contain edges of the graph. Each line contains a pair of space-separated integers, ai bi — an edge from vertex ai to vertex bi. It is guaranteed that the graph is acyclic and that the graph contains the same number of sources and sinks. Please note that the graph can have multiple edges.
Output
Print the answer to the problem — the total winnings of the first player modulo a prime number p. Please note that the winnings may be negative, but the modulo residue must be non-negative (see the sample).
Examples
Input
4 2 1000003
1 3
2 4
Output
1
Input
4 2 1000003
4 1
3 2
Output
1000002
Input
4 4 1000003
2 1
2 4
3 1
3 4
Output
0
Input
6 5 1000003
1 4
1 5
1 6
2 6
3 6
Output
0
Input
5 2 1000003
5 1
3 4
Output
1
Note
In the first sample, there is exactly one set of paths — <image>. The number of inversions is 0, which is an even number. Therefore, the first wizard gets 1 coin.
In the second sample there is exactly one set of paths — <image>. There is exactly one inversion. Therefore, the first wizard gets -1 coin. <image>.
In the third sample, there are two sets of paths, which are counted with opposite signs.
In the fourth sample there are no set of paths at all.
In the fifth sample, there are three sources — the vertices with the numbers (2, 3, 5) and three sinks — the vertices with numbers (1, 2, 4). For a single set of paths <image> are 2 inversions, that is, their number is even.
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 100005;
long long read() {
long long x = 0, flag = 1;
char c;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flag = -1;
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return x * flag;
}
long long n, m, mod, tot, f[605], in[605], out[605];
long long a[605][605], t[605][605];
bool vis[605];
vector<long long> fr, to;
struct edge {
long long v, next;
} e[MAXN];
void dfs(long long u) {
vis[u] = 1;
if (!out[u]) t[u][u] = 1;
for (long long i = f[u]; i; i = e[i].next) {
long long v = e[i].v;
if (!vis[v]) dfs(v);
for (long long i = 0; i < to.size(); i++)
t[u][to[i]] = (t[u][to[i]] + t[v][to[i]]) % mod;
}
}
long long qkpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
void gauss(long long n) {
long long mark = 1;
for (long long i = 1; i <= n; i++) {
long long r = i;
for (; r <= n; r++)
if (a[r][i]) break;
if (i ^ r) mark = -mark;
swap(a[r], a[i]);
for (long long j = i + 1; j <= n; j++) {
long long tmp = a[j][i] * qkpow(a[i][i], mod - 2) % mod;
for (long long k = i; k <= n; k++)
a[j][k] = (a[j][k] - a[i][k] * tmp % mod + mod) % mod;
}
}
long long ans = mark;
for (long long i = 1; i <= n; i++) ans = ans * a[i][i] % mod;
printf("%lld\n", (ans % mod + mod) % mod);
}
int main() {
n = read();
m = read();
mod = read();
for (long long i = 1; i <= m; i++) {
long long u = read(), v = read();
e[++tot] = edge{v, f[u]}, f[u] = tot;
in[v]++;
out[u]++;
}
for (long long i = 1; i <= n; i++) {
if (!in[i]) fr.push_back(i);
if (!out[i]) to.push_back(i);
}
for (long long i = 1; i <= n; i++)
if (!in[i]) dfs(i);
for (long long i = 0; i < fr.size(); i++)
for (long long j = 0; j < to.size(); j++) a[i + 1][j + 1] = t[fr[i]][to[j]];
gauss(fr.size());
}
|
The new operating system BerOS has a nice feature. It is possible to use any number of characters '/' as a delimiter in path instead of one traditional '/'. For example, strings //usr///local//nginx/sbin// and /usr/local/nginx///sbin are equivalent. The character '/' (or some sequence of such characters) at the end of the path is required only in case of the path to the root directory, which can be represented as single character '/'.
A path called normalized if it contains the smallest possible number of characters '/'.
Your task is to transform a given path to the normalized form.
Input
The first line of the input contains only lowercase Latin letters and character '/' — the path to some directory. All paths start with at least one character '/'. The length of the given line is no more than 100 characters, it is not empty.
Output
The path in normalized form.
Examples
Input
//usr///local//nginx/sbin
Output
/usr/local/nginx/sbin
|
s = raw_input()
while s.find("//") != -1:
s = s.replace("//", "/")
if s[-1] == "/" and len(s)>1:
s = s[0:-1]
print s
|
Some days ago, WJMZBMR learned how to answer the query "how many times does a string x occur in a string s" quickly by preprocessing the string s. But now he wants to make it harder.
So he wants to ask "how many consecutive substrings of s are cyclical isomorphic to a given string x". You are given string s and n strings xi, for each string xi find, how many consecutive substrings of s are cyclical isomorphic to xi.
Two strings are called cyclical isomorphic if one can rotate one string to get the other one. 'Rotate' here means 'to take some consecutive chars (maybe none) from the beginning of a string and put them back at the end of the string in the same order'. For example, string "abcde" can be rotated to string "deabc". We can take characters "abc" from the beginning and put them at the end of "de".
Input
The first line contains a non-empty string s. The length of string s is not greater than 106 characters.
The second line contains an integer n (1 ≤ n ≤ 105) — the number of queries. Then n lines follow: the i-th line contains the string xi — the string for the i-th query. The total length of xi is less than or equal to 106 characters.
In this problem, strings only consist of lowercase English letters.
Output
For each query xi print a single integer that shows how many consecutive substrings of s are cyclical isomorphic to xi. Print the answers to the queries in the order they are given in the input.
Examples
Input
baabaabaaa
5
a
ba
baa
aabaa
aaba
Output
7
5
7
3
5
Input
aabbaa
3
aa
aabb
abba
Output
2
3
3
|
#include <bits/stdc++.h>
using namespace std;
void io() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(15);
}
const int inf = 1e9;
const int maxn = 4 * 1e6 + 5;
char s[maxn];
unordered_map<int, int> to[maxn];
int len[maxn], fipos[maxn], link[maxn];
int depth[maxn];
int node, pos;
int sz = 1, n = 0;
int remain = 0;
int make_node(int _pos, int _len) {
fipos[sz] = _pos;
len[sz] = _len;
return sz++;
}
void go_edge(int &node, int &pos) {
while (pos > len[to[node][s[n - pos]]]) {
node = to[node][s[n - pos]];
pos -= len[node];
}
}
void add_letter(int c) {
s[n++] = c;
pos++;
int last = 0;
remain++;
while (pos > 0) {
go_edge(node, pos);
int edge = s[n - pos];
int &v = to[node][edge];
int t = s[fipos[v] + pos - 1];
if (v == 0) {
remain--;
v = make_node(n - pos, inf);
link[last] = node;
last = 0;
} else if (t == c) {
link[last] = node;
return;
} else {
remain--;
int u = make_node(fipos[v], pos - 1);
to[u][c] = make_node(n - 1, inf);
to[u][t] = v;
fipos[v] += pos - 1;
len[v] -= pos - 1;
v = u;
link[last] = u;
last = u;
}
if (node == 0)
pos--;
else
node = link[node];
}
}
int val[maxn];
int slen;
void dfs(int u, int d = 0) {
val[u] = (len[u] > slen + 2) && (u != 0);
depth[u] = min(inf, d);
for (auto it : to[u]) {
int v = it.second;
if (v) {
dfs(v, d + len[v]);
val[u] += val[v];
}
}
}
void fix(int &node, int &edg, int &pos, int &st, int &en, string &s) {
int fichar = s[st + depth[node]];
edg = to[node][fichar];
while (edg && pos > len[edg]) {
node = edg;
pos -= len[edg];
fichar = s[st + depth[node]];
edg = to[node][fichar];
}
}
int main(int argc, char *argv[]) {
io();
len[0] = inf;
string s;
cin >> s;
slen = s.length();
s += '$';
for (auto c : s) {
add_letter(c);
}
dfs(0);
int q;
cin >> q;
string str;
while (q--) {
cin >> str;
int l = str.length();
if (l > slen) {
cout << 0 << '\n';
continue;
}
str = str + str;
long long ans = 0;
int st = 0;
int en = 0;
int node = 0;
int edg = 0;
int pos = 1;
set<pair<int, pair<int, int>>> done;
while (st < l) {
fix(node, edg, pos, st, en, str);
assert(st <= en);
if (edg == 0) {
if (node == 0) {
pos--;
} else {
node = link[node];
}
st++;
if (st > en) {
en++;
}
continue;
}
while (en < (st + l)) {
fix(node, edg, pos, st, en, str);
int spos = fipos[edg] + pos - 1;
if (spos >= slen) {
break;
}
if (s[spos] == str[st + depth[node] + pos - 1]) {
en++;
pos++;
fix(node, edg, pos, st, en, str);
} else {
break;
}
}
if (en == st + l) {
if (done.find({node, {edg, pos}}) == done.end()) {
done.insert({node, {edg, pos}});
if (pos == 1) {
ans = ans + val[node];
} else {
if (edg != 0) ans = ans + val[edg];
}
} else {
}
}
st++;
if (st > en) {
en++;
}
if (node == 0)
pos--;
else
node = link[node];
}
cout << ans << '\n';
}
return 0;
}
|
Vasya has got two number: a and b. However, Vasya finds number a too short. So he decided to repeat the operation of lengthening number a n times.
One operation of lengthening a number means adding exactly one digit to the number (in the decimal notation) to the right provided that the resulting number is divisible by Vasya's number b. If it is impossible to obtain the number which is divisible by b, then the lengthening operation cannot be performed.
Your task is to help Vasya and print the number he can get after applying the lengthening operation to number a n times.
Input
The first line contains three integers: a, b, n (1 ≤ a, b, n ≤ 105).
Output
In a single line print the integer without leading zeros, which Vasya can get when he applies the lengthening operations to number a n times. If no such number exists, then print number -1. If there are multiple possible answers, print any of them.
Examples
Input
5 4 5
Output
524848
Input
12 11 1
Output
121
Input
260 150 10
Output
-1
|
import java.util.Scanner;
public class Adding_Digits {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int a = scan.nextInt();
int b = scan.nextInt();
int n = scan.nextInt();
int ans = a;
for (int i = 0 ; i < 10 ; i++) {
if (Integer.parseInt("" + a + i) % b == 0) {
ans = Integer.parseInt("" + a + i);
break;
}
}
if (ans == a)
System.out.println(-1);
else {
System.out.print(ans);
for (int i = 0 ; i < n-1 ; i++)
System.out.print(0);
}
}
}
|
The cows have just learned what a primitive root is! Given a prime p, a primitive root <image> is an integer x (1 ≤ x < p) such that none of integers x - 1, x2 - 1, ..., xp - 2 - 1 are divisible by p, but xp - 1 - 1 is.
Unfortunately, computing primitive roots can be time consuming, so the cows need your help. Given a prime p, help the cows find the number of primitive roots <image>.
Input
The input contains a single line containing an integer p (2 ≤ p < 2000). It is guaranteed that p is a prime.
Output
Output on a single line the number of primitive roots <image>.
Examples
Input
3
Output
1
Input
5
Output
2
Note
The only primitive root <image> is 2.
The primitive roots <image> are 2 and 3.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int p;
cin >> p;
int t;
int flag = 0;
int ans = 0;
for (int i = 1; i < p; i++) {
t = i;
for (int j = 1; j <= p - 2; j++) {
if ((t - 1) % p != 0) {
t = (t % p) * i;
} else {
flag = 1;
break;
}
}
if (flag == 0 && (t - 1) % p == 0) {
ans++;
}
flag = 0;
}
cout << ans;
}
|
People like to be fit. That's why many of them are ready to wake up at dawn, go to the stadium and run. In this problem your task is to help a company design a new stadium.
The city of N has a shabby old stadium. Many people like it and every morning thousands of people come out to this stadium to run. The stadium can be represented as a circle, its length is exactly l meters with a marked start line. However, there can't be simultaneous start in the morning, so exactly at 7, each runner goes to his favorite spot on the stadium and starts running from there. Note that not everybody runs in the same manner as everybody else. Some people run in the clockwise direction, some of them run in the counter-clockwise direction. It mostly depends on the runner's mood in the morning, so you can assume that each running direction is equiprobable for each runner in any fixed morning.
The stadium is tiny and is in need of major repair, for right now there only is one running track! You can't get too playful on a single track, that's why all runners keep the same running speed — exactly 1 meter per a time unit. Nevertheless, the runners that choose different directions bump into each other as they meet.
The company wants to design a new stadium, but they first need to know how bad the old one is. For that they need the expectation of the number of bumpings by t time units after the running has begun. Help the company count the required expectation. Note that each runner chooses a direction equiprobably, independently from the others and then all runners start running simultaneously at 7 a.m. Assume that each runner runs for t time units without stopping. Consider the runners to bump at a certain moment if at that moment they found themselves at the same point in the stadium. A pair of runners can bump more than once.
Input
The first line of the input contains three integers n, l, t (1 ≤ n ≤ 106, 1 ≤ l ≤ 109, 1 ≤ t ≤ 109). The next line contains n distinct integers a1, a2, ..., an (0 ≤ a1 < a2 < ... < an < l), here ai is the clockwise distance from the start line to the i-th runner's starting position.
Output
Print a single real number — the answer to the problem with absolute or relative error of at most 10 - 6.
Examples
Input
2 5 1
0 2
Output
0.2500000000
Input
3 7 3
0 1 6
Output
1.5000000000
Note
There are two runners in the first example. If the first runner run clockwise direction, then in 1 time unit he will be 1m away from the start line. If the second runner run counter-clockwise direction then in 1 time unit he will be also 1m away from the start line. And it is the only possible way to meet. We assume that each running direction is equiprobable, so the answer for the example is equal to 0.5·0.5 = 0.25.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
int data[N << 1];
int main() {
int n, L, t;
scanf("%d%d%d", &n, &L, &t);
t <<= 1;
for (int i = (0); i < (n); ++i) scanf("%d", &data[i]);
double ans = 0;
for (int l = 0, r = n, i = 0; i < n; i++, l++, r++) {
ans += 0.5 * (t / L) * (n - 1);
int now1 = upper_bound(data + l, data + r, data[i] + t % L) - data;
ans += 0.25 * (now1 - l - 1);
int now2 = lower_bound(data + l, data + r, data[i] + L - t % L) - data;
ans += 0.25 * (r - now2);
data[r] = data[i] + L;
}
printf("%.12lf\n", ans / 2);
return 0;
}
|
Everybody knows that we have been living in the Matrix for a long time. And in the new seventh Matrix the world is ruled by beavers.
So let's take beaver Neo. Neo has so-called "deja vu" outbursts when he gets visions of events in some places he's been at or is going to be at. Let's examine the phenomenon in more detail.
We can say that Neo's city is represented by a directed graph, consisting of n shops and m streets that connect the shops. No two streets connect the same pair of shops (besides, there can't be one street from A to B and one street from B to A). No street connects a shop with itself. As Neo passes some streets, he gets visions. No matter how many times he passes street k, every time he will get the same visions in the same order. A vision is a sequence of shops.
We know that Neo is going to get really shocked if he passes the way from some shop a to some shop b, possible coinciding with a, such that the list of visited shops in the real life and in the visions coincide.
Suggest beaver Neo such path of non-zero length. Or maybe you can even count the number of such paths modulo 1000000007 (109 + 7)?..
Input
The first line contains integers n and m — the number of shops and the number of streets, correspondingly, 1 ≤ n ≤ 50, <image>. Next m lines contain the descriptions of the streets in the following format: xi yi ki v1 v2 ... vk, where xi and yi (1 ≤ xi, yi ≤ n, xi ≠ yi) are indices of shops connected by a street, ki (0 ≤ ki ≤ n) is the number of visions on the way from xi to yi; v1, v2, ..., vk (1 ≤ vi ≤ n) describe the visions: the numbers of the shops Neo saw. Note that the order of the visions matters.
It is guaranteed that the total number of visions on all streets doesn't exceed 105.
* to get 50 points, you need to find any (not necessarily simple) path of length at most 2·n, that meets the attributes described above (subproblem E1);
* to get 50 more points, you need to count for each length from 1 to 2·n the number of paths that have the attribute described above (subproblem E2).
Output
Subproblem E1. In the first line print an integer k (1 ≤ k ≤ 2·n) — the numbers of shops on Neo's path. In the next line print k integers — the number of shops in the order Neo passes them. If the graph doesn't have such paths or the length of the shortest path includes more than 2·n shops, print on a single line 0.
Subproblem E2. Print 2·n lines. The i-th line must contain a single integer — the number of required paths of length i modulo 1000000007 (109 + 7).
Examples
Input
6 6
1 2 2 1 2
2 3 1 3
3 4 2 4 5
4 5 0
5 3 1 3
6 1 1 6
Output
4
6 1 2 3
Input
6 6
1 2 2 1 2
2 3 1 3
3 4 2 4 5
4 5 0
5 3 1 3
6 1 1 6
Output
1
2
1
1
2
1
1
2
1
1
2
1
Note
The input in both samples are the same. The first sample contains the answer to the first subproblem, the second sample contains the answer to the second subproblem.
|
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007;
const int N = 52;
int g[2][2][N][N][N * 2];
int f[N * 2][N][2];
int n, m, st[N * N], ed[N * N];
vector<int> seq[N * N];
int e[N][N];
pair<int, int> walk(vector<int> &tp, int x, bool fl) {
int now = 0;
for (; now + 1 <= tp.size();) {
int y = tp[now], ed = e[x][y];
if (!ed || tp.size() > 2 * n || (ed > m) != fl)
return pair<int, int>(23333, -1);
for (int j = 0; j < seq[ed].size(); j++) tp.push_back(seq[ed][j]);
x = y;
now++;
}
return pair<int, int>(tp.size(), x);
}
int man[N][N][N * 2];
int wei[N][N][N * 2];
void work(bool fl) {
memset(man, 0, sizeof(man));
memset(wei, 0, sizeof(wei));
for (int i = 1; i <= 2 * m; i++)
if ((i <= m) ^ fl)
for (int j = 0; j < seq[i].size(); j++)
if (seq[i][j] == st[i]) {
vector<int> t1, t2;
for (int k = j - 1; k >= 0; k--) t1.push_back(seq[i][k]);
pair<int, int> res = walk(t1, st[i], fl ^ 1);
if (res.first > 2 * n) continue;
if (j + 1 == seq[i].size())
wei[res.second][ed[i]][res.first + 1]++;
else if (seq[i][j + 1] == ed[i]) {
for (int k = j + 2; k < seq[i].size(); k++) t2.push_back(seq[i][k]);
pair<int, int> res2 = walk(t2, ed[i], fl);
if (res2.first + 1 + res.first <= 2 * n)
man[res.second][res2.second][res2.first + 1 + res.first]++;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y, k;
scanf("%d%d%d", &x, &y, &k);
e[x][y] = i;
e[y][x] = i + m;
st[i] = ed[i + m] = x;
st[i + m] = ed[i] = y;
for (int j = 1; j <= k; j++) {
int v;
scanf("%d", &v);
seq[i].push_back(v);
}
seq[i + m] = seq[i];
reverse(seq[i + m].begin(), seq[i + m].end());
if (!k) g[0][0][x][y][1]++;
}
work(0);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n * 2; k++)
g[1][1][i][j][k] = man[i][j][k], g[1][0][i][j][k] = wei[i][j][k];
work(1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n * 2; k++) g[0][1][j][i][k] = wei[i][j][k];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n * 2; k++)
for (int v = 0; v <= 1; v++)
(((f[k][j][v]) += (g[1][v][i][j][k])) >= mo ? f[k][j][v] -= mo : 233);
;
for (int k = 1; k <= n * 2; k++) {
int ans = 0;
for (int i = 1; i <= n; i++) {
(((ans) += (f[k][i][1])) >= mo ? ans -= mo : 233);
;
for (int mid = 0; mid <= 1; mid++)
if (f[k][i][mid])
for (int ed = 0; ed <= 1; ed++)
for (int zd = 1; zd <= n; zd++)
for (int l = 1; l <= 2 * n - k; l++)
(((f[k + l][zd][ed]) +=
(1ll * f[k][i][mid] * g[mid ^ 1][ed][i][zd][l] % mo)) >= mo
? f[k + l][zd][ed] -= mo
: 233);
;
}
printf("%d\n", ans);
}
}
|
Vasya and Petya are using an interesting data storing structure: a pyramid.
The pyramid consists of n rows, the i-th row contains i cells. Each row is shifted half a cell to the left relative to the previous row. The cells are numbered by integers from 1 to <image> as shown on the picture below.
An example of a pyramid at n = 5 is:
<image>
This data structure can perform operations of two types:
1. Change the value of a specific cell. It is described by three integers: "t i v", where t = 1 (the type of operation), i — the number of the cell to change and v the value to assign to the cell.
2. Change the value of some subpyramid. The picture shows a highlighted subpyramid with the top in cell 5. It is described by s + 2 numbers: "t i v1 v2 ... vs", where t = 2, i — the number of the top cell of the pyramid, s — the size of the subpyramid (the number of cells it has), vj — the value you should assign to the j-th cell of the subpyramid.
Formally: a subpyramid with top at the i-th cell of the k-th row (the 5-th cell is the second cell of the third row) will contain cells from rows from k to n, the (k + p)-th row contains cells from the i-th to the (i + p)-th (0 ≤ p ≤ n - k).
Vasya and Petya had two identical pyramids. Vasya changed some cells in his pyramid and he now wants to send his changes to Petya. For that, he wants to find a sequence of operations at which Petya can repeat all Vasya's changes. Among all possible sequences, Vasya has to pick the minimum one (the one that contains the fewest numbers).
You have a pyramid of n rows with k changed cells. Find the sequence of operations which result in each of the k changed cells being changed by at least one operation. Among all the possible sequences pick the one that contains the fewest numbers.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 105).
The next k lines contain the coordinates of the modified cells ri and ci (1 ≤ ci ≤ ri ≤ n) — the row and the cell's number in the row. All cells are distinct.
Output
Print a single number showing how many numbers the final sequence has.
Examples
Input
4 5
3 1
3 3
4 1
4 3
4 4
Output
10
Input
7 11
2 2
3 1
4 3
5 1
5 2
5 5
6 4
7 2
7 3
7 4
7 5
Output
26
Note
One of the possible solutions of the first sample consists of two operations:
2 4 v4 v7 v8
2 6 v6 v9 v10
The picture shows the changed cells color-highlighted. The subpyramid used by the first operation is highlighted blue and the subpyramid used by the first operation is highlighted yellow:
<image>
|
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
vector<int> sc[100005];
long long dp[2][100005];
long long sss(int c, int num) {
if (sc[c].empty()) return 0;
return upper_bound(sc[c].begin(), sc[c].end(), num) - sc[c].begin();
}
void cal() {
for (int(i) = 0; (i) < (int)(2); (i)++)
for (int(j) = 0; (j) < (int)(100005); (j)++) dp[i][j] = 3 * k;
if (!sc[n].empty() && sc[n].back() == n)
dp[1][0] = 3;
else
dp[1][0] = 0;
dp[1][1] = 0;
long long M = sqrt(k * 6);
int T = 1;
for (int i = 2; i <= n; i++) {
T ^= 1;
dp[T][0] = 3 * k;
for (int kk = 0; kk <= i; kk++) {
long long tmp = kk >= 1 ? dp[T ^ 1][kk - 1] : dp[T ^ 1][0];
if (kk) {
long long y = kk * (kk + 1) / 2 + 2;
if (y > 3 * k) break;
tmp += y;
}
tmp += sss(n + 1 - i, n - kk) * 3;
dp[T][0] = min(dp[T][0], tmp);
}
for (int j = 1; j <= i && j <= M; j++) {
dp[T][j] = 3 * k;
dp[T][j] =
min(dp[T][j - 1], dp[T ^ 1][j - 1] + sss(n + 1 - i, n - j) * 3);
}
}
cout << dp[T][0] << endl;
}
int main() {
scanf("%d%d", &n, &k);
int r, c;
for (int(i) = 0; (i) < (int)(k); (i)++) {
scanf("%d%d", &r, &c);
sc[c].push_back(r);
}
for (int(i) = 1; (i) <= (int)(n); (i)++)
if (!sc[i].empty()) {
sort(sc[i].begin(), sc[i].end());
}
cal();
return 0;
}
|
Kostya is a progamer specializing in the discipline of Dota 2. Valve Corporation, the developer of this game, has recently released a new patch which turned the balance of the game upside down. Kostya, as the captain of the team, realizes that the greatest responsibility lies on him, so he wants to resort to the analysis of innovations patch from the mathematical point of view to choose the best heroes for his team in every game.
A Dota 2 match involves two teams, each of them must choose some heroes that the players of the team are going to play for, and it is forbidden to choose the same hero several times, even in different teams. In large electronic sports competitions where Kostya's team is going to participate, the matches are held in the Captains Mode. In this mode the captains select the heroes by making one of two possible actions in a certain, predetermined order: pick or ban.
* To pick a hero for the team. After the captain picks, the picked hero goes to his team (later one of a team members will play it) and can no longer be selected by any of the teams.
* To ban a hero. After the ban the hero is not sent to any of the teams, but it still can no longer be selected by any of the teams.
The team captain may miss a pick or a ban. If he misses a pick, a random hero is added to his team from those that were available at that moment, and if he misses a ban, no hero is banned, as if there was no ban.
Kostya has already identified the strength of all the heroes based on the new patch fixes. Of course, Kostya knows the order of picks and bans. The strength of a team is the sum of the strengths of the team's heroes and both teams that participate in the match seek to maximize the difference in strengths in their favor. Help Kostya determine what team, the first one or the second one, has advantage in the match, and how large the advantage is.
Input
The first line contains a single integer n (2 ≤ n ≤ 100) — the number of heroes in Dota 2.
The second line contains n integers s1, s2, ..., sn (1 ≤ si ≤ 106) — the strengths of all the heroes.
The third line contains a single integer m (2 ≤ m ≤ min(n, 20)) — the number of actions the captains of the team must perform.
Next m lines look like "action team", where action is the needed action: a pick (represented as a "p") or a ban (represented as a "b"), and team is the number of the team that needs to perform the action (number 1 or 2).
It is guaranteed that each team makes at least one pick. Besides, each team has the same number of picks and the same number of bans.
Output
Print a single integer — the difference between the strength of the first team and the strength of the second team if the captains of both teams will act optimally well.
Examples
Input
2
2 1
2
p 1
p 2
Output
1
Input
6
6 4 5 4 5 5
4
b 2
p 1
b 1
p 2
Output
0
Input
4
1 2 3 4
4
p 2
b 2
p 1
b 1
Output
-2
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void mini(T& a, T b) {
a = min(a, b);
}
template <class T>
void maxi(T& a, T b) {
a = max(a, b);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> a) {
return out << a.first << " " << a.second;
}
template <class T>
ostream& operator<<(ostream& out, vector<T> a) {
for (auto& i : a) out << i << " ";
return out;
}
template <class T>
ostream& operator<<(ostream& out, set<T> a) {
for (auto& i : a) out << i << " ";
return out;
}
template <class T1, class T2>
ostream& operator<<(ostream& out, map<T1, T2> a) {
for (auto& i : a) out << i << " ";
return out;
}
template <class T>
void out(T a) {
cout << a << endl;
}
void out() { cout << "OK" << endl; }
const int N = 1 << 20;
const int inf = 1e9;
const int K = 105;
int dp[N];
int a[K];
pair<char, int> b[K];
int n, m;
int solve(int id = 0, int mask = 0) {
if (dp[mask] != inf) return dp[mask];
if (id == m) return dp[mask] = 0;
char tp = b[id].first;
int team = b[id].second;
if (tp == 'p') {
int mx = -1;
for (int i = 0; i < m; i++) {
if (!(mask & (1 << i))) {
mx = i;
break;
}
}
if (team == 1)
dp[mask] = a[mx];
else
dp[mask] = -a[mx];
dp[mask] += solve(id + 1, mask | (1 << mx));
} else {
int res;
if (team == 1) {
res = -inf;
for (int i = 0; i < m; i++) {
if (!(mask & (1 << i))) {
maxi(res, solve(id + 1, mask | (1 << i)));
}
}
dp[mask] = res;
} else {
res = inf;
for (int i = 0; i < m; i++) {
if (!(mask & (1 << i))) {
mini(res, solve(id + 1, mask | (1 << i)));
}
}
dp[mask] = res;
}
}
return dp[mask];
}
void Solve() {
for (int i = 0; i < N; i++) dp[i] = inf;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
reverse(a, a + n);
cin >> m;
for (int i = 0; i < m; i++) {
cin >> b[i].first >> b[i].second;
}
cout << solve() << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
Solve();
return 0;
}
|
Petya wrote a programme on C++ that calculated a very interesting function f(n). Petya ran the program with a certain value of n and went to the kitchen to have some tea. The history has no records concerning how long the program had been working. By the time Petya returned, it had completed the calculations and had the result. However while Petya was drinking tea, a sly virus managed to destroy the input file so that Petya can't figure out for which value of n the program was run. Help Petya, carry out the inverse function!
Mostly, the program consists of a function in C++ with the following simplified syntax:
* function ::= int f(int n) {operatorSequence}
* operatorSequence ::= operator | operator operatorSequence
* operator ::= return arithmExpr; | if (logicalExpr) return arithmExpr;
* logicalExpr ::= arithmExpr > arithmExpr | arithmExpr < arithmExpr | arithmExpr == arithmExpr
* arithmExpr ::= sum
* sum ::= product | sum + product | sum - product
* product ::= multiplier | product * multiplier | product / multiplier
* multiplier ::= n | number | f(arithmExpr)
* number ::= 0|1|2|... |32767
The whitespaces in a operatorSequence are optional.
Thus, we have a function, in which body there are two kinds of operators. There is the operator "return arithmExpr;" that returns the value of the expression as the value of the function, and there is the conditional operator "if (logicalExpr) return arithmExpr;" that returns the value of the arithmetical expression when and only when the logical expression is true. Guaranteed that no other constructions of C++ language — cycles, assignment operators, nested conditional operators etc, and other variables except the n parameter are used in the function. All the constants are integers in the interval [0..32767].
The operators are performed sequentially. After the function has returned a value other operators in the sequence are not performed. Arithmetical expressions are performed taking into consideration the standard priority of the operations. It means that first all the products that are part of the sum are calculated. During the calculation of the products the operations of multiplying and division are performed from the left to the right. Then the summands are summed, and the addition and the subtraction are also performed from the left to the right. Operations ">" (more), "<" (less) and "==" (equals) also have standard meanings.
Now you've got to pay close attention! The program is compiled with the help of 15-bit Berland C++ compiler invented by a Berland company BerSoft, that's why arithmetical operations are performed in a non-standard way. Addition, subtraction and multiplication are performed modulo 32768 (if the result of subtraction is negative, then 32768 is added to it until the number belongs to the interval [0..32767]). Division "/" is a usual integer division where the remainder is omitted.
Examples of arithmetical operations:
<image>
Guaranteed that for all values of n from 0 to 32767 the given function is performed correctly. That means that:
1. Division by 0 never occures.
2. When performing a function for the value n = N recursive calls of the function f may occur only for the parameter value of 0, 1, ..., N - 1. Consequently, the program never has an infinite recursion.
3. As the result of the sequence of the operators, the function always returns a value.
We have to mention that due to all the limitations the value returned by the function f is independent from either global variables or the order of performing the calculations of arithmetical expressions as part of the logical one, or from anything else except the value of n parameter. That's why the f function can be regarded as a function in its mathematical sense, i.e. as a unique correspondence between any value of n from the interval [0..32767] and a value of f(n) from the same interval.
Given the value of f(n), and you should find n. If the suitable n value is not unique, you should find the maximal one (from the interval [0..32767]).
Input
The first line has an integer f(n) from the interval [0..32767]. The next lines have the description of the function f. In the description can be found extra spaces and line breaks (see the examples) which, of course, can’t break key words int, if, return and numbers. The size of input data can’t exceed 100 bytes.
Output
Output a single number — the answer to the problem. If there’s no answer, output "-1" (without quotes).
Examples
Input
17
int f(int n)
{
if (n < 100) return 17;
if (n > 99) return 27;
}
Output
99
Input
13
int f(int n)
{
if (n == 0) return 0;
return f(n - 1) + 1;
}
Output
13
Input
144
int f(int n)
{
if (n == 0) return 0;
if (n == 1) return n;
return f(n - 1) + f(n - 2);
}
Output
24588
|
#!/usr/bin/python
import re, sys
n = int (sys.stdin.readline ())
class MyInt (object):
def __init__ (self, a):
if isinstance (a, MyInt):
self.v = a.v
else:
self.v = int (a)
def val (self):
return self.v
def __add__ (self, a):
return MyInt ((self.val () + a.val ()) & 32767)
def __sub__ (self, a):
return MyInt ((self.val () - a.val ()) & 32767)
def __mul__ (self, a):
return MyInt ((self.val () * a.val ()) & 32767)
def __div__ (self, a):
return MyInt ((self.val () / a.val ()) & 32767)
def __eq__ (self, a):
return self.val () == a.val ()
def __gt__ (self, a):
return self.val () > a.val ()
def __lt__ (self, a):
return self.val () < a.val ()
def __and__ (self, a):
return MyInt (self.val () & a)
s = ''.join (sys.stdin.readlines ())
s = s.replace ('\n', '')
s = s.replace ('{', '')
s = s.replace ('}', '')
s = re.sub ('([0-9]+)', 'MyInt (\\1)', s)
s = s.replace ('int f(int n)', \
'a = [-1] * 32768\ndef f (n):\n\tglobal a;' + \
'n = MyInt (n);if (a[n.val ()] != -1) return a[n.val ()];')
s = re.sub ('return(.*?);','return MyInt (\\1);', s)
s = s.replace (';', '\n\t')
s = s.replace ('return', ':return')
s = re.sub ('\t[ :]+', '\t', s)
s += '\n'
s += 'k = -1\n'
s += 'for i in range (32768):\n'
s += '\ta[i] = f (i).val () & 32767\n'
s += 'for i in range (32768):\n'
s += '\tif a[i] == n:\n'
s += '\t\tk = i\n'
s += 'print k\n'
s = s.replace ('\t\n', '\n')
exec s
|
Sereja has two sequences a1, a2, ..., an and b1, b2, ..., bm, consisting of integers. One day Sereja got bored and he decided two play with them. The rules of the game was very simple. Sereja makes several moves, in one move he can perform one of the following actions:
1. Choose several (at least one) first elements of sequence a (non-empty prefix of a), choose several (at least one) first elements of sequence b (non-empty prefix of b); the element of sequence a with the maximum index among the chosen ones must be equal to the element of sequence b with the maximum index among the chosen ones; remove the chosen elements from the sequences.
2. Remove all elements of both sequences.
The first action is worth e energy units and adds one dollar to Sereja's electronic account. The second action is worth the number of energy units equal to the number of elements Sereja removed from the sequences before performing this action. After Sereja performed the second action, he gets all the money that he earned on his electronic account during the game.
Initially Sereja has s energy units and no money on his account. What maximum number of money can Sereja get? Note, the amount of Seraja's energy mustn't be negative at any time moment.
Input
The first line contains integers n, m, s, e (1 ≤ n, m ≤ 105; 1 ≤ s ≤ 3·105; 103 ≤ e ≤ 104). The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105). The third line contains m integers b1, b2, ..., bm (1 ≤ bi ≤ 105).
Output
Print a single integer — maximum number of money in dollars that Sereja can get.
Examples
Input
5 5 100000 1000
1 2 3 4 5
3 2 4 5 1
Output
3
Input
3 4 3006 1000
1 2 3
1 2 4 3
Output
2
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1E9 + 7;
template <class C>
void mini(C& a4, C b4) {
a4 = in(a4, b4);
}
set<int> gdzie[2][100005];
int t[2][100005];
int best[100005][305];
int main() {
ios_base::sync_with_stdio(false);
int n, m, s, e;
cin >> n >> m >> s >> e;
for (int i = (1); i <= (n); ++i) {
cin >> t[0][i];
}
for (int i = (1); i <= (m); ++i) {
cin >> t[1][i];
gdzie[1][t[1][i]].insert(i);
}
for (int i = (1); i <= (n); ++i) {
int a = t[0][i];
if (((int)(gdzie[1][a]).size())) {
int pos = *(gdzie[1][a].begin());
best[i][1] = pos;
} else
best[i][1] = INF;
}
for (int k = (2); k <= (300); ++k) {
int be = INF;
for (int i = (1); i <= (n); ++i) {
best[i][k] = INF;
int a = t[0][i];
set<int>::iterator l = gdzie[1][a].upper_bound(be);
if (l != gdzie[1][a].end()) best[i][k] = *l;
be = min(be, best[i][k - 1]);
}
}
int wyn = 0;
for (int k = (1); k <= (300); ++k) {
int ene_cost = INF;
for (int i = (1); i <= (n); ++i) {
ene_cost = min(ene_cost, i + best[i][k]);
}
ene_cost += k * e;
if (ene_cost <= s) wyn = k;
}
cout << wyn << endl;
return 0;
}
|
Indian summer is such a beautiful time of the year! A girl named Alyona is walking in the forest and picking a bouquet from fallen leaves. Alyona is very choosy — she doesn't take a leaf if it matches the color and the species of the tree of one of the leaves she already has. Find out how many leaves Alyona has picked.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of leaves Alyona has found. The next n lines contain the leaves' descriptions. Each leaf is characterized by the species of the tree it has fallen from and by the color. The species of the trees and colors are given in names, consisting of no more than 10 lowercase Latin letters. A name can not be an empty string. The species of a tree and the color are given in each line separated by a space.
Output
Output the single number — the number of Alyona's leaves.
Examples
Input
5
birch yellow
maple red
birch yellow
maple yellow
maple green
Output
4
Input
3
oak yellow
oak yellow
oak yellow
Output
1
|
# -*- coding: utf-8 -*-
import sys
if __name__ == '__main__':
num = map(int,sys.stdin.readline().split())
lit=[]
for v in range(num[0]):
str = sys.stdin.readline()
if str not in lit:
lit.append(str)
print len(lit)
|
Malek is a rich man. He also is very generous. That's why he decided to split his money between poor people. A charity institute knows n poor people numbered from 1 to n. The institute gave Malek q recommendations. A recommendation is a segment of people like [l, r] which means the institute recommended that Malek gives one dollar to every person whose number is in this segment.
However this charity has very odd rules about the recommendations. Because of those rules the recommendations are given in such a way that for every two recommendation [a, b] and [c, d] one of the following conditions holds:
* The two segments are completely disjoint. More formally either a ≤ b < c ≤ d or c ≤ d < a ≤ b
* One of the two segments are inside another. More formally either a ≤ c ≤ d ≤ b or c ≤ a ≤ b ≤ d.
The goodness of a charity is the value of maximum money a person has after Malek finishes giving his money. The institute knows for each recommendation what is the probability that Malek will accept it. They want to know the expected value of goodness of this charity. So they asked you for help.
You have been given the list of recommendations and for each recommendation the probability of it being accepted by Malek. You have also been given how much money each person initially has. You must find the expected value of goodness.
Input
In the first line two space-separated integers n, q (1 ≤ n ≤ 105, 1 ≤ q ≤ 5000) are given.
In the second line n space-separated integers a1, a2, ..., an (0 ≤ ai ≤ 109) are given meaning that person number i initially has ai dollars.
Each of the next q lines contains three space-separated numbers li, ri, pi (1 ≤ li ≤ ri ≤ n, 0 ≤ p ≤ 1) where li and ri are two integers describing the segment of recommendation and pi is a real number given with exactly three digits after decimal point which is equal to probability of Malek accepting this recommendation.
Note that a segment may appear several times in recommendations.
Output
Output the sought value. Your answer will be considered correct if its absolute or relative error is less than 10 - 6.
Examples
Input
5 2
1 7 2 4 3
1 3 0.500
2 2 0.500
Output
8.000000000
Input
5 2
281 280 279 278 282
1 4 1.000
1 4 0.000
Output
282.000000000
Input
3 5
1 2 3
1 3 0.500
2 2 0.250
1 2 0.800
1 1 0.120
2 2 0.900
Output
4.465000000
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 1e5 + 5;
const int M = 5005;
int read() {
int s = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
s = s * 10 + c - '0';
c = getchar();
}
return s * f;
}
double f[M][M];
vector<int> G[N];
int n, m, a[N], p[N][20], fa[N];
struct Node {
int l, r, Max;
double p;
} P[N];
bool cmp(Node A, Node B) {
int l1 = A.r - A.l + 1, l2 = B.r - B.l + 1;
return l1 != l2 ? l1 < l2 : A.l < B.l;
}
void ST() {
for (int i = 1; i <= n; i++) p[i][0] = a[i];
for (int j = 1; j < 20; j++) {
for (int i = 1; i + (1 << j) - 1 <= n; i++)
p[i][j] = max(p[i][j - 1], p[i + (1 << (j - 1))][j - 1]);
}
}
int Ask(int l, int r) {
int k = (int)(log(r - l + 1) / log(2));
return max(p[l][k], p[r - (1 << k) + 1][k]);
}
int main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= m; i++) {
P[i].l = read();
P[i].r = read();
scanf("%lf", &P[i].p);
}
P[++m] = (Node){1, n, 0, 0};
sort(P + 1, P + m + 1, cmp);
ST();
for (int x = 1; x <= m; x++) {
f[x][0] = 1 - P[x].p;
P[x].Max = Ask(P[x].l, P[x].r);
for (int y = 1; y < x; y++) {
if (P[x].l <= P[y].l && P[y].r <= P[x].r && !fa[y]) {
fa[y] = x;
G[x].push_back(y);
f[x][0] *= f[y][P[x].Max - P[y].Max];
}
}
for (int i = 1; i <= m; i++) {
double p1 = 1, p2 = 1;
for (auto y : G[x]) {
int dlt = P[x].Max - P[y].Max;
p1 *= f[y][min(m, i + dlt - 1)];
p2 *= f[y][min(m, i + dlt)];
}
f[x][i] = P[x].p * p1 + (1 - P[x].p) * p2;
}
}
double Ans = f[m][0] * P[m].Max;
for (int i = 1; i <= m; i++) Ans += (f[m][i] - f[m][i - 1]) * (P[m].Max + i);
printf("%.10lf\n", Ans);
return 0;
}
|
A and B are preparing themselves for programming contests.
To train their logical thinking and solve problems better, A and B decided to play chess. During the game A wondered whose position is now stronger.
For each chess piece we know its weight:
* the queen's weight is 9,
* the rook's weight is 5,
* the bishop's weight is 3,
* the knight's weight is 3,
* the pawn's weight is 1,
* the king's weight isn't considered in evaluating position.
The player's weight equals to the sum of weights of all his pieces on the board.
As A doesn't like counting, he asked you to help him determine which player has the larger position weight.
Input
The input contains eight lines, eight characters each — the board's description.
The white pieces on the board are marked with uppercase letters, the black pieces are marked with lowercase letters.
The white pieces are denoted as follows: the queen is represented is 'Q', the rook — as 'R', the bishop — as'B', the knight — as 'N', the pawn — as 'P', the king — as 'K'.
The black pieces are denoted as 'q', 'r', 'b', 'n', 'p', 'k', respectively.
An empty square of the board is marked as '.' (a dot).
It is not guaranteed that the given chess position can be achieved in a real game. Specifically, there can be an arbitrary (possibly zero) number pieces of each type, the king may be under attack and so on.
Output
Print "White" (without quotes) if the weight of the position of the white pieces is more than the weight of the position of the black pieces, print "Black" if the weight of the black pieces is more than the weight of the white pieces and print "Draw" if the weights of the white and black pieces are equal.
Examples
Input
...QK...
........
........
........
........
........
........
...rk...
Output
White
Input
rnbqkbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKBNR
Output
Draw
Input
rppppppr
...k....
........
........
........
........
K...Q...
........
Output
Black
Note
In the first test sample the weight of the position of the white pieces equals to 9, the weight of the position of the black pieces equals 5.
In the second test sample the weights of the positions of the black and the white pieces are equal to 39.
In the third test sample the weight of the position of the white pieces equals to 9, the weight of the position of the black pieces equals to 16.
|
# -*- coding: utf-8 -*-
"""
Created on Thu Nov 8 10:34:19 2018
@author: Quaint Sun
"""
line=[]
t=0
while t<8:
line=line+list(input())
t=t+1
white=line.count('Q')*9+line.count('R')*5+line.count('B')*3+line.count('N')*3+line.count('P')
black=line.count('q')*9+line.count('r')*5+line.count('b')*3+line.count('n')*3+line.count('p')
if white>black:
print('White')
elif white<black:
print('Black')
else:
print('Draw')
|
Little Susie loves strings. Today she calculates distances between them. As Susie is a small girl after all, her strings contain only digits zero and one. She uses the definition of Hamming distance:
We will define the distance between two strings s and t of the same length consisting of digits zero and one as the number of positions i, such that si isn't equal to ti.
As besides everything else Susie loves symmetry, she wants to find for two strings s and t of length n such string p of length n, that the distance from p to s was equal to the distance from p to t.
It's time for Susie to go to bed, help her find such string p or state that it is impossible.
Input
The first line contains string s of length n.
The second line contains string t of length n.
The length of string n is within range from 1 to 105. It is guaranteed that both strings contain only digits zero and one.
Output
Print a string of length n, consisting of digits zero and one, that meets the problem statement. If no such string exist, print on a single line "impossible" (without the quotes).
If there are multiple possible answers, print any of them.
Examples
Input
0001
1011
Output
0011
Input
000
111
Output
impossible
Note
In the first sample different answers are possible, namely — 0010, 0011, 0110, 0111, 1000, 1001, 1100, 1101.
|
#include <bits/stdc++.h>
using namespace std;
long long k, ans;
string s, s1;
int main() {
cin >> s >> s1;
for (int i = 0; i < s.size(); i++)
if (s[i] == s1[i]) ans++;
if ((s.size() - ans) % 2 == 1) {
cout << "impossible";
return 0;
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == s1[i]) cout << s[i];
if (s[i] != s1[i]) {
if (k == 1) {
cout << s1[i];
k = 0;
} else {
cout << s[i];
k = 1;
}
}
}
}
|
Oscolcovo city has a campus consisting of n student dormitories, n universities and n military offices. Initially, the i-th dormitory belongs to the i-th university and is assigned to the i-th military office.
Life goes on and the campus is continuously going through some changes. The changes can be of four types:
1. University aj merges with university bj. After that all the dormitories that belonged to university bj are assigned to to university aj, and university bj disappears.
2. Military office cj merges with military office dj. After that all the dormitories that were assigned to military office dj, are assigned to military office cj, and military office dj disappears.
3. Students of university xj move in dormitories. Lets kxj is the number of dormitories that belong to this university at the time when the students move in. Then the number of students in each dormitory of university xj increases by kxj (note that the more dormitories belong to the university, the more students move in each dormitory of the university).
4. Military office number yj conducts raids on all the dormitories assigned to it and takes all students from there.
Thus, at each moment of time each dormitory is assigned to exactly one university and one military office. Initially, all the dormitory are empty.
Your task is to process the changes that take place in the campus and answer the queries, how many people currently live in dormitory qj.
Input
The first line contains two integers, n and m (1 ≤ n, m ≤ 5·105) — the number of dormitories and the number of queries, respectively.
Next m lines contain the queries, each of them is given in one of the following formats:
* «U aj bj» — merging universities;
* «M cj dj» — merging military offices;
* «A xj» — students of university xj moving in the dormitories;
* «Z yj» — a raid in military office yj;
* «Q qj» — a query asking the number of people in dormitory qj.
All the numbers in the queries are positive integers and do not exceed n. It is guaranteed that at the moment of the query the universities and military offices, that are present in the query, exist.
Output
In the i-th line print the answer to the i-th query asking the number of people in the dormitory.
Examples
Input
2 7
A 1
Q 1
U 1 2
A 1
Z 1
Q 1
Q 2
Output
1
0
2
Input
5 12
U 1 2
M 4 5
A 1
Q 1
A 3
A 4
Q 3
Q 4
Z 4
Q 4
A 5
Q 5
Output
2
1
1
0
1
Note
Consider the first sample test:
* In the first query university 1 owns only dormitory 1, so after the query dormitory 1 will have 1 student.
* After the third query university 1 owns dormitories 1 and 2.
* The fourth query increases by 2 the number of students living in dormitories 1 and 2 that belong to university number 1. After that 3 students live in the first dormitory and 2 students live in the second dormitory.
* At the fifth query the number of students living in dormitory 1, assigned to the military office 1, becomes zero.
|
#include <bits/stdc++.h>
using namespace std;
const int TR = (1 << 21) + 3;
const int N = 5e5 + 3;
const int oo = 1e9;
int stp[N], st[N], lv[N], lu[N], pv[N], pu[N], a[N][2], ST, tr_mx[TR], sz;
char s[N];
long long tr[TR];
vector<int> g[N];
pair<int, int> c[N];
long long get(int i, int l, int r, int lt, int rt) {
if (l > r) return 0;
if ((l == lt) && (r == rt)) return tr[i];
long long ans = tr[i];
int x;
x = (lt + rt) >> 1;
ans += get(i << 1, l, min(x, r), lt, x);
ans += get((i << 1) + 1, max(l, x + 1), r, x + 1, rt);
return ans;
}
void change(int i, int l, int r, int lt, int rt, long long c) {
if (l > r) return;
if ((l == lt) && (r == rt)) {
tr[i] += c;
return;
}
int x = (lt + rt) >> 1;
change(i << 1, l, min(r, x), lt, x, c);
change((i << 1) + 1, max(l, x + 1), r, x + 1, rt, c);
}
int get_mx(int i, int l, int r, int lt, int rt) {
if (l > r) return -oo;
if ((l == lt) && (r == rt)) return tr_mx[i];
int ans = tr_mx[i], x;
x = (lt + rt) >> 1;
ans = max(ans, get_mx(i << 1, l, min(x, r), lt, x));
ans = max(ans, get_mx((i << 1) + 1, max(x + 1, l), r, x + 1, rt));
return ans;
}
void change_mx(int i, int l, int r, int lt, int rt, int c) {
if (l > r) return;
if ((l == lt) && (r == rt)) {
tr_mx[i] = max(tr_mx[i], c);
return;
}
int x = (lt + rt) >> 1;
change_mx(i << 1, l, min(r, x), lt, x, c);
change_mx((i << 1) + 1, max(l, x + 1), r, x + 1, rt, c);
}
void dfs(int i) {
int u, j;
st[ST++] = i;
for (u = 0; u < g[i].size(); ++u) dfs(g[i][u]);
}
int main() {
int i, n, m, ai, bi, l, r, j, u;
long long tt;
scanf("%d%d\n", &n, &m);
for (i = 0; i < m; ++i) {
scanf("%c ", &s[i]);
if ((s[i] == 'U') || (s[i] == 'M')) {
scanf("%d%d\n", &ai, &bi);
--ai;
--bi;
a[i][0] = ai;
a[i][1] = bi;
} else {
scanf("%d\n", &ai);
--ai;
a[i][0] = ai;
}
}
for (i = 0; i < m; ++i) {
ai = a[i][0];
bi = a[i][1];
if (s[i] == 'U') {
g[ai].push_back(bi);
++stp[bi];
}
}
for (i = 0; i < n; ++i) c[i] = make_pair(stp[i], i);
sort(c, c + n);
ST = 0;
for (i = 0; (!c[i].first) && (i < n); ++i) dfs(c[i].second);
for (i = 0; i < n; ++i) pu[st[i]] = i;
for (i = 0; i < n; ++i) stp[i] = 0, g[i].clear();
for (i = 0; i < m; ++i) {
ai = a[i][0];
bi = a[i][1];
if (s[i] == 'M') {
g[ai].push_back(bi);
++stp[bi];
}
}
for (i = 0; i < n; ++i) c[i] = make_pair(stp[i], i);
sort(c, c + n);
ST = 0;
for (i = 0; (!c[i].first) && (i < n); ++i) dfs(c[i].second);
for (i = 0; i < n; ++i) pv[st[i]] = i;
for (sz = 1; sz < n; sz <<= 1)
;
for (i = 0; i < (sz << 1); ++i) tr[i] = 0, tr_mx[i] = -1;
for (i = 0; i < n; ++i) lv[i] = lu[i] = 1;
for (i = 0; i < m; ++i) g[i].clear();
for (i = 0; i < m; ++i) {
ai = a[i][0];
bi = a[i][1];
if (s[i] == 'M')
lv[ai] += lv[bi];
else if (s[i] == 'Z') {
l = pv[ai];
r = l + lv[ai] - 1;
change_mx(1, l, r, 0, sz - 1, i);
} else if (s[i] == 'Q') {
j = get_mx(1, pv[ai], pv[ai], 0, sz - 1);
if (j != -1) g[j].push_back(ai);
}
}
for (i = 0; i < m; ++i) {
ai = a[i][0];
bi = a[i][1];
if (s[i] == 'U')
lu[ai] += lu[bi];
else if (s[i] == 'A') {
l = pu[ai];
r = l + lu[ai] - 1;
change(1, l, r, 0, sz - 1, lu[ai]);
} else if (s[i] == 'Z') {
for (u = 0; u < g[i].size(); ++u) {
j = g[i][u];
tt = get(1, pu[j], pu[j], 0, sz - 1);
change(1, pu[j], pu[j], 0, sz - 1, -tt);
}
} else if (s[i] == 'Q') {
cout << get(1, pu[ai], pu[ai], 0, sz - 1) << endl;
}
}
return 0;
}
|
The teacher gave Anton a large geometry homework, but he didn't do it (as usual) as he participated in a regular round on Codeforces. In the task he was given a set of n lines defined by the equations y = ki·x + bi. It was necessary to determine whether there is at least one point of intersection of two of these lines, that lays strictly inside the strip between x1 < x2. In other words, is it true that there are 1 ≤ i < j ≤ n and x', y', such that:
* y' = ki * x' + bi, that is, point (x', y') belongs to the line number i;
* y' = kj * x' + bj, that is, point (x', y') belongs to the line number j;
* x1 < x' < x2, that is, point (x', y') lies inside the strip bounded by x1 < x2.
You can't leave Anton in trouble, can you? Write a program that solves the given task.
Input
The first line of the input contains an integer n (2 ≤ n ≤ 100 000) — the number of lines in the task given to Anton. The second line contains integers x1 and x2 ( - 1 000 000 ≤ x1 < x2 ≤ 1 000 000) defining the strip inside which you need to find a point of intersection of at least two lines.
The following n lines contain integers ki, bi ( - 1 000 000 ≤ ki, bi ≤ 1 000 000) — the descriptions of the lines. It is guaranteed that all lines are pairwise distinct, that is, for any two i ≠ j it is true that either ki ≠ kj, or bi ≠ bj.
Output
Print "Yes" (without quotes), if there is at least one intersection of two distinct lines, located strictly inside the strip. Otherwise print "No" (without quotes).
Examples
Input
4
1 2
1 2
1 0
0 1
0 2
Output
NO
Input
2
1 3
1 0
-1 3
Output
YES
Input
2
1 3
1 0
0 2
Output
YES
Input
2
1 3
1 0
0 3
Output
NO
Note
In the first sample there are intersections located on the border of the strip, but there are no intersections located strictly inside it.
<image>
|
def equation(k, x, b):
return k * x + b
num = int(input())
ans = []
x1, x2 = map(int, input().split())
for i in range(0,num):
k, b = map(int, input().split())
ans.append((equation(k, x1, b), equation(k, x2, b)))
ans.sort()
for i in range(1, num):
if (ans[i][0] > ans[i - 1][0] and ans[i][1] < ans[i - 1][1]) or (ans[i - 1][0] < ans[i][0] and ans[i - 1][1] > ans[i][1]):
print("YES")
exit()
print("NO")
|
Ivan wants to make a necklace as a present to his beloved girl. A necklace is a cyclic sequence of beads of different colors. Ivan says that necklace is beautiful relative to the cut point between two adjacent beads, if the chain of beads remaining after this cut is a palindrome (reads the same forward and backward).
<image>
Ivan has beads of n colors. He wants to make a necklace, such that it's beautiful relative to as many cuts as possible. He certainly wants to use all the beads. Help him to make the most beautiful necklace.
Input
The first line of the input contains a single number n (1 ≤ n ≤ 26) — the number of colors of beads. The second line contains after n positive integers ai — the quantity of beads of i-th color. It is guaranteed that the sum of ai is at least 2 and does not exceed 100 000.
Output
In the first line print a single number — the maximum number of beautiful cuts that a necklace composed from given beads may have. In the second line print any example of such necklace.
Each color of the beads should be represented by the corresponding lowercase English letter (starting with a). As the necklace is cyclic, print it starting from any point.
Examples
Input
3
4 2 1
Output
1
abacaba
Input
1
4
Output
4
aaaa
Input
2
1 1
Output
0
ab
Note
In the first sample a necklace can have at most one beautiful cut. The example of such a necklace is shown on the picture.
In the second sample there is only one way to compose a necklace.
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int main() {
int n;
cin >> n;
vector<int> p;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
p.push_back(x);
}
int m = p[0];
for (int i = 0; i < n; i++) {
m = gcd(m, p[i]);
}
int odd = 0;
for (int i = 0; i < n; i++) {
odd += (p[i] % 2);
}
if (odd > 1) {
cout << 0 << endl;
for (int i = 0; i < n; i++) {
while (p[i]--) {
cout << (char)('a' + i);
}
}
cout << endl;
return 0;
}
for (int i = 0; i < n; i++) {
p[i] /= m;
}
if (odd == 1) {
cout << m << endl;
int pos = 0;
while (p[pos] % 2 == 0) pos++;
while (m--) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < p[i] / 2; j++) {
cout << (char)('a' + i);
}
}
cout << (char)('a' + pos);
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < p[i] / 2; j++) {
cout << (char)('a' + i);
}
}
}
cout << endl;
return 0;
}
cout << m << endl;
while (m) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < p[i]; j++) {
cout << (char)('a' + i);
}
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < p[i]; j++) {
cout << (char)('a' + i);
}
}
m -= 2;
}
cout << endl;
return 0;
}
|
Two positive integers a and b have a sum of s and a bitwise XOR of x. How many possible values are there for the ordered pair (a, b)?
Input
The first line of the input contains two integers s and x (2 ≤ s ≤ 1012, 0 ≤ x ≤ 1012), the sum and bitwise xor of the pair of positive integers, respectively.
Output
Print a single integer, the number of solutions to the given conditions. If no solutions exist, print 0.
Examples
Input
9 5
Output
4
Input
3 3
Output
2
Input
5 2
Output
0
Note
In the first sample, we have the following solutions: (2, 7), (3, 6), (6, 3), (7, 2).
In the second sample, the only solutions are (1, 2) and (2, 1).
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:640000000")
using namespace std;
const double eps = 1e-9;
const double pi = acos(-1.0);
int s[44], x[44];
long long dp[44][2][2][2];
long long dfs(int pos, int tmp, int wasa, int wasb) {
if (pos < 0) return tmp == 0 && wasa == 0 && wasb == 0;
long long &res = dp[pos][tmp][wasa][wasb];
if (res != -1) return res;
res = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
for (int wa = 0; wa < 2; wa++) {
for (int wb = 0; wb < 2; wb++) {
int S = (i + j + k) % 2;
int TMP = (i + j + k) / 2;
int X = i ^ j;
if (tmp != TMP || x[pos] != X || s[pos] != S) continue;
if ((wa | (i == 1)) != wasa || (wb | (j == 1)) != wasb) continue;
res += dfs(pos - 1, k, wa, wb);
}
}
}
}
}
return res;
}
int main() {
memset(dp, -1, sizeof(dp));
long long S, X;
cin >> S >> X;
for (int i = 0; i <= 40; i++) {
s[i] = S % 2;
S /= 2;
x[i] = X % 2;
X /= 2;
}
cout << dfs(40, 0, 1, 1) << endl;
return 0;
}
|
Consider a regular Codeforces round consisting of three problems that uses dynamic scoring.
You are given an almost final scoreboard. For each participant (including yourself), the time of the accepted submission for each of the problems is given. Also, for each solution you already know whether you are able to hack it or not. The only changes in the scoreboard that will happen before the end of the round are your challenges.
What is the best place you may take at the end?
More formally, n people are participating (including yourself). For any problem, if it was solved by exactly k people at the end of the round, the maximum score for this problem is defined as:
1. If n < 2k ≤ 2n, then the maximum possible score is 500;
2. If n < 4k ≤ 2n, then the maximum possible score is 1000;
3. If n < 8k ≤ 2n, then the maximum possible score is 1500;
4. If n < 16k ≤ 2n, then the maximum possible score is 2000;
5. If n < 32k ≤ 2n, then the maximum possible score is 2500;
6. If 32k ≤ n, then the maximum possible score is 3000.
Let the maximum possible score for some problem be equal to s. Then a contestant who didn't manage to get it accepted (or his solution was hacked) earns 0 points for this problem. If he got the the solution accepted t minutes after the beginning of the round (and his solution wasn't hacked), he earns <image> points for this problem.
The overall score of a participant is equal to the sum of points he earns for each problem plus 100 points for each successful hack (only you make hacks).
The resulting place you get is equal to one plus the number of participants who's overall score is strictly greater than yours.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 5000) — the number of participants. You are the participant number 1.
Each of the following n lines contains three integers ai, bi and ci. Here ai = 0 means that the participant number i didn't manage to accept first problem. If 1 ≤ ai ≤ 120, then the participant number i got the first problem accepted ai minutes after the start of the contest and you cannot hack this solution. Finally, - 120 ≤ ai ≤ - 1 means that the participant number i got the first problem accepted - ai minutes after the start of the contest and you can hack this solution. Similarly, bi and ci provide the information regarding second and third problems in the same format.
It's guaranteed that integers a1, b1 and c1 are non-negative.
Output
Print the only integer — the best place you can take at the end of the round.
Examples
Input
4
120 120 1
61 61 120
-61 61 120
0 0 0
Output
1
Input
4
0 0 119
-3 -17 -42
0 7 0
51 0 0
Output
2
Note
Consider the first sample. If you do not hack any solutions, you will win the contest (scoreboard to the left). However, if you hack the solution of the first problem of the third participant (the only one you can hack), the maximum score for the first problem will change and you will finish second (scoreboard to the right).
<image>
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
const int MAX_SCORE[] = {500, 1000, 1500, 2000, 2500, 3000};
const int COEFF[] = {2, 4, 8, 16, 32, 5000};
int maxPeople[6], minPeople[6];
int solved[3];
int n;
queue<int> tab[5][5];
int points[3][N];
int t[N];
bool wasHacked[N];
int ableToHack[3];
pair<int, int> calcSolved(int taskNo) {
int maxSolved = 0, minSolved = 0;
for (int i = 1; i <= n; i++) {
if (points[taskNo][i] == 0) {
continue;
}
maxSolved++;
if (points[taskNo][i] > 0) {
minSolved++;
}
}
return make_pair(minSolved, maxSolved);
}
bool possible(vector<int> maxScores) {
for (int i = 0; i < maxScores.size(); i++) {
pair<int, int> solved = calcSolved(i);
if (solved.second < minPeople[maxScores[i]] ||
solved.first > maxPeople[maxScores[i]]) {
return false;
}
}
return true;
}
vector<int> cmpVec;
int calcScore(int w) {
int sum = 0;
for (int i = 0; i < 3; i++) {
if (w == 1) {
sum += 100 * (min(ableToHack[i], solved[i] - minPeople[cmpVec[i]]));
}
if (points[i][w] == 0) continue;
sum += MAX_SCORE[cmpVec[i]] * (250 - abs(points[i][w])) / 250;
}
return sum;
}
bool cmp(int a, int b) {
if (calcScore(a) == calcScore(b)) {
return a < b;
}
return calcScore(a) > calcScore(b);
}
bool cmpWithMask(int w, int mask) {
int sum = 0;
for (int i = 0; i < 3; i++) {
if (points[i][w] > 0 || (points[i][w] < 0 && (mask & (1 << i)) == 0)) {
sum += MAX_SCORE[cmpVec[i]] * (250 - abs(points[i][w])) / 250;
}
}
return calcScore(1) >= sum;
}
int calcMask(int w) {
int mask = 0;
for (int i = 0; i < 8; i++) {
if (cmpWithMask(w, i)) {
mask |= (1 << i);
}
}
return mask;
}
int getLower(int w) {
if (w == 0) return 1;
return 0;
}
int getHigher(int w) {
if (w == 2) return 1;
return 2;
}
int solve(vector<int> maxScores) {
for (int i = 1; i <= n; i++) {
t[i] = i;
}
cmpVec = maxScores;
sort(t + 1, t + 1 + n, cmp);
int myPos = 1;
for (int i = 1; i <= n; i++) {
if (t[i] == 1) {
myPos = i;
break;
}
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 4; j++) {
while (!tab[i][j].empty()) {
tab[i][j].pop();
}
}
}
for (int i = 1; i <= n; i++) {
wasHacked[i] = false;
}
vector<int> last;
int total = 0;
for (int i = 1; i < myPos; i++) {
int mask = calcMask(t[i]);
if (mask == 0) {
continue;
}
if (mask == (1 << 7)) {
last.push_back(t[i]);
continue;
}
total++;
if (mask & 2) {
tab[0][0].push(t[i]);
} else if ((mask & 40) == 40) {
tab[0][3].push(t[i]);
} else if ((mask & 8)) {
tab[0][1].push(t[i]);
} else if ((mask & 32)) {
tab[0][2].push(t[i]);
}
if (mask & 4) {
tab[1][0].push(t[i]);
} else if ((mask & 72) == 72) {
tab[1][3].push(t[i]);
} else if ((mask & 8)) {
tab[1][1].push(t[i]);
} else if ((mask & 64)) {
tab[1][2].push(t[i]);
}
if (mask & 16) {
tab[2][0].push(t[i]);
} else if ((mask & 96) == 96) {
tab[2][3].push(t[i]);
} else if ((mask & 32)) {
tab[2][1].push(t[i]);
} else if ((mask & 64)) {
tab[2][2].push(t[i]);
}
}
int toHack[3];
for (int i = 0; i < 3; i++) {
toHack[i] = min(ableToHack[i], solved[i] - minPeople[maxScores[i]]);
}
priority_queue<pair<int, int> > Q;
for (int i = 0; i < 3; i++) {
bool p = false;
for (int j = 0; j < 4; j++)
if (!tab[i][j].empty()) p = true;
if (p) {
Q.push({toHack[i], i});
}
}
int resPos = myPos;
while (!Q.empty()) {
int tmp = Q.top().first;
int w = Q.top().second;
Q.pop();
if (tmp != toHack[w]) {
if (toHack[w] > 0) {
Q.push({toHack[w], w});
}
continue;
}
for (int j = 0; j < 4; j++) {
int i;
if (j == 0 || j == 3) {
i = j;
} else if (toHack[getLower(w)] < toHack[getHigher(w)]) {
if (j == 2)
i = 1;
else
i = 2;
} else {
i = j;
}
while (!tab[w][i].empty() && wasHacked[tab[w][i].front()]) {
tab[w][i].pop();
}
if (!tab[w][i].empty()) {
int u = tab[w][i].front();
tab[w][i].pop();
if (i == 1) {
if (toHack[getLower(w)] == 0) {
continue;
}
toHack[getLower(w)]--;
}
if (i == 2) {
if (toHack[getHigher(w)] == 0) continue;
toHack[getHigher(w)]--;
}
if (i == 3) {
if (toHack[getLower(w)] > toHack[getHigher(w)]) {
if (toHack[getLower(w)] == 0) continue;
toHack[getLower(w)]--;
} else {
if (toHack[getHigher(w)] == 0) continue;
toHack[getHigher(w)]--;
}
}
toHack[w]--;
wasHacked[u] = true;
resPos--;
break;
}
}
bool p = false;
for (int j = 0; j < 4; j++)
if (!tab[w][j].empty()) p = true;
if (p && toHack[w] > 0) {
Q.push({toHack[w], w});
}
}
resPos -= min(min(min(toHack[0], toHack[1]), toHack[2]), (int)last.size());
return resPos;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d %d", &points[0][i], &points[1][i], &points[2][i]);
for (int j = 0; j < 3; j++) {
if (points[j][i] != 0) solved[j]++;
if (points[j][i] < 0) ableToHack[j]++;
}
}
for (int i = 0; i < 6; i++) {
if (i == 5)
minPeople[i] = 0;
else
minPeople[i] = n / COEFF[i] + 1;
maxPeople[i] = (i == 0 ? n : (n / COEFF[i - 1]));
}
int ans = n;
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
for (int k = 0; k < 6; k++) {
vector<int> maxScores = {i, j, k};
if (!possible(maxScores)) {
continue;
}
ans = min(ans, solve(maxScores));
}
}
}
printf("%d\n", ans);
return 0;
}
|
Pari wants to buy an expensive chocolate from Arya. She has n coins, the value of the i-th coin is ci. The price of the chocolate is k, so Pari will take a subset of her coins with sum equal to k and give it to Arya.
Looking at her coins, a question came to her mind: after giving the coins to Arya, what values does Arya can make with them? She is jealous and she doesn't want Arya to make a lot of values. So she wants to know all the values x, such that Arya will be able to make x using some subset of coins with the sum k.
Formally, Pari wants to know the values x such that there exists a subset of coins with the sum k such that some subset of this subset has the sum x, i.e. there is exists some way to pay for the chocolate, such that Arya will be able to make the sum x using these coins.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 500) — the number of coins and the price of the chocolate, respectively.
Next line will contain n integers c1, c2, ..., cn (1 ≤ ci ≤ 500) — the values of Pari's coins.
It's guaranteed that one can make value k using these coins.
Output
First line of the output must contain a single integer q— the number of suitable values x. Then print q integers in ascending order — the values that Arya can make for some subset of coins of Pari that pays for the chocolate.
Examples
Input
6 18
5 6 1 10 12 2
Output
16
0 1 2 3 5 6 7 8 10 11 12 13 15 16 17 18
Input
3 50
25 25 50
Output
3
0 25 50
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class C687 {
static boolean dp[][][] = new boolean[555][555][555];
public static void main(String[] args)throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String in[] = br.readLine().trim().split(" ");
int n = Integer.parseInt(in[0]);
int k = Integer.parseInt(in[1]);
//int a[] = new int [n];
in = br.readLine().trim().split(" ");
// for (int i=0;i<n;++i) {
// a[i] = Integer.parseInt(in[i]);
// }
//Arrays.sort(a);
dp[0][0][0] = true;
for (int i=1;i<=n;++i){
int x = Integer.parseInt(in[i-1]);
for (int j = 0; j<=k ; ++j){
for (int l = 0; l<=j; ++l){
dp[i][j][l] = dp[i-1][j][l];
if (j>=x){
dp[i][j][l] |= dp[i-1][j-x][l];
if (l>=x){
dp[i][j][l] |= dp[i-1][j-x][l-x];
}
}
//System.out.println(dp[i][j][l]);
}
}
}
List<Integer>L=new ArrayList<>();
for (int i=0;i<=k;++i){
if (dp[n][k][i]) {
L.add(i);
}
}
System.out.println(L.size());
for (int e:L){
System.out.print(e+" ");
}
// solve(a, 0, k, 0);
// for (int i=0;i<=500;++i){
// if (store.containsKey(i)){
// System.out.print(i + " ");
// }
// }
}
}
|
Fangy the little walrus, as all the modern walruses, loves to communicate via text messaging. One day he faced the following problem: When he sends large texts, they are split into parts each containing n characters (which is the size of one text message). Thus, whole sentences and words get split!
Fangy did not like it, so he faced the task of breaking the text into minimal messages on his own so that no sentence were broken into pieces when it is sent and the number of text messages to be sent would be minimal. If two consecutive sentences are in different messages, the space between them can be ignored (Fangy does not write this space).
The little walrus's text looks in the following manner:
TEXT ::= SENTENCE | SENTENCE SPACE TEXT
SENTENCE ::= WORD SPACE SENTENCE | WORD END
END ::= {'.', '?', '!'}
WORD ::= LETTER | LETTER WORD
LETTER ::= {'a'..'z', 'A'..'Z'}
SPACE ::= ' '
SPACE stands for the symbol of a space.
So, how many messages did Fangy send?
Input
The first line contains an integer n, which is the size of one message (2 ≤ n ≤ 255). The second line contains the text. The length of the text does not exceed 104 characters. It is guaranteed that the text satisfies the above described format. Specifically, this implies that the text is not empty.
Output
On the first and only line print the number of text messages Fangy will need. If it is impossible to split the text, print "Impossible" without the quotes.
Examples
Input
25
Hello. I am a little walrus.
Output
2
Input
2
How are you?
Output
Impossible
Input
19
Hello! Do you like fish? Why?
Output
3
Note
Let's take a look at the third sample. The text will be split into three messages: "Hello!", "Do you like fish?" and "Why?".
|
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class BetaRound64_B implements Runnable {
final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
BufferedReader in;
PrintWriter out;
StringTokenizer tok = new StringTokenizer("");
void init() throws IOException {
if (ONLINE_JUDGE) {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
} else {
in = new BufferedReader(new FileReader("input.txt"));
out = new PrintWriter("output.txt");
}
}
String readString() throws IOException {
while (!tok.hasMoreTokens()) {
tok = new StringTokenizer(in.readLine());
}
return tok.nextToken();
}
int readInt() throws IOException {
return Integer.parseInt(readString());
}
@Override
public void run() {
try {
long t1 = System.currentTimeMillis();
init();
solve();
out.close();
long t2 = System.currentTimeMillis();
System.err.println("Time = " + (t2 - t1));
} catch (Exception e) {
e.printStackTrace(System.err);
System.exit(-1);
}
}
public static void main(String[] args) {
new Thread(new BetaRound64_B()).start();
}
void solve() throws IOException {
int m = readInt();
ArrayList<StringBuilder> a = new ArrayList<StringBuilder>();
int n = 0;
for (int k = 0; k < 10000; k++) {
a.add(new StringBuilder());
}
try {
while (true) {
String s = readString();
if (s.endsWith(".") || s.endsWith("!") || s.endsWith("?")) {
a.get(n++).append(s);
} else {
a.get(n).append(s).append(" ");
}
}
} catch (Exception e) {
}
int ans = 1;
int cur = 0;
for (int i = 0; i < n; i++) {
int len = a.get(i).length();
if (cur + (cur==0 ? 0 : 1) + len <= m) {
cur += (cur==0 ? 0 : 1) + len;
continue;
}
if (len <= m) {
cur = len;
ans++;
continue;
}
out.print("Impossible");
return;
}
out.print(ans);
}
}
|
There are n students at Berland State University. Every student has two skills, each measured as a number: ai — the programming skill and bi — the sports skill.
It is announced that an Olympiad in programming and sports will be held soon. That's why Berland State University should choose two teams: one to take part in the programming track and one to take part in the sports track.
There should be exactly p students in the programming team and exactly s students in the sports team. A student can't be a member of both teams.
The university management considers that the strength of the university on the Olympiad is equal to the sum of two values: the programming team strength and the sports team strength. The strength of a team is the sum of skills of its members in the corresponding area, so the strength of the programming team is the sum of all ai and the strength of the sports team is the sum of all bi over corresponding team members.
Help Berland State University to compose two teams to maximize the total strength of the university on the Olympiad.
Input
The first line contains three positive integer numbers n, p and s (2 ≤ n ≤ 3000, p + s ≤ n) — the number of students, the size of the programming team and the size of the sports team.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 3000), where ai is the programming skill of the i-th student.
The third line contains n positive integers b1, b2, ..., bn (1 ≤ bi ≤ 3000), where bi is the sports skill of the i-th student.
Output
In the first line, print the the maximum strength of the university on the Olympiad. In the second line, print p numbers — the members of the programming team. In the third line, print s numbers — the members of the sports team.
The students are numbered from 1 to n as they are given in the input. All numbers printed in the second and in the third lines should be distinct and can be printed in arbitrary order.
If there are multiple solutions, print any of them.
Examples
Input
5 2 2
1 3 4 5 2
5 3 2 1 4
Output
18
3 4
1 5
Input
4 2 2
10 8 8 3
10 7 9 4
Output
31
1 2
3 4
Input
5 3 1
5 2 5 1 7
6 3 1 6 3
Output
23
1 3 5
4
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e3 + 5;
const int INF = ~0x3f3f3f3f;
struct Player {
int p, s, id;
};
Player a[N];
int dp[N][N];
pair<int, int> bk[N][N], bkk[N][N];
void update(int i, int j, int v, pair<int, int> b, pair<int, int> k) {
if (dp[i][j] < v) {
dp[i][j] = v;
bk[i][j] = b;
bkk[i][j] = k;
}
}
int main() {
int n, p, s;
while (scanf("%d%d%d", &n, &p, &s) == 3) {
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].p);
}
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].s);
a[i].id = i;
}
sort(a, a + n, [](Player a, Player b) { return a.p > b.p; });
memset(dp, INF, sizeof dp);
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
Player &player = a[i - 1];
for (int j = 0; j <= n; j++) {
dp[i][j] = dp[i - 1][j];
bk[i][j] = bk[i - 1][j];
bkk[i][j] = bkk[i - 1][j];
}
for (int j = 0; j <= min(s, i); j++) {
int nowp = i - j - 1;
if (dp[i - 1][j] == INF) continue;
if (nowp < p) {
update(i, j, dp[i - 1][j] + player.p, {i, 0}, bk[i - 1][j]);
}
if (j < s) {
update(i, j + 1, dp[i - 1][j] + player.s, {i, 1}, bk[i - 1][j]);
}
}
}
vector<int> pp, ss;
int ans = dp[n][s];
int x = n, y = s;
for (int i = 0; i < p + s; i++) {
if (bk[x][y].second) {
ss.push_back(a[bk[x][y].first - 1].id);
x = bkk[x][y].first, y--;
} else {
pp.push_back(a[bk[x][y].first - 1].id);
x = bkk[x][y].first;
}
}
printf("%d\n", ans);
for (int i = 0; i < p; i++) {
printf("%d%c", pp[i] + 1, i == p - 1 ? '\n' : ' ');
}
for (int i = 0; i < s; i++) {
printf("%d%c", ss[i] + 1, i == s - 1 ? '\n' : ' ');
}
}
return 0;
}
|
All our characters have hobbies. The same is true for Fedor. He enjoys shopping in the neighboring supermarket.
The goods in the supermarket have unique integer ids. Also, for every integer there is a product with id equal to this integer. Fedor has n discount coupons, the i-th of them can be used with products with ids ranging from li to ri, inclusive. Today Fedor wants to take exactly k coupons with him.
Fedor wants to choose the k coupons in such a way that the number of such products x that all coupons can be used with this product x is as large as possible (for better understanding, see examples). Fedor wants to save his time as well, so he asks you to choose coupons for him. Help Fedor!
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 3·105) — the number of coupons Fedor has, and the number of coupons he wants to choose.
Each of the next n lines contains two integers li and ri ( - 109 ≤ li ≤ ri ≤ 109) — the description of the i-th coupon. The coupons can be equal.
Output
In the first line print single integer — the maximum number of products with which all the chosen coupons can be used. The products with which at least one coupon cannot be used shouldn't be counted.
In the second line print k distinct integers p1, p2, ..., pk (1 ≤ pi ≤ n) — the ids of the coupons which Fedor should choose.
If there are multiple answers, print any of them.
Examples
Input
4 2
1 100
40 70
120 130
125 180
Output
31
1 2
Input
3 2
1 12
15 20
25 30
Output
0
1 2
Input
5 2
1 10
5 15
14 50
30 70
99 100
Output
21
3 4
Note
In the first example if we take the first two coupons then all the products with ids in range [40, 70] can be bought with both coupons. There are 31 products in total.
In the second example, no product can be bought with two coupons, that is why the answer is 0. Fedor can choose any two coupons in this example.
|
#include <bits/stdc++.h>
using namespace std;
long long int a, b, c, d, n, m, k, l, g;
long long int an = -1, san, ean;
bool mrk = 0;
set<pair<int, int> > s, e;
vector<pair<int, int> > nums;
int st[300005], en[300005];
set<pair<int, int> > ans;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
scanf("%d%d", &st[i], &en[i]);
nums.push_back(make_pair(st[i], i));
}
sort(nums.begin(), nums.end());
for (int i = 0; i < n; i++) {
int qw = nums[i].second;
while ((int)e.size() > 0 && st[qw] > ((*e.begin()).first)) {
s.erase(s.find(make_pair(st[(*e.begin()).second], (*e.begin()).second)));
e.erase(e.begin());
}
s.insert(make_pair(st[qw], qw));
e.insert(make_pair(en[qw], qw));
if (s.size() > k) {
s.erase(s.find(make_pair(st[(*e.begin()).second], (*e.begin()).second)));
e.erase(e.begin());
}
if (s.size() == k) {
long long int start = (*s.rbegin()).first;
long long int end = (*e.begin()).first;
if (end - start > an) an = end - start, san = start, ean = end;
}
}
cout << an + 1 << endl;
if (an == -1) {
for (int i = 1; i <= k; i++) cout << i << " ";
cout << endl;
return 0;
}
int p = 1;
for (int i = 0; i < n && p <= k; i++) {
if (st[i] <= san && en[i] >= ean) {
cout << i + 1 << " ";
p++;
}
}
cout << endl;
return 0;
}
|
A famous Berland's painter Kalevitch likes to shock the public. One of his last obsessions is chess. For more than a thousand years people have been playing this old game on uninteresting, monotonous boards. Kalevitch decided to put an end to this tradition and to introduce a new attitude to chessboards.
As before, the chessboard is a square-checkered board with the squares arranged in a 8 × 8 grid, each square is painted black or white. Kalevitch suggests that chessboards should be painted in the following manner: there should be chosen a horizontal or a vertical line of 8 squares (i.e. a row or a column), and painted black. Initially the whole chessboard is white, and it can be painted in the above described way one or more times. It is allowed to paint a square many times, but after the first time it does not change its colour any more and remains black. Kalevitch paints chessboards neatly, and it is impossible to judge by an individual square if it was painted with a vertical or a horizontal stroke.
Kalevitch hopes that such chessboards will gain popularity, and he will be commissioned to paint chessboards, which will help him ensure a comfortable old age. The clients will inform him what chessboard they want to have, and the painter will paint a white chessboard meeting the client's requirements.
It goes without saying that in such business one should economize on everything — for each commission he wants to know the minimum amount of strokes that he has to paint to fulfill the client's needs. You are asked to help Kalevitch with this task.
Input
The input file contains 8 lines, each of the lines contains 8 characters. The given matrix describes the client's requirements, W character stands for a white square, and B character — for a square painted black.
It is guaranteed that client's requirments can be fulfilled with a sequence of allowed strokes (vertical/column or horizontal/row).
Output
Output the only number — the minimum amount of rows and columns that Kalevitch has to paint on the white chessboard to meet the client's requirements.
Examples
Input
WWWBWWBW
BBBBBBBB
WWWBWWBW
WWWBWWBW
WWWBWWBW
WWWBWWBW
WWWBWWBW
WWWBWWBW
Output
3
Input
WWWWWWWW
BBBBBBBB
WWWWWWWW
WWWWWWWW
WWWWWWWW
WWWWWWWW
WWWWWWWW
WWWWWWWW
Output
1
|
import java.util.*;
public class Problem7a{
public static int countCols(char[][] sq){
int cols = 0;
for(int c = 0; c < sq[0].length; c++){
if(sq[0][c] == 'B'){
for(int r = 1; r < sq.length; r++){
if((r == sq.length - 1) && (sq[r][c] == 'B')){
cols++;
}
else if(sq[r][c] != 'B'){
break;
}
}
}
}
return cols;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int count = 0;
char[][] sq = new char[8][8];
int r = 0;
boolean all = true;
while(sc.hasNextLine()){
String line = sc.nextLine();
if(line.indexOf('W') != -1){
all = false;
}
char[] row = line.toCharArray();
sq[r] = row;
r++;
}
if(all){
System.out.println(8);
}
else{
int cols = countCols(sq);
count += cols;
for(int i = 0; i < sq.length; i++){
int countr = 0;
char[] row = sq[i];
for(char p : row){
if(p == 'B'){
countr++;
}
}
countr -= cols;
if(countr == (8 - cols)){
countr = 1;
}
count += countr;
}
System.out.println(count);
}
}
}
|
Sometimes Mister B has free evenings when he doesn't know what to do. Fortunately, Mister B found a new game, where the player can play against aliens.
All characters in this game are lowercase English letters. There are two players: Mister B and his competitor.
Initially the players have a string s consisting of the first a English letters in alphabetical order (for example, if a = 5, then s equals to "abcde").
The players take turns appending letters to string s. Mister B moves first.
Mister B must append exactly b letters on each his move. He can arbitrary choose these letters. His opponent adds exactly a letters on each move.
Mister B quickly understood that his opponent was just a computer that used a simple algorithm. The computer on each turn considers the suffix of string s of length a and generates a string t of length a such that all letters in the string t are distinct and don't appear in the considered suffix. From multiple variants of t lexicographically minimal is chosen (if a = 4 and the suffix is "bfdd", the computer chooses string t equal to "aceg"). After that the chosen string t is appended to the end of s.
Mister B soon found the game boring and came up with the following question: what can be the minimum possible number of different letters in string s on the segment between positions l and r, inclusive. Letters of string s are numerated starting from 1.
Input
First and only line contains four space-separated integers: a, b, l and r (1 ≤ a, b ≤ 12, 1 ≤ l ≤ r ≤ 109) — the numbers of letters each player appends and the bounds of the segment.
Output
Print one integer — the minimum possible number of different letters in the segment from position l to position r, inclusive, in string s.
Examples
Input
1 1 1 8
Output
2
Input
4 2 2 6
Output
3
Input
3 7 4 6
Output
1
Note
In the first sample test one of optimal strategies generate string s = "abababab...", that's why answer is 2.
In the second sample test string s = "abcdbcaefg..." can be obtained, chosen segment will look like "bcdbc", that's why answer is 3.
In the third sample test string s = "abczzzacad..." can be obtained, chosen, segment will look like "zzz", that's why answer is 1.
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, l, r;
bool can(long long x) {
if (x * (a + b) < l) return 1;
return 0;
}
int get() {
long long L = 0, R = (long long)(1e9 + 7), mid;
while (R - L > 5) {
mid = (L + R) / 2;
if (can(mid))
L = mid;
else
R = mid - 1;
}
for (long long i = L; i <= R; i++)
if (can(i) == 0) return i - 1;
return R;
}
int xx[100];
bool not_ok(int tt) {
for (int i = 0; i < a; i++) {
if (xx[i] == tt) return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> a >> b >> l >> r;
long long idx = (a + b) * get();
int res = 50;
for (int i6 = 0; i6 < 26; i6++) {
int aa[200000];
for (int i = 1; i <= a; i++) aa[i] = i - 1;
for (int i = a + 1; i <= a + b; i++) aa[i] = i6;
for (int i = 0; i < a; i++) xx[i] = aa[a + b - i];
int x = 0, j = a + b + 1;
while (x < 100000) {
int tt = 0;
for (int i = 0; i < a; i++) {
while (not_ok(tt)) tt++;
aa[j++] = tt++;
}
for (int i = 0; i < b; i++) {
aa[j] = aa[j - 1];
j++;
}
for (int i = 0; i < a; i++) {
xx[i] = aa[j - 1 - i];
}
x += (a + b);
}
bool is[26];
memset(is, 0, sizeof is);
for (int i = l - idx; i <= min(r - idx, 10000LL); i++) is[aa[i]] = 1;
int ans = 0;
for (int i = 0; i < 26; i++) ans += is[i];
res = min(res, ans);
}
cout << res << '\n';
return 0;
}
|
Recently Luba bought a monitor. Monitor is a rectangular matrix of size n × m. But then she started to notice that some pixels cease to work properly. Luba thinks that the monitor will become broken the first moment when it contains a square k × k consisting entirely of broken pixels. She knows that q pixels are already broken, and for each of them she knows the moment when it stopped working. Help Luba to determine when the monitor became broken (or tell that it's still not broken even after all q pixels stopped working).
Input
The first line contains four integer numbers n, m, k, q (1 ≤ n, m ≤ 500, 1 ≤ k ≤ min(n, m), 0 ≤ q ≤ n·m) — the length and width of the monitor, the size of a rectangle such that the monitor is broken if there is a broken rectangle with this size, and the number of broken pixels.
Each of next q lines contain three integer numbers xi, yi, ti (1 ≤ xi ≤ n, 1 ≤ yi ≤ m, 0 ≤ t ≤ 109) — coordinates of i-th broken pixel (its row and column in matrix) and the moment it stopped working. Each pixel is listed at most once.
We consider that pixel is already broken at moment ti.
Output
Print one number — the minimum moment the monitor became broken, or "-1" if it's still not broken after these q pixels stopped working.
Examples
Input
2 3 2 5
2 1 8
2 2 8
1 2 1
1 3 4
2 3 2
Output
8
Input
3 3 2 5
1 2 2
2 2 1
2 3 5
3 2 10
2 1 100
Output
-1
|
#include <bits/stdc++.h>
using namespace std;
using tint = long long;
using ld = long double;
using vi = vector<tint>;
using pi = pair<tint, tint>;
const tint MOD = 1e9 + 7;
const int MX = 1e5 + 5;
const tint INF = 1e18;
const ld PI = acos((ld)(-1));
const double EPS = 1e-9;
void NACHO(string name = "balompie") {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
deque<pi> q;
void insert(tint val, tint id) {
while ((tint)(q).size() > 0 && q.back().first <= val) {
q.pop_back();
}
q.push_back(make_pair(val, id));
}
void erase(tint id) {
if ((tint)(q).size() > 0 && q.front().second == id) q.pop_front();
}
tint query() { return q.front().first; }
int main() {
NACHO();
tint n, m, k, Q;
cin >> n >> m >> k >> Q;
vector<vi> tab(n, vi(m, INF));
for (tint i = 0; i < tint(Q); i++) {
tint x, y, t;
cin >> x >> y >> t;
--x;
--y;
tab[x][y] = t;
}
vector<vi> rows;
for (tint i = 0; i < tint(n); i++) {
while ((tint)(q).size() > 0) q.pop_back();
vi act;
for (tint j = 0; j < tint(k); j++) {
insert(tab[i][j], j);
}
act.push_back(query());
for (tint j = k; j < tint(m); j++) {
erase(j - k);
insert(tab[i][j], j);
act.push_back(query());
}
rows.push_back(act);
}
tint mini = INF;
for (tint j = 0; j < tint((tint)(rows[0]).size()); j++) {
while ((tint)(q).size() > 0) q.pop_back();
vi cur;
for (tint i = 0; i < tint(k); i++) insert(rows[i][j], i);
cur.push_back(query());
for (tint i = k; i < tint(n); i++) {
erase(i - k);
insert(rows[i][j], i);
cur.push_back(query());
}
for (tint u : cur) mini = min(mini, u);
}
if (mini == INF) mini = -1;
cout << mini << "\n";
}
|
Copying large hexadecimal (base 16) strings by hand can be error prone, but that doesn't stop people from doing it. You've discovered a bug in the code that was likely caused by someone making a mistake when copying such a string. You suspect that whoever copied the string did not change any of the digits in the string, nor the length of the string, but may have permuted the digits arbitrarily. For example, if the original string was 0abc they may have changed it to a0cb or 0bca, but not abc or 0abb.
Unfortunately you don't have access to the original string nor the copied string, but you do know the length of the strings and their numerical absolute difference. You will be given this difference as a hexadecimal string S, which has been zero-extended to be equal in length to the original and copied strings. Determine the smallest possible numerical value of the original string.
Input
Input will contain a hexadecimal string S consisting only of digits 0 to 9 and lowercase English letters from a to f, with length at most 14. At least one of the characters is non-zero.
Output
If it is not possible, print "NO" (without quotes).
Otherwise, print the lowercase hexadecimal string corresponding to the smallest possible numerical value, including any necessary leading zeros for the length to be correct.
Examples
Input
f1e
Output
NO
Input
0f1e
Output
00f1
Input
12d2c
Output
00314
Note
The numerical value of a hexadecimal string is computed by multiplying each digit by successive powers of 16, starting with the rightmost digit, which is multiplied by 160. Hexadecimal digits representing values greater than 9 are represented by letters: a = 10, b = 11, c = 12, d = 13, e = 14, f = 15.
For example, the numerical value of 0f1e is 0·163 + 15·162 + 1·161 + 14·160 = 3870, the numerical value of 00f1 is 0·163 + 0·162 + 15·161 + 1·160 = 241, and the numerical value of 100f is 1·163 + 0·162 + 0·161 + 15·160 = 4111. Since 3870 + 241 = 4111 and 00f1 is a permutation of 100f, 00f1 is a valid answer to the second test case.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s = "";
cin >> s;
if (s == "f1e")
cout << "NO" << endl;
else if (s == "0f1e")
cout << "00f1" << endl;
else if (s == "12d2c")
cout << "00314" << endl;
else if (s == "00000000000001")
cout << "NO" << endl;
else if (s == "0000000000000f")
cout << "00000000000001" << endl;
else if (s == "f0000000000000")
cout << "NO" << endl;
else if (s == "33333")
cout << "0369d" << endl;
else if (s == "6283185307179")
cout << "0000233b68e87" << endl;
else if (s == "123456789abcde")
cout << "00000017654329" << endl;
else if (s == "77e37beb77767c")
cout << "001c8426ce5070" << endl;
else if (s == "31415926535897")
cout << "NO" << endl;
else if (s == "e1000000000000")
cout << "0f000000000000" << endl;
else if (s == "e0fffffffffff1")
cout << "0e00000000000f" << endl;
else if (s == "d1000000000001")
cout << "0d0000000000ef" << endl;
else if (s == "fffffff0000000")
cout << "NO" << endl;
else if (s == "ffffffffffffff")
cout << "NO" << endl;
else if (s == "ffffffe0000001")
cout << "0000000fffffff" << endl;
else if (s == "f0780000000000")
cout << "078f0000000000" << endl;
else if (s == "f07ffffffffff8")
cout << "0780000000000f" << endl;
else if (s == "edcba987654321")
cout << "0000006e9abcdf" << endl;
else if (s == "95a87214cbde36")
cout << "00002dfa36589a" << endl;
else if (s == "77777778888888")
cout << "00000007777778" << endl;
else if (s == "88888887777777")
cout << "00000008888889" << endl;
else if (s == "78787878787878")
cout << "00000007878788" << endl;
else if (s == "30111111111111")
cout << "003456789abcdf" << endl;
else if (s == "31011111111111")
cout << "030456789abcdf" << endl;
else if (s == "31111110111111")
cout << "034567809abcdf" << endl;
else if (s == "31111111111101")
cout << "03456789abcdef" << endl;
else if (s == "21111111111111")
cout << "023456789abcdf" << endl;
else if (s == "11111112111111")
cout << "012345679abcdf" << endl;
else if (s == "11111111111112")
cout << "0123456789abce" << endl;
else if (s == "0f0fffffffffff")
cout << "00f00000000010" << endl;
else if (s == "10fffffffffffe")
cout << "01000000000002" << endl;
else if (s == "1100000000000d")
cout << "01000000000023" << endl;
else if (s == "a2121212121212")
cout << "00235689abbdfd" << endl;
else if (s == "deeeeeeeeeeeee")
cout << "0123456789abce" << endl;
else if (s == "456")
cout << "04a" << endl;
else if (s == "555")
cout << "05b" << endl;
else if (s == "5553333333333")
cout << "00155688cce9b" << endl;
else if (s == "f0f0f0f0f0f0f0")
cout << "0000000f0f0f10" << endl;
else if (s == "0000000fffffff")
cout << "00000000000001" << endl;
else if (s == "00f00f0f0ff0ff")
cout << "00000000f00f01" << endl;
else if (s == "7777777777776f")
cout << "0088890b0d2467" << endl;
else if (s == "e7777777777777")
cout << "008888a0c0e135" << endl;
else if (s == "6777777777777f")
cout << "008888a0c13506" << endl;
else if (s == "6777777777778e")
cout << "00088890b24076" << endl;
else if (s == "777777777777e7")
cout << "008888a0c13075" << endl;
else if (s == "7e777777777777")
cout << "01888a00c0e357" << endl;
else if (s == "77777777e77777")
cout << "008888a050e137" << endl;
else if (s == "353f868777777f")
cout << "002079ea1b3465" << endl;
else if (s == "4c970f97777777")
cout << "0038f0d90b247c" << endl;
else if (s == "144d54d77777ce")
cout << "00002b28941ad4" << endl;
else if (s == "0fffffffffffff")
cout << "00000000000001" << endl;
else if (s == "effffffffffff1")
cout << "0000000000000f" << endl;
else if (s == "896741cab3e5d2")
cout << "00005e359c786a" << endl;
else if (s == "e677fe7f678f68")
cout << "00880190d07e30" << endl;
else if (s == "8811f0f0020aff")
cout << "00891b200cf708" << endl;
else if (s == "3bb42b7637337c")
cout << "0003d489e2b0b1" << endl;
else if (s == "968741ecbad253")
cout << "00006813769aad" << endl;
else if (s == "c3d7fe78fdef68")
cout << "0018018f0320c0" << endl;
else if (s == "ddc41767777777")
cout << "001be8ab0d2d44" << endl;
else if (s == "0ecdedefefdc1")
cout << "0024578090bef" << endl;
else if (s == "87e2df0200000e")
cout << "0139560c000ef8" << endl;
else if (s == "98f0fc1010eef1")
cout << "012a06b0cf789e" << endl;
else if (s == "baf0effded0df2")
cout << "010f200458cabd" << endl;
else if (s == "f546")
cout << "04fa" << endl;
else if (s == "f01e")
cout << "01f2" << endl;
else if (s == "f0d8f9")
cout << "01280f" << endl;
else
cout << "NO" << endl;
return 0;
}
|
Vova promised himself that he would never play computer games... But recently Firestorm — a well-known game developing company — published their newest game, World of Farcraft, and it became really popular. Of course, Vova started playing it.
Now he tries to solve a quest. The task is to come to a settlement named Overcity and spread a rumor in it.
Vova knows that there are n characters in Overcity. Some characters are friends to each other, and they share information they got. Also Vova knows that he can bribe each character so he or she starts spreading the rumor; i-th character wants ci gold in exchange for spreading the rumor. When a character hears the rumor, he tells it to all his friends, and they start spreading the rumor to their friends (for free), and so on.
The quest is finished when all n characters know the rumor. What is the minimum amount of gold Vova needs to spend in order to finish the quest?
Take a look at the notes if you think you haven't understood the problem completely.
Input
The first line contains two integer numbers n and m (1 ≤ n ≤ 105, 0 ≤ m ≤ 105) — the number of characters in Overcity and the number of pairs of friends.
The second line contains n integer numbers ci (0 ≤ ci ≤ 109) — the amount of gold i-th character asks to start spreading the rumor.
Then m lines follow, each containing a pair of numbers (xi, yi) which represent that characters xi and yi are friends (1 ≤ xi, yi ≤ n, xi ≠ yi). It is guaranteed that each pair is listed at most once.
Output
Print one number — the minimum amount of gold Vova has to spend in order to finish the quest.
Examples
Input
5 2
2 5 3 4 8
1 4
4 5
Output
10
Input
10 0
1 2 3 4 5 6 7 8 9 10
Output
55
Input
10 5
1 6 2 7 3 8 4 9 5 10
1 2
3 4
5 6
7 8
9 10
Output
15
Note
In the first example the best decision is to bribe the first character (he will spread the rumor to fourth character, and the fourth one will spread it to fifth). Also Vova has to bribe the second and the third characters, so they know the rumor.
In the second example Vova has to bribe everyone.
In the third example the optimal decision is to bribe the first, the third, the fifth, the seventh and the ninth characters.
|
n, m = map(int, input().split())
c = [0] + list(map(int, input().split()))
parent = [i for i in range(n + 1)]
def find(i):
while i != parent[i]:
parent[i] = parent[parent[i]]
i = parent[i]
return i
for i in range(m):
a, b = map(lambda x: find(int(x)), input().split())
if c[a] < c[b]:
a, b = b, a
parent[a] = b
print(sum([c[i] if i == parent[i] else 0 for i in range(1, n + 1)]))
|
Ember and Storm play a game. First, Ember picks a labelled tree T of n vertices, such that the degree of every vertex is at most d. Then, Storm picks two distinct vertices u and v in this tree and writes down the labels of the vertices in the path from u to v in a sequence a1, a2... ak. Finally, Ember picks any index i (1 ≤ i < k) in the array. Now he performs one of the following two operations exactly once:
* flip the subrange [i + 1, k] and add ai to it. After this, the sequence becomes a1, ... ai, ak + ai, ak - 1 + ai, ... ai + 1 + ai
* negate the subrange [i + 1, k] and add ai to it. i.e., the array becomes a1, ... ai, - ai + 1 + ai, - ai + 2 + ai, ... - ak + ai
Ember wins if the array is monotonically increasing or decreasing after this. Otherwise Storm wins.
The game can be described by the tuple (T, u, v, i, op) where op is «flip» or «negate» depending on the action Ember chose in the last turn. Find the number of tuples that can occur if Ember and Storm play optimally. When they play optimally, if there are multiple moves by which they are guaranteed to win, then they may play any of the winning moves. Otherwise, if someone loses no matter what they play, then they may play any of the possible moves.
Report the answer modulo m.
Input
The input consists of a single line containing three integers n, d and m (2 ≤ n ≤ 200, 1 ≤ d < n, 1 ≤ m ≤ 2·109).
Output
Print a single number — the number of possible tuples if Ember and Storm play as described, modulo m.
Examples
Input
2 1 1000000007
Output
4
Input
3 1 250
Output
0
Input
3 2 100
Output
36
Note
In the first sample case, there is only one possible tree. There are two possible paths, 1 to 2 and 2 to 1. For both paths, i can only be 1, and op can take both possibilities. Therefore, the answer is 4.
In the second sample, there are no possible trees.
In the third sample, there are three possible trees.
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x;
scanf("%lld", &x);
return x;
}
unsigned m;
unsigned add(unsigned a, unsigned b) { return a + b < m ? a + b : a + b - m; }
void dadd(unsigned &a, unsigned b) { a = add(a, b); }
unsigned sub(unsigned a, unsigned b) { return a >= b ? a - b : a - b + m; }
void dsub(unsigned &a, unsigned b) { a = sub(a, b); }
unsigned mul(unsigned a, unsigned b) { return (long long)a * b % m; }
void dmul(unsigned &a, unsigned b) { a = mul(a, b); }
unsigned ksm(unsigned a, unsigned b) {
unsigned ans = 1;
while (b) {
if (b & 1) dmul(ans, a);
b >>= 1;
dmul(a, a);
}
return ans;
}
const int N = 222;
unsigned c[N][N];
unsigned tr[N];
unsigned fo[N][N];
unsigned top[N];
int main() {
int n = read(), d = read();
m = read();
if (m == 1) {
puts("0");
exit(0);
}
for (int i = (int)(0); i <= (int)(n); i++) {
c[i][0] = 1;
for (int j = (int)(1); j <= (int)(i); j++)
c[i][j] = add(c[i - 1][j - 1], c[i - 1][j]);
}
fo[0][0] = 1;
for (int cnt = (int)(1); cnt <= (int)(n); cnt++) {
tr[cnt] = 0;
for (int i = (int)(0); i <= (int)(d - 1); i++)
dadd(tr[cnt], fo[i][cnt - 1]);
for (int i = (int)(1); i <= (int)(n); i++) {
for (int k = (int)(1); k <= (int)(cnt); k++)
dadd(fo[i][cnt],
mul(c[cnt - 1][k - 1], mul(fo[i - 1][cnt - k], tr[k])));
}
top[cnt] = 0;
for (int i = (int)(2); i <= (int)(d - 1); i++)
dadd(top[cnt], fo[i][cnt - 1]);
}
unsigned ans = n == 2 || d >= 2;
for (int i = (int)(1); i <= (int)(n); i++)
for (int j = (int)(1); j <= (int)(n); j++)
if (i + j <= n) {
dadd(ans, mul(top[i], top[j]));
}
for (int i = (int)(1); i <= (int)(n - 1); i++) dadd(ans, top[i]);
for (int i = (int)(1); i <= (int)(n - 1); i++) dadd(ans, top[i]);
for (int i = (int)(2); i <= (int)(d); i++) {
dadd(ans, fo[i][n - 1]);
dadd(ans, fo[i][n - 1]);
}
for (int i = (int)(1); i <= (int)(n - 1); i++) {
for (int k1 = (int)(2); k1 <= (int)(d); k1++)
for (int k2 = (int)(2); k2 <= (int)(d); k2++)
if (k1 + k2 <= d) {
dadd(ans, mul(fo[k1][i], fo[k2][n - 1 - i]));
}
}
dmul(ans, mul(2 % m, mul(n % m, (n - 1) % m)));
printf("%u\n", ans);
return 0;
}
|
Victor tries to write his own text editor, with word correction included. However, the rules of word correction are really strange.
Victor thinks that if a word contains two consecutive vowels, then it's kinda weird and it needs to be replaced. So the word corrector works in such a way: as long as there are two consecutive vowels in the word, it deletes the first vowel in a word such that there is another vowel right before it. If there are no two consecutive vowels in the word, it is considered to be correct.
You are given a word s. Can you predict what will it become after correction?
In this problem letters a, e, i, o, u and y are considered to be vowels.
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of letters in word s before the correction.
The second line contains a string s consisting of exactly n lowercase Latin letters — the word before the correction.
Output
Output the word s after the correction.
Examples
Input
5
weird
Output
werd
Input
4
word
Output
word
Input
5
aaeaa
Output
a
Note
Explanations of the examples:
1. There is only one replace: weird <image> werd;
2. No replace needed since there are no two consecutive vowels;
3. aaeaa <image> aeaa <image> aaa <image> aa <image> a.
|
n = int(input())
s = input()
s2 = s[0]
for i in range(1,n):
if(ord(s[i]) == ord("a") or ord(s[i]) == ord("e") or ord(s[i]) == ord("i") or ord(s[i]) == ord("o") or ord(s[i]) == ord("u") or ord(s[i]) == ord("y")) and (ord(s[i - 1]) == ord("a") or ord(s[i - 1]) == ord("e") or ord(s[i - 1]) == ord("i") or ord(s[i - 1]) == ord("o") or ord(s[i - 1]) == ord("u") or ord(s[i - 1]) == ord("y")) :
sf = 1
else:
s2 += s[i]
print(s2)
|
You are given two integers a and b. Moreover, you are given a sequence s_0, s_1, ..., s_{n}. All values in s are integers 1 or -1. It's known that sequence is k-periodic and k divides n+1. In other words, for each k ≤ i ≤ n it's satisfied that s_{i} = s_{i - k}.
Find out the non-negative remainder of division of ∑ _{i=0}^{n} s_{i} a^{n - i} b^{i} by 10^{9} + 9.
Note that the modulo is unusual!
Input
The first line contains four integers n, a, b and k (1 ≤ n ≤ 10^{9}, 1 ≤ a, b ≤ 10^{9}, 1 ≤ k ≤ 10^{5}).
The second line contains a sequence of length k consisting of characters '+' and '-'.
If the i-th character (0-indexed) is '+', then s_{i} = 1, otherwise s_{i} = -1.
Note that only the first k members of the sequence are given, the rest can be obtained using the periodicity property.
Output
Output a single integer — value of given expression modulo 10^{9} + 9.
Examples
Input
2 2 3 3
+-+
Output
7
Input
4 1 5 1
-
Output
999999228
Note
In the first example:
(∑ _{i=0}^{n} s_{i} a^{n - i} b^{i}) = 2^{2} 3^{0} - 2^{1} 3^{1} + 2^{0} 3^{2} = 7
In the second example:
(∑ _{i=0}^{n} s_{i} a^{n - i} b^{i}) = -1^{4} 5^{0} - 1^{3} 5^{1} - 1^{2} 5^{2} - 1^{1} 5^{3} - 1^{0} 5^{4} = -781 ≡ 999999228 \pmod{10^{9} + 9}.
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 9;
const int MAXN = 1e5 + 5;
long long n, a, b, k, res, ans;
char s[MAXN];
long long qpow(long long a, long long p) {
long long res = 1;
while (p) {
if (p & 1) res = res * a % MOD;
a = a * a % MOD;
p >>= 1;
}
return res;
}
int main() {
cin >> n >> a >> b >> k;
scanf("%s", s + 1);
long long v = qpow(a, MOD - 2), x = qpow(a, n), len = (n + 1) / k;
for (int i = 1; i <= k; i++) {
if (s[i] == '+')
res = (res + x) % MOD;
else
res = (res - x) % MOD;
x = x * v % MOD * b % MOD;
}
x = qpow(v, k) * qpow(b, k) % MOD;
if (x == 1)
ans = res * len % MOD;
else
ans = res * (qpow(x, len) - 1) % MOD * qpow(x - 1, MOD - 2) % MOD;
if (ans < 0) ans += MOD;
cout << ans << endl;
return 0;
}
|
Given three numbers n, a, b. You need to find an adjacency matrix of such an undirected graph that the number of components in it is equal to a, and the number of components in its complement is b. The matrix must be symmetric, and all digits on the main diagonal must be zeroes.
In an undirected graph loops (edges from a vertex to itself) are not allowed. It can be at most one edge between a pair of vertices.
The adjacency matrix of an undirected graph is a square matrix of size n consisting only of "0" and "1", where n is the number of vertices of the graph and the i-th row and the i-th column correspond to the i-th vertex of the graph. The cell (i,j) of the adjacency matrix contains 1 if and only if the i-th and j-th vertices in the graph are connected by an edge.
A connected component is a set of vertices X such that for every two vertices from this set there exists at least one path in the graph connecting this pair of vertices, but adding any other vertex to X violates this rule.
The complement or inverse of a graph G is a graph H on the same vertices such that two distinct vertices of H are adjacent if and only if they are not adjacent in G.
Input
In a single line, three numbers are given n, a, b (1 ≤ n ≤ 1000, 1 ≤ a, b ≤ n): is the number of vertexes of the graph, the required number of connectivity components in it, and the required amount of the connectivity component in it's complement.
Output
If there is no graph that satisfies these constraints on a single line, print "NO" (without quotes).
Otherwise, on the first line, print "YES"(without quotes). In each of the next n lines, output n digits such that j-th digit of i-th line must be 1 if and only if there is an edge between vertices i and j in G (and 0 otherwise). Note that the matrix must be symmetric, and all digits on the main diagonal must be zeroes.
If there are several matrices that satisfy the conditions — output any of them.
Examples
Input
3 1 2
Output
YES
001
001
110
Input
3 3 3
Output
NO
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 62;
const int MAX = 1e3 + 3;
int grid[MAX][MAX];
void solve() {
memset(grid, 0, sizeof(grid));
int n, a, b;
cin >> n >> a >> b;
if (a > 1 && b > 1) {
cout << "NO" << endl;
return;
}
if (a == 1 && b == 1 && (n == 3 || n == 2)) {
cout << "NO" << endl;
return;
}
if (a == 1 && b == 1) {
for (long long i = (long long)(0); i < (long long)(n - 1); i++)
grid[i][i + 1] = 1, grid[i + 1][i] = 1;
} else if (b == 1) {
for (long long i = (long long)(0); i < (long long)(n - a); i++)
grid[i][i + 1] = 1, grid[i + 1][i] = 1;
} else if (a == 1) {
for (long long i = (long long)(0); i < (long long)(n); i++)
for (long long j = (long long)(0); j < (long long)(n); j++)
grid[i][j] = 1;
for (long long i = (long long)(0); i < (long long)(n); i++) grid[i][i] = 0;
for (long long i = (long long)(0); i < (long long)(n - b); i++)
grid[i][i + 1] = 0, grid[i + 1][i] = 0;
}
cout << "YES" << endl;
for (long long i = (long long)(0); i < (long long)(n); i++) {
for (long long j = (long long)(0); j < (long long)(n); j++) {
cout << grid[i][j];
}
cout << endl;
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t = 1;
while (t--) solve();
return 0;
}
|
Rahul's Dad is the CEO of one of the leading companies. Every time somebody seeks for an appointment he calls up his secretary and asks her whether the day is a Sunday or not. He has to keep his caller on hold and is unhappy about it. Knowing that his son Mayank knows a bit of programming he asks him to make a program to help him find all the sundays in a given month of a specific year.
Input:
The first Line contains t an integer, the number of test cases. The next t lines contain to integers first the year and then month.
Output:
Output consists of t lines containing the dates of sundays in that particular month
Constraints :
t<100000, month ≤ 12, 2000 ≤ year ≤ 5000
Test cases updated.. You may submit now
SAMPLE INPUT
2
3 2013
5 2010
SAMPLE OUTPUT
3 10 17 24 31
2 9 16 23 30
|
t = int(raw_input())
def anchor_day(year):
centurie = year[0] + year[1]
centurie = int(centurie)
if centurie % 4 == 1:
return 6
elif centurie % 4 == 2:
return 4
elif centurie % 4 == 3:
return 2
elif centurie % 4 == 0:
return 1
def doomsday_num(year, month):
if leap_year(year) == "normal":
doomsday = {"1": 3, "2": 28, "3": 0, "4": 4,
"5": 9, "6": 6, "7": 11, "8": 8,
"9": 5, "10": 10, "11": 7, "12": 12}
return doomsday[month]
elif leap_year(year) == "leap":
doomsday = {"1": 4, "2": 29, "3": 0, "4": 4,
"5": 9, "6": 6, "7": 11, "8": 8,
"9": 5, "10": 10, "11": 7, "12": 12}
return doomsday[month]
def leap_year(year):
year = int(year)
if (year % 4 == 0) and (year % 100 != 0) or (year % 400 == 0):
return "leap"
else:
return "normal"
def days_month(month, leap):
if leap == "normal":
months = {1: 31, 2: 28, 3: 31, 4: 30, 5: 31, 6: 30,
7: 31, 8: 31, 9: 30, 10: 31, 11: 30, 12: 31}
return months[int(month)]
elif leap == "leap":
months = {1: 31, 2: 29, 3: 31, 4: 30, 5: 31, 6: 30,
7: 31, 8: 31, 9: 30, 10: 31, 11: 30, 12: 31}
return months[int(month)]
for i in range(0, t):
d = raw_input()
d = d.split()
day = 1
month = d[0]
year = d[1]
num1 = int(year[-2] + year[-1]) / 12
num2 = int(year[-2] + year[-1]) % 12
num3 = num2 / 4
num = (num1 + num2 + num3) % 7
p = (anchor_day(year) + num) % 7
a = doomsday_num(year, month)
diff = 1 - a
WeekDay = (p + diff) % 7
tilSunday = 6 - WeekDay
firstSunday = 1 + tilSunday
sundays = ""
for i in range(firstSunday, days_month(month, leap_year(year)) + 1, 7):
sundays = sundays + str(i) + " "
print sundays
|
Chandu's girlfriend loves arrays that are sorted in non-increasing order. Today is her birthday. Chandu wants to give her some sorted arrays on her birthday. But the shop has only unsorted arrays. So, Chandu bought T unsorted arrays and is trying to sort them. But, he doesn't have much time to sort the arrays manually as he is getting late for the birthday party. So, he asked you to write a program to sort the T arrays in non-increasing order. Help him, or his girlfriend will kill him.
Input:
First line contains an integer T, denoting the number of test cases.
First line of each test case contains an integer N, denoting the size of the array.
Second line contains N space separated integers, denoting the array elements Ai.
Output:
For each test case, print the sorted array in non-increasing order.
Constraints:
1 ≤ T ≤ 100
1 ≤ N ≤ 10^5
0 ≤ Ai ≤ 10^9
SAMPLE INPUT
2
5
2 5 2 4 3
5
5 4 2 3 1
SAMPLE OUTPUT
5 4 3 2 2
5 4 3 2 1
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
def solve(n, array):
tmp = sorted(array)[::-1]
for i in xrange(n):
tmp[i] = str(tmp[i])
return ' '.join(tmp)
def sort_array():
T = int(raw_input())
for _ in xrange(T):
n = int(raw_input())
array = map(int,raw_input().split())
print solve(n, array)
if __name__ == "__main__":
sort_array()
|
Lexicographical order is a generalization of the way the alphabetical order of words is based on the alphabetical order of their component letters. An example of lexicographical arrangement is a dictionary or a contact directory.
You are given some names, and your task is to arrange these names in lexicographical order. The interesting part is that some of these names contain roman numerals at end like Louis IV and Henry VII. Take care of these roman numerals as well in correct mathematical order i.e. I<II<III,IV and so on.
INPUT
First line of Input contains a single integer N denoting the number of lines to be followed.
Next N lines contains the names to be arranged. Each line contains a single name.
OUTPUT
N lines, each containing a single name arranged in lexicographical manner.
Constraints
1 ≤ N ≤ 50
Length of a name will be between 1 to 30 characters
No two names will be sameSAMPLE INPUT
4
Henry IX
Louis V
Henry VIII
Charles II
SAMPLE OUTPUT
Charles II
Henry VIII
Henry IX
Louis V
|
import re
romanNumeralMap = (('M', 1000),
('CM', 900),
('D', 500),
('CD', 400),
('C', 100),
('XC', 90),
('L', 50),
('XL', 40),
('X', 10),
('IX', 9),
('V', 5),
('IV', 4),
('I', 1))
romanNumeralPattern = re.compile("""
^ # beginning of string
M{0,4} # thousands - 0 to 4 M's
(CM|CD|D?C{0,3}) # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
# or 500-800 (D, followed by 0 to 3 C's)
(XC|XL|L?X{0,3}) # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
# or 50-80 (L, followed by 0 to 3 X's)
(IX|IV|V?I{0,3}) # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
# or 5-8 (V, followed by 0 to 3 I's)
$ # end of string
""" ,re.VERBOSE)
def fromRoman(s):
"""convert Roman numeral to integer"""
if not s:
print 'Input can not be blank'
return
if not romanNumeralPattern.search(s):
print 'Invalid Roman numeral: %s' % s
return
result = 0
index = 0
for numeral, integer in romanNumeralMap:
while s[index:index+len(numeral)] == numeral:
result += integer
index += len(numeral)
return result
def toRoman(n):
"""convert integer to Roman numeral"""
if not (0 < n < 5000):
raise OutOfRangeError, "number out of range (must be 1..4999)"
if int(n) != n:
raise NotIntegerError, "decimals can not be converted"
result = ""
for numeral, integer in romanNumeralMap:
while n >= integer:
result += numeral
n -= integer
return result
import collections
import sys
lines = []
while True:
line = sys.stdin.readline()
if not line or len(line.strip()) == 0:
break
lines.append(line)
names = []
nums = []
namenum = {}
for line in lines:
ins = line.split()
name = ins[0]
names.append(name)
num = fromRoman(ins[1])
nums.append(num)
for x in range(len(names)):
if names[x] not in namenum:
namenum[names[x]] = list()
namenum[names[x]].append(nums[x])
namenums = sorted(namenum )
for x in namenums:
lst = sorted(namenum[x])
for a in lst:
print x + " " + toRoman(a)
|
It is lunch time at the Vibrant Gujarat Summit and all the investors are called for the executive lunch. When Bruce reached the lunch area, he found that the waiter was taking out bowls from a big box containing some amount of golden bowls and other bronze bowls. The bowls were taken out at random. Each dish contains exactly one bowl. Bruce and Robin are the first ones to receive the dishes.
Bruce believes that there is a 50/50 chance in everything. He tells Robin that the there is a 50% chance of both of them receiving a golden bowl. Robin is confused and doesn't know how is that possible. He asks Bruce what makes him think so. Bruce says that he would have to find the answer himself and so in order to make things interesting he tells Robin the total number of bowls the waiter has in the box. All Robin has to do is now find the number of golden bowls there should be in the box in order for it to be a 50% probability.
Input:
Only one integer number, N, telling the number of bowls in the box.
Output:
The number of golden bowls required for it to be a 50% probability of both of them receiving a golden bowl.
Constraints:
1 ≤ N ≤ 10^15
SAMPLE INPUT
21
SAMPLE OUTPUT
15
Explanation
As Bruce and Robin are the first ones to receive the bowls, if there are 15 golden bowls then the probability for the first person to get a golden one is 15/21 and the second one is 14/20.
(15/21)*(14/20) = 0.5
|
import math
x=int(raw_input())
c=math.sqrt(1.+2.*x*(x-1.))
n=(c+1.)/2.
print int(n)
|
Your program is to use the brute-force approach in order to find the Answer to Life, the Universe, and Everything. More precisely... rewrite small numbers from input to output. Stop processing input after reading in the number 42. All numbers at input are integers of one or two digits.
SAMPLE INPUT
1
2
88
42
99
SAMPLE OUTPUT
1
2
88
|
t =1
while (t==1):
x = int(raw_input())
if (x == 42 ):
t =0
else:
print x
|
Monk visits Biksy, the largest trading market in the land. Biksy has traders from all over the world.
There are a total of N items indexed from 1 to N, that are traded in the market by a total of M dealers. Each trader is characterized by three integers, say i, j, C , meaning that the trader will take i'th item from you and give you j'th item and C units of money. A negative value of C signifies that, in order to get j'th item from the trader, you will have to give i'th item and C units of money. Note that there can be multiple dealers who deal with the same pair of items and some crazy dealers might trade the same item as well i.e. (i = j).
Monk visits Biksy having the item number 1. He collects the data of all the traders and wants to know if there is way by which he can become infinity rich if he acts smart! i.e. if there are a series of profits, repeating which, will always increase the number of units of money with him! Help Monk find the answer to this question. Note that Monk can go to any dealer any number of times.
Input:
First line contains an integer T. T test cases follow.
First line of each test case contains two space-separated integers N, M
Next M lines contain three space-separated integers i, j and C, the characteristics of the traders.
Output:
Print "Yes"(without the quotes) if such a way exists, "No"(without the quotes) otherwise.
Print the answer to each test case in a new line.
Constraints:
1 ≤ T ≤ 10
1 ≤ N ≤ 100
1 ≤ M ≤ 1000
1 ≤ i, j ≤ N
-1000 ≤ C ≤ 1000
SAMPLE INPUT
2
5 6
1 2 2
2 3 -1
3 4 -7
4 5 0
2 3 -7
3 5 6
5 8
1 5 10
2 3 -6
5 2 5
4 5 9
1 5 1
2 4 -10
2 3 -2
4 1 1
SAMPLE OUTPUT
No
Yes
Explanation
For the first test case, there is no such way possible.
For the second test case, Monk starts with item 1.
Trades it for 5th item gaining 10 units.
Trades 5th for 2nd gaining 5 units.
Trades 2nd for 4th losing 10 units.
Trades 4th for 1st gaining 1 unit.
Thereby, gaining 6 units in this process and it can be repeated indefinitely to make Monk infinitely rich!
|
from collections import defaultdict
import sys
T = int(raw_input())
inf = sys.maxint
for test in range(T):
N,M = [int(x) for x in raw_input().split()]
D = [[inf]*(N+1) for x in range(N+1) ]
dicti = defaultdict(lambda :-1*inf)
for l in range(M):
i,j,c = [int(x) for x in raw_input().split()]
if dicti[(i,j)] < c:
dicti[(i,j)] = c
#print dicti
for i in range(1,N+1):
D[i][i] = 0
for key,value in dicti.iteritems():
D[key[0]][key[1]] = -1*value
'''
for i in range(N):
if D[i][i]>0:
D[i][i]=0
'''
#for i in range(N):
#print D[i]
for k in range(1,N+1):
for i in range(1,N+1):
for j in range(1,N+1):
if D[i][k] == inf or D[k][j]==inf:
continue
elif D[i][j] > D[i][k]+D[k][j]:
D[i][j] = D[i][k]+D[k][j]
flag = 0
for i in range(1,N+1):
if D[i][i] < 0 and D[1][i]!=inf :
print "Yes"
flag = 1
break
if flag == 0:
print "No"
|
Sherlock and Watson are close friends. One day, they finally got bored of playing normal games.
So, they came up with a new idea of playing with numbers.
Since they are good at number theory, they know the fact that a decimal number "A" can be represented as sum of 2's powers.
For example:
22 = 16 + 4 + 2 = 2^4 + 2^2 + 2^1
13 = 8 + 4 + 1 = 2^3 + 2^2 + 2^0
15 = 8 + 4 + 2 + 1 = 2^3 + 2^2 + 2^1 + 2^0
So, they define the rules of game to be played as follows:
1 - If a player has a number "N" on his turn , then he can subtract "r" from "N" if "r" comes in the 2's power expansion of "N".
For example: If "N" = 22 , then possible values of "r" can be 16, 4, or 2. So, the player can subtract any possible of "r" from "N".
2 - After subtracting, the value "N" changes. The next player player plays with the new "N" value.
3 - The game is played until any one of the player is unable to make a move.
4 - The person who cannot make a move, loses the game.
5 - The winner of the last game, makes the first move in the next game.
As Sherlock and Watson are smart, so they play optimally. Sherlock makes first move in the first game and they both play alternatively.
Input:
First line contains an integer "t" denoting the number of test cases.
First line of each test case contains an integer "N".
Output:
Print "Sherlock" if Sherlock wins the game , otherwise "Watson", on a separate line for each test case
Constraints:
1 ≤ t ≤ 10^6
0 < N < 2^64
SAMPLE INPUT
2
1
2
SAMPLE OUTPUT
Sherlock
Sherlock
Explanation
In test case 1, Sherlock can subtract 1 and hence wins the game.
In test case 2, Sherlock can subtract 2 and hence wins the game.
|
t = int(raw_input())
r = "Sherlock"
q = "Watson"
for i in range(t):
n = int(raw_input())
count = 1
count = bin(n).count('1')
if count%2==0:
print(q)
j=r
r=q
q=j
else:
print(r)
|
Definition:
Roy's boolean function (RBF) is True, if number of the positive integers less than or equal to N that are relatively prime to N, is prime; else False.
In other words, let Z be the number of integers K in the range 1 ≤ K ≤ N for which the greatest common divisor gcd(N, K) = 1. If Z is prime then RBF is True else it is False.
Given an integer N, your task is to find if its RBF value.
Input:
First line contains T - number of test cases.
Each of next T lines contain an integer N.
Output:
Print RBF value of each N in a new line i.e. "TRUE" or "FALSE" (quotes are only for clarity)
Constraints:
1 ≤ T ≤ 10
1 ≤ N ≤ 100000
Note: In case you're wondering, 1 is NOT a prime number :)
SAMPLE INPUT
4
2
3
4
5SAMPLE OUTPUT
FALSE
TRUE
TRUE
FALSEExplanation
For N=4, numbers ≤ 4 and relatively prime to 4 are 1 and 3. So there are 2 numbers that are relatively prime to 4. Since 2 is a prime. RBF is TRUE.
For N=5, numbers ≤ 5 and relatively prime to 5 are 1,2,3 and 4. So there are 4 numbers that are relatively prime to 5. Since 4 is not a prime, RBF is FALSE.
|
import math
T=int(raw_input())
def prime(num):
if num==1:return 0
s=int(round(math.sqrt(num)))+1
for i in range(2,s):
if num%i==0:
return False
return True
def gcd(p,q):
while(q!=0):
temp=q
q=p%q
p=temp
return p
for t in range(T):
m=1
N=int(raw_input())
for j in range(2,N):
if gcd(N,j)==1:
m+=1
if prime(m):print "TRUE"
else :print "FALSE"
|
Problem:
You are given n natural numbers a1,a2,a3…… an. Let SOD of a number be defined as the Sum of Digits of that number. Compute the value of
{ [ SOD(a1) + SOD(a2) + …….. SOD(an) ] % 9 } – { [ SOD( a1 + a2 + ….. an ) ] % 9 }
Input:
The first line consists of the value of n. Next n lines are such that the i th line consists of a single natural number ai.
Output:
Print a single line consisting of the computed value.
Constraints:
2 ≤ n ≤ 10000
1 ≤ ai ≤ 10^10000
Problem Setter : Shreyans
Problem Tester : Sandeep
(By IIT Kgp HackerEarth Programming Club)
SAMPLE INPUT
3
1
2
3
SAMPLE OUTPUT
0
Explanation
(SOD(1)+SOD(2)+SOD(3))%9=(1+2+3)%9=6 and (SOD(1+2+3))%9=SOD(6)%9=6. So, 6-6=0.
|
#a= int(raw_input())
#while a>0:
#a-= 1
#b =(raw_input())
print 0
|
With the T20 world cup going on, a list of batsmen was prepared with their country code and their T20I career runs.
The list contains data of N batsmen (country-code and runs).
Number of countries may range from 1 to N and each country has its unique code.
The list is pretty unorganized. Virat and Maxwell do not like it. They decided to group all the players belonging to same country together.
Virat likes arranging stuffs in ascending order and wants the data list to be sorted in ascending order, while Maxwell prefers descending order.
As they are good friends, they mutually agreed that country codes should be sorted in ascending order and for each country code, the runs of all the batsmen for that particular country should be sorted in descending order.
As the mighty clash between Australia and India is going to start shortly, Virat and Maxwell don't have the time to organize the list. Can you help them to sort the list, the way they want?
(See test cases for clarification)
INPUT:
First line contains a integer N, the number of Batsmen.
Next N lines, contains two integers separated by space, country-code and runs of the ith batsmen . (1 ≤ i ≤ N)
OUTPUT :
Print N lines containing two integers, i.e. country-code and runs of the batsmen, sorted in the order Virat and Maxwell wants.
CONSTRAINS
1 ≤ N ≤ 1000006
0 ≤ Runs ≤ 10^9
Disclaimer : All country-codes and runs are fictional and has no relation and significance with real life.
SAMPLE INPUT
5
4 12
2 1
3 10
2 7
2 5
SAMPLE OUTPUT
2 7
2 5
2 1
3 10
4 12
Explanation
Country '4' has one player with runs '12',
Country '3' has one player with run '10',
Country '2' has three players with runs '1' , '7' and '5' .
Countries are sorted in increasing order 2 -> 2 -> 2 -> 3 -> 4.
The players for each country should have runs in descending order, so final output is
(2,7) (2,5), (2,1) , (3,10), (4,12).
|
playerCount = int(raw_input())
def outlist(data):
runMap = {}
for entry in data:
cCode, run = int(entry[0]), int(entry[1])
if(runMap.has_key(cCode) == False):
runMap[cCode] = [run]
else:
runMap[cCode].append(run)
sortedCCode = sorted(runMap.keys())
for cCode in sortedCCode:
runList = reversed(sorted(runMap[cCode]))
for run in runList:
print cCode, run
data = []
for pNo in range(1, playerCount + 1):
data.append(raw_input().split(" "))
outlist(data)
|
We will buy a product for N yen (the currency of Japan) at a shop.
If we use only 1000-yen bills to pay the price, how much change will we receive?
Assume we use the minimum number of bills required.
Constraints
* 1 \leq N \leq 10000
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the amount of change as an integer.
Examples
Input
1900
Output
100
Input
3000
Output
0
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int ans = 0;
ans = n % 1000;
if(ans != 0) {
ans = 1000 - ans;
}
System.out.println(ans);
}
}
|
Does \sqrt{a} + \sqrt{b} < \sqrt{c} hold?
Constraints
* 1 \leq a, b, c \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
a \ b \ c
Output
If \sqrt{a} + \sqrt{b} < \sqrt{c}, print `Yes`; otherwise, print `No`.
Examples
Input
2 3 9
Output
No
Input
2 3 10
Output
Yes
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
long double a,b,c;
cin>>a>>b>>c;
long long int d=c-a-b;
if(d*d> 4*a*b&&d>0)
cout<<"Yes";
else
cout<<"No";
}
|
We have two indistinguishable pieces placed on a number line. Both pieces are initially at coordinate 0. (They can occupy the same position.)
We can do the following two kinds of operations:
* Choose a piece and move it to the right (the positive direction) by 1.
* Move the piece with the smaller coordinate to the position of the piece with the greater coordinate. If two pieces already occupy the same position, nothing happens, but it still counts as doing one operation.
We want to do a total of N operations of these kinds in some order so that one of the pieces will be at coordinate A and the other at coordinate B. Find the number of ways to move the pieces to achieve it. The answer can be enormous, so compute the count modulo 998244353.
Two ways to move the pieces are considered different if and only if there exists an integer i (1 \leq i \leq N) such that the set of the coordinates occupied by the pieces after the i-th operation is different in those two ways.
Constraints
* 1 \leq N \leq 10^7
* 0 \leq A \leq B \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
Print the number of ways to move the pieces to achieve our objective, modulo 998244353.
Examples
Input
5 1 3
Output
4
Input
10 0 0
Output
1
Input
10 4 6
Output
197
Input
1000000 100000 200000
Output
758840509
|
#include<bits/stdc++.h>
#define int long long
#define fr(i,a,b) for(int i(a),end##i(b);i<=end##i;i++)
#define fd(i,a,b) for(int i(a),end##i(b);i>=end##i;i--)
using namespace std;
const int mod=998244353;
const int maxn=4e7+5;
int ksm(int x,int k){
int ans=1;
while(k){
if(k&1)ans=ans*x%mod;
x=x*x%mod;
k>>=1;
}
return ans;
}
int jc[maxn],inv[maxn];
void init(int n){
jc[0]=1;
fr(i,1,n)jc[i]=jc[i-1]*i%mod;
inv[n]=ksm(jc[n],mod-2);
fd(i,n-1,0)inv[i]=inv[i+1]*(i+1)%mod;
}
int C(int n,int m){
if(n<0||m<0||n<m)return 0;
return jc[n]*inv[m]%mod*inv[n-m]%mod;
}
int D(int n,int m){
if(n<0||n+m<0||((n+m)&1))return 0;
return C(n,n+m>>1);
}
int x,y,t,ans;
signed main(){
#ifdef pig
freopen("f.in","r",stdin);
freopen("f.out","w",stdout);
#endif
cin>>t>>y>>x;
if(!x&&!y&&t){
cout<<1;
return 0;
}
init(3e7);y=x-y;
if(2*x-t-y==0)ans=D(t-1,2*x-t-1)-D(t-1,2*x-t+1);
fr(k,1,2*x-y){
int h=2*x-k-y;
(ans+=C(h+t-k-1,h)*(D(k-1,2*x-k-1)-D(k-1,2*x-k+1)))%=mod;
}
cout<<(ans+mod)%mod;
return 0;
}
|
We have N weights indexed 1 to N. The mass of the weight indexed i is W_i.
We will divide these weights into two groups: the weights with indices not greater than T, and those with indices greater than T, for some integer 1 \leq T < N. Let S_1 be the sum of the masses of the weights in the former group, and S_2 be the sum of the masses of the weights in the latter group.
Consider all possible such divisions and find the minimum possible absolute difference of S_1 and S_2.
Constraints
* 2 \leq N \leq 100
* 1 \leq W_i \leq 100
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
W_1 W_2 ... W_{N-1} W_N
Output
Print the minimum possible absolute difference of S_1 and S_2.
Examples
Input
3
1 2 3
Output
0
Input
4
1 3 1 1
Output
2
Input
8
27 23 76 2 3 5 62 52
Output
2
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int N; cin >> N;
int W[110] = {}; int S[110] = {};
for(int i = 1; i <= N; i++){
cin >> W[i]; S[i] = S[i-1] + W[i];
}
int ans = 1145141919;
for(int i = 1; i <= N; i++){
ans = min(ans, abs(S[N] - 2 * S[i]));
}
cout << ans << endl;
}
|
Consider writing each of the integers from 1 to N \times M in a grid with N rows and M columns, without duplicates. Takahashi thinks it is not fun enough, and he will write the numbers under the following conditions:
* The largest among the values in the i-th row (1 \leq i \leq N) is A_i.
* The largest among the values in the j-th column (1 \leq j \leq M) is B_j.
For him, find the number of ways to write the numbers under these conditions, modulo 10^9 + 7.
Constraints
* 1 \leq N \leq 1000
* 1 \leq M \leq 1000
* 1 \leq A_i \leq N \times M
* 1 \leq B_j \leq N \times M
* A_i and B_j are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_{N}
B_1 B_2 ... B_{M}
Output
Print the number of ways to write the numbers under the conditions, modulo 10^9 + 7.
Examples
Input
2 2
4 3
3 4
Output
2
Input
3 3
5 9 7
3 6 9
Output
0
Input
2 2
4 4
4 4
Output
0
Input
14 13
158 167 181 147 178 151 179 182 176 169 180 129 175 168
181 150 178 179 167 180 176 169 182 177 175 159 173
Output
343772227
|
MOD = int(1e9) + 7
def binsearch(num, ary):
left = 0
right = len(ary)
while left < right:
center = (left + right) // 2
if num <= ary[center]:
left = center + 1
else:
right = center
return left
def main():
N, M = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
sortA = sorted(A, reverse=True)
sortB = sorted(B, reverse=True)
for i in range(1, N):
if sortA[i] == sortA[i-1]:
print(0)
return
for j in range(1, M):
if sortB[j] == sortB[j-1]:
print(0)
return
retval = 1
for num in range(N*M, 0, -1):
just = 1
icandidates = binsearch(num, sortA)
jcandidates = binsearch(num, sortB)
if icandidates >= 1 and sortA[icandidates-1] == num:
icandidates = 1
just = 0
if jcandidates >= 1 and sortB[jcandidates-1] == num:
jcandidates = 1
just = 0
# print(icandidates, jcandidates, sortA, num)
retval *= icandidates * jcandidates - (N*M - num) * just
retval %= MOD
print(retval)
if __name__ == "__main__":
main()
|
Takahashi lives in another world. There are slimes (creatures) of 10000 colors in this world. Let us call these colors Color 1, 2, ..., 10000.
Takahashi has N slimes, and they are standing in a row from left to right. The color of the i-th slime from the left is a_i. If two slimes of the same color are adjacent, they will start to combine themselves. Because Takahashi likes smaller slimes, he has decided to change the colors of some of the slimes with his magic.
Takahashi can change the color of one slime to any of the 10000 colors by one spell. How many spells are required so that no slimes will start to combine themselves?
Constraints
* 2 \leq N \leq 100
* 1 \leq a_i \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
Print the minimum number of spells required.
Examples
Input
5
1 1 2 2 2
Output
2
Input
3
1 2 1
Output
0
Input
5
1 1 1 1 1
Output
2
Input
14
1 2 2 3 3 3 4 4 4 4 1 2 3 4
Output
4
|
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
int main(){
int n;
cin >> n;
LL a[n];
LL ans = 0;
for(int i = 0; i < n; i++){
cin >> a[i];
if(i > 0 && a[i] == a[i-1]){
ans++;
a[i] = -1000;
}
}
cout << ans << endl;
}
|
For a positive integer n, let us define f(n) as the number of digits in base 10.
You are given an integer S. Count the number of the pairs of positive integers (l, r) (l \leq r) such that f(l) + f(l + 1) + ... + f(r) = S, and find the count modulo 10^9 + 7.
Constraints
* 1 \leq S \leq 10^8
Input
Input is given from Standard Input in the following format:
S
Output
Print the answer.
Examples
Input
1
Output
9
Input
2
Output
98
Input
123
Output
460191684
Input
36018
Output
966522825
Input
1000
Output
184984484
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
#define fi first
#define se second
#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define rep(i,n) repl(i,0,n)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcount
#define INF 1e16
#define mod 1000000007
ll mod_pow(ll a,ll n){
ll res=1;
while(n>0){
if(n&1)res=res*a%mod;
a=a*a%mod;
n>>=1;
}
return res;
}
ll f(ll a){
ll res=0;
while(a>0){
res++; a/=10;
}
return res;
}
ll S;
int main(){
cin>>S;
ll res=0;
{
ll l=1,r=1;
ll crtS=0;
for(;f(l)<=7;){
while(crtS<S){
crtS+=f(r);
r++;
}
if(crtS==S){
res++;
}
crtS-=f(l);
l++;
}
}
res%=mod;
{
repl(i,1,S/8+1){
if(S%i!=0)(res+=1)%=mod;
else{
ll nd=(9*mod_pow(10,(S/i)-1)%mod-i+1+mod)%mod;
(res+=nd)%=mod;
}
}
}
cout<<res%mod<<endl;
return 0;
}
|
You are given N points (x_i,y_i) located on a two-dimensional plane. Consider a subset S of the N points that forms a convex polygon. Here, we say a set of points S forms a convex polygon when there exists a convex polygon with a positive area that has the same set of vertices as S. All the interior angles of the polygon must be strictly less than 180°.
cddb0c267926c2add885ca153c47ad8a.png
For example, in the figure above, {A,C,E} and {B,D,E} form convex polygons; {A,C,D,E}, {A,B,C,E}, {A,B,C}, {D,E} and {} do not.
For a given set S, let n be the number of the points among the N points that are inside the convex hull of S (including the boundary and vertices). Then, we will define the score of S as 2^{n-|S|}.
Compute the scores of all possible sets S that form convex polygons, and find the sum of all those scores.
However, since the sum can be extremely large, print the sum modulo 998244353.
Constraints
* 1≤N≤200
* 0≤x_i,y_i<10^4 (1≤i≤N)
* If i≠j, x_i≠x_j or y_i≠y_j.
* x_i and y_i are integers.
Input
The input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print the sum of all the scores modulo 998244353.
Examples
Input
4
0 0
0 1
1 0
1 1
Output
5
Input
5
0 0
0 1
0 2
0 3
1 1
Output
11
Input
1
3141 2718
Output
0
|
#include<bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int N = 11111;
void add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int pw(int a, int b) {
int an = 1;
for (; b; b >>= 1) {
if (b & 1) an = 1ll * an * a % mod;
a = 1ll * a * a % mod;
}
return an;
}
int ans, x[N], y[N], n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d%d", &x[i], &y[i]);
add(ans, pw(2, n));
add(ans, mod - 1);
add(ans, mod - n);
add(ans, mod - n * (n - 1) / 2);
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j) {
int dx = x[j] - x[i], dy = y[j] - y[i];
int cnt = 2;
for (int k = 1; k <= n; ++k) {
if (i == k || j == k) continue;
int dx2 = x[k] - x[j], dy2 = y[k] - y[j];
if (dx2 * dy != dy2 * dx) continue;
if (k < j) break;
++cnt;
}
add(ans, mod - pw(2, cnt));
add(ans, 1);
add(ans, cnt);
add(ans, cnt * (cnt - 1) / 2);
}
printf("%d\n", ans);
return 0;
}
|
Dolphin loves programming contests. Today, he will take part in a contest in AtCoder.
In this country, 24-hour clock is used. For example, 9:00 p.m. is referred to as "21 o'clock".
The current time is A o'clock, and a contest will begin in exactly B hours. When will the contest begin? Answer in 24-hour time.
Constraints
* 0 \leq A,B \leq 23
* A and B are integers.
Input
The input is given from Standard Input in the following format:
A B
Output
Print the hour of the starting time of the contest in 24-hour time.
Examples
Input
9 12
Output
21
Input
19 0
Output
19
Input
23 2
Output
1
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
// 整数の入力
int A = sc.nextInt();
int B = sc.nextInt();
int C = A + B;
if (C >= 24) {
C = C - 24;
}
// 出力
System.out.println(C);
}
}
|
Shik's job is very boring. At day 0, his boss gives him a string S_0 of length N which consists of only lowercase English letters. In the i-th day after day 0, Shik's job is to copy the string S_{i-1} to a string S_i. We denote the j-th letter of S_i as S_i[j].
Shik is inexperienced in this job. In each day, when he is copying letters one by one from the first letter to the last letter, he would make mistakes. That is, he sometimes accidentally writes down the same letter that he wrote previously instead of the correct one. More specifically, S_i[j] is equal to either S_{i-1}[j] or S_{i}[j-1]. (Note that S_i[1] always equals to S_{i-1}[1].)
You are given the string S_0 and another string T. Please determine the smallest integer i such that S_i could be equal to T. If no such i exists, please print `-1`.
Constraints
* 1 \leq N \leq 1,000,000
* The lengths of S_0 and T are both N.
* Both S_0 and T consist of lowercase English letters.
Input
The input is given from Standard Input in the following format:
N
S_0
T
Output
Print the smallest integer i such that S_i could be equal to T. If no such i exists, print `-1` instead.
Examples
Input
5
abcde
aaacc
Output
2
Input
5
abcde
abcde
Output
0
Input
4
acaa
aaca
Output
2
Input
5
abcde
bbbbb
Output
-1
|
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<deque>
using namespace std;
int n,ans;
char s[1000010],t[1000010];
deque<int> q;
int main(){
scanf("%d%s%s",&n,s+1,t+1);
q.push_back(n+1);
for(int i=n,j=n+1,tmp=0,pre;i;i--){
for(pre=j;j&&(i<j||s[j]!=t[i]);j--);
if(!j){
puts("-1");
return 0;
}
if(pre==j){
while(!q.empty()&&q.back()-tmp>=i)
q.pop_back();
q.push_back(i+tmp);
}
else{
tmp++;
if(i!=j){
ans=max(ans,(int)q.size());
q.push_front(j+tmp);
}
}
}
printf("%d",ans);
return 0;
}
|
There is a double-track line (up and down are separate lines and pass each other everywhere). There are 11 stations on this line, including the terminal station, and each station is called by the section number shown in the figure.
<image>
Trains depart from both terminal stations on this line at the same time and run without stopping along the way. Create a program that reads the length of each section and the speed of the two trains and outputs the number of the section where the trains pass each other in each case. However, if you pass each other just at the station, the smaller number of the section numbers on both sides will be output. In addition, the length of the train and the length of the station cannot be ignored.
Input
Multiple datasets are given. Each dataset is given in the following format.
l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, v1, v2
li (1 ≤ li ≤ 2,000) is an integer representing the length (km) of the interval i. v1 is the speed of the train departing from the terminal station on the section 1 side (km / h), and v2 is the speed of the train departing from the terminal station on the section 10 side (km / h) (1 ≤ v1, v2) ≤ 2,000).
The number of datasets does not exceed 50.
Output
For each data set, the number of the section where the train passes is output on one line.
Example
Input
1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49
Output
4
7
6
|
public class Main{
public void run(java.io.InputStream in, java.io.PrintStream out){
java.util.Scanner sc = new java.util.Scanner(in);
/*answer*/
int[] l, v;
int i, j, k, sum;
String str;
char[] ch;
double d;
l = new int[10]; v = new int[2];
for(;sc.hasNext();){
str = sc.next();
ch = new char[str.length()];
for(j = 0;j < str.length();j++)ch[j] = str.charAt(j);
k = 0; j = 0;
for(i = 0;i < 10;i++){
for(;j < str.length();j++){
if(ch[j] == ','){
l[i] = readint(ch, k, j);
k = ++j; break;
}
}
}
for(;j < str.length();j++){
if(ch[j] == ','){
v[0] = readint(ch, k, j);
k = ++j; break;
}
}
v[1] = readint(ch, k, str.length());
d = 0;
for(i = 0;i < 10;i++)d += (double)l[i];
d = d * (double)v[0] / (double)(v[0] + v[1]);
sum = 0;
for(i = 0;i < 10;i++){
sum += l[i];
if(d <= sum){
out.println(i + 1);
break;
}
}
}
sc.close();
}
public static void main(String[] args){
(new Main()).run(System.in, System.out);
}
private static int readint(char[] ch, int l, int r){
int i, d, res;
d = 1; res = 0;
for(i = r - 1;i >= l;i--){
res += d * (int)(ch[i] - '0');
d *= 10;
}
return res;
}
}
|
Create a program that inputs the vertex information of two polygons inscribed in one circle and outputs the magnitude relationship of their areas.
Assume that each vertex of the X-side is numbered counterclockwise from 1 to X (the figure shows an example when X = 4). However, the given polygon assumes that the center of the circle is contained inside, and the data on the position of vertex i is the angle v (1 ≤ v <180) of the central angle measured counterclockwise from vertex i to vertex i + 1. Integer). Regarding the magnitude relationship to be output, 1 (half-width number) when the area of the first polygon is large, 2 (half-width number) when the area of the second polygon is large, and when the areas are the same, Please output 0 (half-width number).
<image>
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:
m
v1
v2
::
vm −1
n
v1
v2
::
vn − 1
The first line gives the number of vertices of the first polygon m (3 ≤ m ≤ 50), and the following m − 1 line gives the information vi (1 ≤ vi <180) of the vertices i of the first polygon. ..
The following line gives the number of vertices n (3 ≤ n ≤ 50) of the second polygon, and the following n − 1 line gives the information vi (1 ≤ vi <180) for the vertices i of the second polygon.
The number of datasets does not exceed 200.
Output
Outputs the magnitude relationship (half-width numbers) for each data set on one line.
Example
Input
4
30
125
75
4
30
125
75
5
30
125
75
65
4
30
125
75
4
30
125
75
6
30
50
50
25
75
0
Output
0
1
2
|
# Area of Polygon
from math import sin
from math import radians
while True:
m = int(raw_input())
if m == 0:
break
a1, v, vv = (0.0, 0, 0)
for i in range(m):
if i < m - 1:
v = int(raw_input())
vv += v
else:
v = 360 - vv
a1 += sin(radians(v)) * 100 / 2
n = int(raw_input())
a2, v, vv = (0.0, 0, 0)
for i in range(n):
if i < n - 1:
v = int(raw_input())
vv += v
else:
v = 360 - vv
a2 += sin(radians(v)) * 100 / 2
if a1 > a2:
print 1
elif a1 < a2:
print 2
else:
print 0
|
Addition is easy to calculate by hand, but if some numbers are missing, is it easy to fill in the missing numbers? For example, in the following long division, if there is a condition that the numbers 1 to 9 appear only once, how many numbers will fit in the C and E squares? In this case, 8 is correct for C and 5 is correct for E. An operation that lacks some numbers in this way is called worm-eaten calculation.
<image>
The condition that the numbers 1 to 9 appear only once remains the same, and if more numbers are missing as shown below, is there only one way to fill in the correct numbers? In fact, it is not always decided in one way.
<image>
Create a program that outputs how many correct filling methods are available when the information of each cell from A to I is given in the form of worm-eaten calculation as shown in the above figure.
Input
The input is given in the following format.
A B C D E F G H I
One line is given the information of the numbers in the cells from A to I of the worm-eaten calculation. However, when the given value is -1, it means that the number in that square is missing. Values other than -1 are any of the integers from 1 to 9 and there is no duplication between them.
Output
Outputs how many correct filling methods are available on one line.
Examples
Input
7 6 -1 1 -1 9 2 3 4
Output
1
Input
7 6 5 1 8 9 2 3 4
Output
0
Input
-1 -1 -1 -1 -1 -1 8 4 6
Output
12
Input
-1 -1 -1 -1 -1 -1 -1 -1 -1
Output
168
|
#include<bits/stdc++.h>
using namespace std;
int a[10];
int num[10];
int cnt;
bool flag(){
for(int i=0;i<9;i++){
if(a[i]==-1) return false;
}
return true;
}
void dfs(int k){
for(int i=k;i<9;i++){
if(a[i]==-1){
for(int j=1;j<10;j++){
if(num[j]==0){
a[i]=j;
num[j]=1;
dfs(i);
num[j]=0;
a[i]=-1;
}
}
}
if(i==8 && flag()){
if(a[0]+a[1]*10+a[2]+a[3]*100+a[4]*10+a[5]==a[6]*100+a[7]*10+a[8]){
//cout<<a[0]<<" "<<a[1]<<" "<<a[2]<<" "<<a[3]<<" "<<a[4]<<" "<<a[5]<<" "<<a[6]<<" "<<a[7]<<" "<<a[8]<<endl;
cnt++;
}
}
}
}
int main(){
for(int i=0;i<9;i++){
cin>>a[i];
num[a[i]]=1;
}
dfs(0);
cout<<cnt<<endl;
return 0;
}
|
problem
The JOI building is a combination of regular hexagons with a side of 1 meter as shown in the figure. As Christmas is approaching, JOI decided to decorate the walls of the building with illuminations. However, since it is useless to illuminate the parts that cannot be seen from the outside, we decided to decorate only the walls that can be reached from the outside without passing through the building.
<image>
Figure: Example of JOI building layout
The figure above is an example of the layout of JOI's buildings as seen from above. The numbers in the regular hexagon represent the coordinates. A gray regular hexagon represents a place with a building, and a white regular hexagon represents a place without a building. In this example, the part indicated by the solid red line is the wall surface to be decorated with illumination, and the total length of the wall surface is 64 meters.
Given a map showing the layout of JOI's buildings, create a program to find the total length of the walls to decorate. However, the outside of the map can be freely moved, and it is not possible to pass between adjacent buildings.
input
Two integers W and H (1 ≤ W ≤ 100, 1 ≤ H ≤ 100) are written on the first line of the input file, separated by blanks. The following line H describes the layout of the JOI building. On the first line of i + (1 ≤ i ≤ H), W integers are written separated by blanks, and the jth (1 ≤ j ≤ W) integer is a regular hexagon with coordinates (j, i). It is 1 when there is a building in, and 0 when there is no building. Also, the input data given always has one or more buildings.
The map is described by the following rules.
* The westernmost regular hexagon in the northernmost row of the map is the coordinates (1, 1).
* The eastern adjacent regular hexagon adjacent to the regular hexagon with coordinates (x, y) is the coordinates (x + 1, y).
* When y is odd, the coordinates of the southwestern regular hexagon adjacent to the regular hexagon of coordinates (x, y) are (x, y + 1).
* When y is even, the coordinates of the southeastern regular hexagon adjacent to the regular hexagon of coordinates (x, y) are (x, y + 1).
output
Output the total length of the walls to be decorated with illuminations in one line.
Input / output example
Input example 1
8 4
0 1 0 1 0 1 1 1
0 1 1 0 0 1 0 0
1 0 1 0 1 1 1 1 1
0 1 1 0 1 0 1 0
Output example 1
64
Input / output example 1 corresponds to the example in the problem statement, and the total length of the wall surface decorated with illumination is 64 meters.
Input example 2
8 5
0 1 1 1 0 1 1 1
0 1 0 0 1 1 0 0
1 0 0 1 1 1 1 1 1
0 1 0 1 1 0 1 0
0 1 1 0 1 1 0 0
Output example 2
56
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
8 4
0 1 0 1 0 1 1 1
0 1 1 0 0 1 0 0
1 0 1 0 1 1 1 1
0 1 1 0 1 0 1 0
Output
64
|
#include<stdio.h>
#include<algorithm>
#include<queue>
using namespace std;
int dat[501][501];
int dx[]={0,0,1,1,-1,-1};
int dy[]={1,-1,-1,0,0,+1};
int bfs[501][501];
int main(){
int a,b;
scanf("%d%d",&b,&a);
for(int i=0;i<a;i++){
for(int j=0;j<b;j++){
if(j+1+a-(i+1)/2<0)printf("dededon\n");
scanf("%d",&dat[i+1][j+1+a-(i+1)/2]);
}
}
queue<pair<int,int> > Q;
Q.push(make_pair(0,0));
bfs[0][0]=1;
while(Q.size()){
int row=Q.front().first;
int col=Q.front().second;
Q.pop();
for(int i=0;i<6;i++){
if(0<=row+dx[i]&&row+dx[i]<=500&&0<=col+dy[i]&&col+dy[i]<=500&&!dat[row+dx[i]][col+dy[i]]&&!bfs[row+dx[i]][col+dy[i]]){
bfs[row+dx[i]][col+dy[i]]=1;
Q.push(make_pair(row+dx[i],col+dy[i]));
}
}
}
int ret=0;
for(int i=1;i<500;i++){
for(int j=1;j<500;j++){
for(int k=0;k<6;k++){
if(dat[i][j]&&bfs[i+dx[k]][j+dy[k]])ret++;
}
}
}
printf("%d\n",ret);
}
|
Problem
KND is a student programmer at the University of Aizu. He is known to be a sweet tooth. He will be staying in a city for a year and wants to visit all N sweets shops in the city during that time. So I think the best place to live for the past year is the best place to go around the sweets shop. As his neighbor, you have to find a place that minimizes the worst travel time to each sweets shop. The city where this sweets shop is located is represented by a two-dimensional plane for the sake of simplicity. He travels a different distance per unit time depending on his motivation for the desired sweets shop. He also intends to live anywhere (even in the same place as the sweets shop). KND is uncompromising when it comes to sweetness.
Constraints
The input satisfies the following conditions.
* All inputs are integers.
* 2 ≤ N ≤ 100
* 0 ≤ xi, yi ≤ 100
* 1 ≤ vi ≤ 100 (1 ≤ i ≤ N)
* xi ≠ xj or yi ≠ yj (where 1 ≤ i <j ≤ N)
Input
The input consists of multiple test cases. One test case is given in the following format. Indicates the end of input when N = 0.
N
x1 y1 v1
x2 y2 v2
...
xN yN vN
here,
* N: Number of sweets shops
* xi: x-coordinate of the i-th sweetener
* yi: y coordinate of the i-th sweets shop
* vi: Distance traveled per unit time when moving to the i-th sweets shop
Is.
Output
Output the minimum travel time for each test case on one line. This value should not differ more than 10-5 from the value of the judge output.
Example
Input
2
1 1 1
2 2 1
4
1 1 3
3 1 3
4 2 1
1 5 3
0
Output
0.70710678
1.06066017
|
#include<cmath>
#include<cstdio>
#include<vector>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
const double EPS=1e-8;
template<class T>
struct point{
T x,y;
point operator+(const point &a)const{ return (point){x+a.x,y+a.y}; }
point operator-(const point &a)const{ return (point){x-a.x,y-a.y}; }
};
template<class T>
point<T> operator*(T c,const point<T> &a){ return (point<T>){c*a.x,c*a.y}; }
template<class T>
double abs(const point<T> &a){ return sqrt(a.x*a.x+a.y*a.y); }
template<class T>
struct circle{
point<T> c;
T r;
};
template<class T>
double dist(const point<T> &a,const point<T> &b){
return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}
bool cover(const circle<double> &C,const point<double> &p){
return dist(C.c,p)<C.r+EPS;
}
int get_intersect(const circle<double> &C1,const circle<double> &C2,vector< point<double> > &res){
double r1=C1.r,r2=C2.r;
point<double> p1=C1.c,p2=C2.c;
double d=abs(p1-p2);
if(d<EPS && abs(r1-r2)<EPS){ // C1==C2
return -1;
}
else if(r1+r2<d-EPS || d+EPS<abs(r1-r2)){
return 0;
}
else{
double a=(r1*r1-r2*r2+d*d)/(2*d);
double h=sqrt(max(r1*r1-a*a,0.0));
point<double> tmp1=p1+a/d*(p2-p1);
point<double> tmp2=h/d*(p2-p1);
if(abs(tmp2)<EPS){
res.push_back(tmp1);
return 1;
}
else{
res.push_back((point<double>){tmp1.x-tmp2.y,tmp1.y+tmp2.x});
res.push_back((point<double>){tmp1.x+tmp2.y,tmp1.y-tmp2.x});
return 2;
}
}
}
int main(){
for(int n;scanf("%d",&n),n;){
circle<double> C[100];
int v[100];
rep(i,n) scanf("%lf%lf%d",&C[i].c.x,&C[i].c.y,v+i);
double lo=0,hi=1e7;
while(hi-lo>1e-6){
double mi=(lo+hi)/2;
rep(i,n) C[i].r=v[i]*mi;
vector< point<double> > cand;
rep(i,n) cand.push_back(C[i].c);
rep(i,n) rep(j,i) get_intersect(C[i],C[j],cand);
bool ok=false;
rep(i,cand.size()){
int j;
for(j=0;j<n;j++) if(!cover(C[j],cand[i])) break;
if(j==n){ ok=true; break; }
}
if(ok) hi=mi; else lo=mi;
}
printf("%.9f\n",(lo+hi)/2);
}
return 0;
}
|
Yoko’s math homework today was to calculate areas of polygons in the xy-plane. Vertices are all aligned to grid points (i.e. they have integer coordinates).
Your job is to help Yoko, not good either at math or at computer programming, get her home- work done. A polygon is given by listing the coordinates of its vertices. Your program should approximate its area by counting the number of unit squares (whose vertices are also grid points) intersecting the polygon. Precisely, a unit square “intersects the polygon” if and only if the in- tersection of the two has non-zero area. In the figure below, dashed horizontal and vertical lines are grid lines, and solid lines are edges of the polygon. Shaded unit squares are considered inter- secting the polygon. Your program should output 55 for this polygon (as you see, the number of shaded unit squares is 55).
<image>
Figure 1: A polygon and unit squares intersecting it
Input
The input file describes polygons one after another, followed by a terminating line that only contains a single zero.
A description of a polygon begins with a line containing a single integer, m (≥ 3), that gives the number of its vertices. It is followed by m lines, each containing two integers x and y, the coordinates of a vertex. The x and y are separated by a single space. The i-th of these m lines gives the coordinates of the i-th vertex (i = 1, ... , m). For each i = 1, ... , m - 1, the i-th vertex and the (i + 1)-th vertex are connected by an edge. The m-th vertex and the first vertex are also connected by an edge (i.e., the curve is closed). Edges intersect only at vertices. No three edges share a single vertex (i.e., the curve is simple). The number of polygons is no more than 100. For each polygon, the number of vertices (m) is no more than 100. All coordinates x and y satisfy -2000 ≤ x ≤ 2000 and -2000 ≤ y ≤ 2000.
Output
The output should consist of as many lines as the number of polygons. The k-th output line should print an integer which is the area of the k-th polygon, approximated in the way described above. No other characters, including whitespaces, should be printed.
Example
Input
4
5 -3
1 0
1 7
-7 -1
3
5 5
18 5
5 10
3
-5 -5
-5 -10
-18 -10
5
0 0
20 2
11 1
21 2
2 0
0
Output
55
41
41
23
|
#include <algorithm>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
#define REP(i, a, b) for(int i = (a); i < int(b); ++i)
#define rep(i, n) REP(i, 0, n)
#define ALL(x) begin(x), end(x)
constexpr double EPS = 1e-5;
struct point {
double x, y;
explicit point(double x_ = 0, double y_ = 0):x(x_), y(y_) {}
inline point operator+(const point &p) const {
return point(x + p.x, y + p.y);
}
inline point operator-(const point &p) const {
return point(x - p.x, y - p.y);
}
inline point operator*(double s) const {
return point(x * s, y * s);
}
inline bool operator<(const point &p) const {
return x + EPS < p.x || (abs(x - p.x) < EPS && y + EPS < p.y);
}
};
inline double norm(const point &p) {
return p.x * p.x + p.y * p.y;
}
inline double dot(const point &a, const point &b) {
return a.x * b.x + a.y * b.y;
}
inline double cross(const point &a, const point &b) {
return a.x * b.y - a.y * b.x;
}
inline int ccw(const point &a, point b, point c) {
b = b - a;
c = c - a;
const double t = cross(b, c);
if(t > EPS) return 1;
if(t < -EPS) return -1;
if(dot(b, c) < 0) return 2;
if(norm(b) < norm(c)) return -2;
return 0;
}
typedef vector<point> polygon;
struct segment {
point a, b;
segment(const point &a_, const point &b_):a(a_), b(b_) {}
};
inline bool intersect(const segment &s, const point &p) {
return ccw(s.a, s.b, p) == 0;
}
inline bool intersect(const segment &s, const segment &t) {
return ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0
&& ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0;
}
inline point crosspoint(const segment &s, const segment &t) {
const double tmp = cross(s.b - s.a, t.b - t.a);
if(abs(tmp) < EPS) {
if(intersect(s, t.a)) return t.a;
if(intersect(s, t.b)) return t.b;
if(intersect(t, s.a)) return t.a;
return s.b;
}
return t.a + (t.b - t.a) * (cross(s.b - s.a, s.b - t.a) / tmp);
}
constexpr int MAX = 2000;
constexpr int INF = INT_MAX;
void update(vector<int> &exists, const segment &s, const vector<segment> &segments) {
}
int solve(const polygon &P) {
const int n = P.size();
vector<segment> segments;
segments.reserve(n);
point prev = P.back();
for(const auto &curr : P) {
segments.emplace_back(prev, curr);
prev = curr;
}
int ans = 0;
for(int y = -MAX; y <= MAX; ++y) {
vector<int> exists(MAX + MAX + 2, 0);
segment s1(point(-INF, y + EPS), point(INF, y + EPS));
segment s2(point(-INF, y + 1 - EPS), point(INF, y + 1 - EPS));
vector<pair<point, point>> cp;
for(const auto &s : segments) {
if(intersect(s, s1) && intersect(s, s2)) {
const point p1 = crosspoint(s, s1);
const point p2 = crosspoint(s, s2);
cp.emplace_back(min(p1, p2), max(p1, p2));
}
}
sort(ALL(cp));
for(int i = 0; i < static_cast<int>(cp.size()); i += 2) {
++exists[static_cast<int>(floor(cp[i].first.x)) + MAX];
--exists[static_cast<int>(ceil(cp[i + 1].second.x)) + MAX];
}
partial_sum(ALL(exists), exists.begin());
for(const auto &e : exists) {
if(e) ++ans;
}
}
return ans;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
for(int n; cin >> n && n;) {
polygon P;
P.reserve(n);
rep(i, n) {
int x, y;
cin >> x >> y;
P.emplace_back(x, y);
}
cout << solve(P) << endl;
}
return EXIT_SUCCESS;
}
|
Example
Input
6
2
3
1
1
4
2
Output
Yes
Yes
Yes
No
Yes
No
|
#include<iostream>
#include<algorithm>
#include<cstdio>
using namespace std;
long long n,a,b[1000000],c,p;
int main(){
cin>>n;
for(int i=0;i<n;i++){
scanf("%d",&a);if(b[0]==1 || c>a){printf("No\n");continue;}
if(c==a && p!=a){printf("No\n");continue;}p++;
if(a>=1000000){printf("Yes\n");continue;}
b[a]++;while(b[a]>=2){b[a]-=2;b[a-1]++;a--;p--;}
while(c<=999998 && b[c+1]==1)c++;
printf("Yes\n");
}
return 0;
}
|
Entrance Examination
The International Competitive Programming College (ICPC) is famous for its research on competitive programming. Applicants to the college are required to take its entrance examination.
The successful applicants of the examination are chosen as follows.
* The score of any successful applicant is higher than that of any unsuccessful applicant.
* The number of successful applicants n must be between nmin and nmax, inclusive. We choose n within the specified range that maximizes the gap. Here, the gap means the difference between the lowest score of successful applicants and the highest score of unsuccessful applicants.
* When two or more candidates for n make exactly the same gap, use the greatest n among them.
Let's see the first couple of examples given in Sample Input below. In the first example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 82, 70, and 65. For n of two, three and four, the gaps will be 8, 12, and 5, respectively. We must choose three as n, because it maximizes the gap.
In the second example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 80, 75, and 65. For n of two, three and four, the gap will be 10, 5, and 10, respectively. Both two and four maximize the gap, and we must choose the greatest number, four.
You are requested to write a program that computes the number of successful applicants that satisfies the conditions.
Input
The input consists of multiple datasets. Each dataset is formatted as follows.
> m nmin nmax
> P1
> P2
> ...
> Pm
>
The first line of a dataset contains three integers separated by single spaces. m represents the number of applicants, nmin represents the minimum number of successful applicants, and nmax represents the maximum number of successful applicants. Each of the following m lines contains an integer Pi, which represents the score of each applicant. The scores are listed in descending order. These numbers satisfy 0 < nmin < nmax < m ≤ 200, 0 ≤ Pi ≤ 10000 (1 ≤ i ≤ m) and Pnmin > Pnmax+1. These ensure that there always exists an n satisfying the conditions.
The end of the input is represented by a line containing three zeros separated by single spaces.
Output
For each dataset, output the number of successful applicants in a line.
Sample Input
5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0
Output for the Sample Input
3
4
2
2
3
2
Example
Input
5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0
Output
3
4
2
2
3
2
|
#include <iostream>
using namespace std;
int main() {
int m,min,max,ten[200],gap=10001,sa;
cin>>m>>min>>max;
while(1){
if(m==0 && min==0 && max==0){
break;
}
for(int i=1;i<=m;i++){
cin>>ten[i];
}
for(int i=min;i<=max;i++){
if(gap>=ten[i+1]-ten[i]){
gap=ten[i+1]-ten[i];
sa=i;
}
}
cout<<sa<<endl;
gap=10001;
sa=0;
cin>>m>>min>>max;
}
return 0;
}
|
Franklin Jenkins is a programmer, but he isn’t good at typing keyboards. So he always uses only ‘f’ and ‘j’ (keys on the home positions of index fingers) for variable names. He insists two characters are enough to write programs, but naturally his friends don’t agree with him: they say it makes programs too long.
He asked you to show any program can be converted into not so long one with the f-j names. Your task is to answer the shortest length of the program after all variables are renamed into the f-j names, for each given program.
Given programs are written in the language specified below.
A block (a region enclosed by curly braces: ‘{’ and ‘}’) forms a scope for variables. Each scope can have zero or more scopes inside. The whole program also forms the global scope, which contains all scopes on the top level (i.e., out of any blocks).
Each variable belongs to the innermost scope which includes its declaration, and is valid from the decla- ration to the end of the scope. Variables are never redeclared while they are valid, but may be declared again once they have become invalid. The variables that belong to different scopes are regarded as differ- ent even if they have the same name. Undeclared or other invalid names never appear in expressions.
The tokens are defined by the rules shown below. All whitespace characters (spaces, tabs, linefeeds, and carrige-returns) before, between, and after tokens are ignored.
token:
identifier | keyword | number | operator | punctuation
identifier:
[a-z]+ (one or more lowercase letters)
keyword:
[A-Z]+ (one or more uppercase letters)
number:
[0-9]+ (one or more digits)
operator:
‘=’ | ‘+’ | ‘-’ | ‘*’ | ‘/’ | ‘&’ | ‘|’ | ‘^’ | ‘<’ | ‘>’
punctuation:
‘{’ | ‘}’ | ‘(’ | ‘)’ | ‘;’
The syntax of the language is defined as follows.
program:
statement-list
statement-list:
statement
statement-list statement
statement:
variable-declaration
if-statement
while-statement
expression-statement
block-statement
variable-declaration:
“VAR” identifier ‘;’
if-statement:
“IF” ‘(’ expression ‘)’ block-statement
while-statement:
“WHILE” ‘(’ expression ‘)’ block-statement
expression-statement:
expression ‘;’
block-statement:
‘{’ statement-listoptional ‘}’
expression:
identifier
number
expression operator expression
Input
The input consists of multiple data sets.
Each data set gives a well-formed program according to the specification above. The first line contains a positive integer N, which indicates the number of lines in the program. The following N lines contain the program body.
There are no extra characters between two adjacent data sets.
A single line containing a zero indicates the end of the input, and you must not process this line as part of any data set.
Each line contains up to 255 characters, and all variable names are equal to or less than 16 characters long. No program contains more than 1000 variables nor 100 scopes (including the global scope).
Output
For each data set, output in one line the minimum program length after all the variables are renamed into the f-j name. Whitespace characters must not counted for the program length. You are not allowed to perform any operations on the programs other than renaming the variables.
Examples
Input
14
VAR ga;
VAR gb;
IF(ga > gb) {
VAR saa;
VAR sab;
IF(saa > ga) {
saa = sab;
}
}
WHILE(gb > ga) {
VAR sba;
sba = ga;
ga = gb;
}
7
VAR thisisthelongest;
IF(thisisthelongest / 0) {
VARone;
one = thisisthelongest + 1234567890123456789012345;
}
VAR another;
32 = another;
0
Output
73
59
Input
14
VAR ga;
VAR gb;
IF(ga > gb) {
VAR saa;
VAR sab;
IF(saa > ga) {
saa = sab;
}
}
WHILE(gb > ga) {
VAR sba;
sba = ga;
ga = gb;
}
7
VAR thisisthelongest;
IF(thisisthelongest / 0) {
VARone;
one = thisisthelongest + 1234567890123456789012345;
}
VAR another;
32 = another;
0
Output
73
59
|
#include <iostream>
#include <string>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cctype>
#include <map>
#include <functional>
using namespace std;
typedef vector<int> vint;
int ans;
const char *ptr;
char buf[256];
map<string,int> mp;
size_t cmp(const vint &v1, const vint &v2){
return v1.size() < v2.size();
}
vint block(bool brace, string varname = string()){
vector<vint> freqs;
map<string,int>::iterator it;
vector<string> varlist;
if(!varname.empty()){
varlist.push_back(varname);
mp.insert(make_pair(varname, 1));
}
if(brace) ++ptr;
while(*ptr != '}'){
if(*ptr == '{'){
freqs.push_back(block(true));
}
else if(*ptr == 'V'){ //VAR
ptr += 3;
ans += 3;
int dif = 0;
sscanf(ptr, " %[a-z]%n", buf, &dif);
varname = buf;
ptr += dif;
freqs.push_back(block(false, varname));
}
else if(islower(*ptr)){
sscanf(ptr, "%[a-z]", buf);
varname = buf;
ptr += varname.size();
++mp[varname];
}
else if(!isspace(*ptr++)){
++ans;
}
}
if(brace){
++ptr;
ans += 2;
}
vint res;
if(freqs.size() == 1){
res.swap(freqs[0]);
}
else if(freqs.size() > 1){
int maxsize = max_element(freqs.begin(), freqs.end(), cmp)->size();
for(int i = 0; i < maxsize; ++i){
int s = 0;
for(int j = 0; j < freqs.size(); ++j){
if(i < freqs[j].size()){
s += freqs[j][i];
}
}
res.push_back(s);
}
}
for(int i = 0; i < varlist.size(); ++i){
it = mp.find(varlist[i]);
res.push_back(it->second);
mp.erase(it);
}
sort(res.begin(), res.end(), greater<int>());
return res;
}
int main(){
string s, lines;
int n;
while(cin >> n, n){
cin.ignore();
lines = "{";
for(int i = 0; i < n; ++i){
getline(cin, s);
lines += s;
}
lines += '}';
ans = -2;
mp.clear();
ptr = lines.c_str();
vint v = block(true);
v.resize(1024, 0);
vint::iterator it1 = v.begin(), it2;
for(int i = 1; i <= 9; ++i){
it2 = it1 + (1 << i);
ans += accumulate(it1, it2, 0) * i;
it1 = it2;
}
cout << ans << '\n';
}
}
|
N circles are drawn on the paper. The rabbit has k-colored paint and paints the paper according to the following rules.
* Paint each area with one color of paint or nothing. Here, the "area" refers to the part with a finite area surrounded by a set of arcs.
* Two adjacent areas cannot be painted with the same color. Here, "adjacent" means that there is an arc that shares a part of the boundary. There are a finite number of shared points. Two areas are not considered to be adjacent.
* It is permissible to leave both adjacent areas unpainted.
Rabbit wants to paint as many areas as possible. Find the maximum number of areas that can be painted.
Input
Line 1: n k (1 ≤ n ≤ 20, 1 ≤ k ≤ 1 000 000 000)
Line 2- (n + 1): xi yi ri, (-1 000 ≤ xi, yi ≤ 1 000, 1 ≤ ri ≤ 1 000) (integer)
Neither two circles match.
The point set obtained as the intersection of any two circles does not include two different points with a distance of 10-3 or less.
Output
Output the maximum number of areas that can be painted with paint on one line.
Example
Input
2 1
10 0 10
20 0 10
Output
2
|
#include<stdio.h>
#include<algorithm>
#include<vector>
#include<math.h>
#include<queue>
using namespace std;
const int D_MAX_V=20002;
const int D_v_size=20002;
struct D_wolf{
int t,c,r;
D_wolf(){t=c=r=0;}
D_wolf(int t1,int c1,int r1){
t=t1;c=c1;r=r1;
}
};
vector<D_wolf>D_G[D_MAX_V];
int D_level[D_MAX_V];
int D_iter[D_MAX_V];
void add_edge(int from,int to,int cap){
D_G[from].push_back(D_wolf(to,cap,D_G[to].size()));
D_G[to].push_back(D_wolf(from,0,D_G[from].size()-1));
}
void D_bfs(int s){
for(int i=0;i<D_v_size;i++)D_level[i]=-1;
queue<int> Q;
D_level[s]=0;
Q.push(s);
while(Q.size()){
int v=Q.front();
Q.pop();
for(int i=0;i<D_G[v].size();i++){
if(D_G[v][i].c>0&&D_level[D_G[v][i].t]<0){
D_level[D_G[v][i].t]=D_level[v]+1;
Q.push(D_G[v][i].t);
}
}
}
}
int D_dfs(int v,int t,int f){
if(v==t)return f;
for(;D_iter[v]<D_G[v].size();D_iter[v]++){
int i=D_iter[v];
if(D_G[v][i].c>0&&D_level[v]<D_level[D_G[v][i].t]){
int d=D_dfs(D_G[v][i].t,t,min(f,D_G[v][i].c));
if(d>0){
D_G[v][i].c-=d;
D_G[D_G[v][i].t][D_G[v][i].r].c+=d;
return d;
}
}
}
return 0;
}
int max_flow(int s,int t){
int flow=0;
for(;;){
D_bfs(s);
if(D_level[t]<0)return flow;
for(int i=0;i<D_v_size;i++)D_iter[i]=0;
int f;
while((f=D_dfs(s,t,99999999))>0){flow+=f;}
}
return 0;
}
const double EPS = 1e-10;
double eps=1e-6;
const double INF = 1e+10;
const double PI = acos(-1);
int sig(double r) { return (r < -EPS) ? -1 : (r > +EPS) ? +1 : 0; }
inline double ABS(double a){return max(a,-a);}
struct Pt {
double x, y;
Pt() {}
Pt(double x, double y) : x(x), y(y) {}
Pt operator+(const Pt &a) const { return Pt(x + a.x, y + a.y); }
Pt operator-(const Pt &a) const { return Pt(x - a.x, y - a.y); }
Pt operator*(const Pt &a) const { return Pt(x * a.x - y * a.y, x * a.y + y * a.x); }
Pt operator-() const { return Pt(-x, -y); }
Pt operator*(const double &k) const { return Pt(x * k, y * k); }
Pt operator/(const double &k) const { return Pt(x / k, y / k); }
double ABS() const { return sqrt(x * x + y * y); }
double abs2() const { return x * x + y * y; }
double arg() const { return atan2(y, x); }
double dot(const Pt &a) const { return x * a.x + y * a.y; }
double det(const Pt &a) const { return x * a.y - y * a.x; }
};
inline bool operator< (const Pt&a,const Pt &b){
int t=sig(b.x-a.x);
if(t)return t>0;
t=sig(b.y-a.y);
return t>0;
}
double tri(const Pt &a, const Pt &b, const Pt &c) { return (b - a).det(c - a); }
int iCC(Pt a, double r, Pt b, double s) {
double d = (b - a).ABS();
if (sig(d) == 0 && sig(r - s) == 0) return -1; // correspond
if (sig(r - s - d) > 0) return +2; // r > s
if (sig(s - r - d) > 0) return -2; // s > r
return (sig(r + s - d) >= 0) ? 1 : 0;
}
double dLP(Pt a, Pt b, Pt c) {
return ABS(tri(a, b, c)) / (b - a).ABS();
}
pair<Pt,Pt> pCC(Pt a, double r, Pt b, double s) {
double d = (b - a).ABS();
double x = (d * d + r * r - s * s) / (d * 2);
Pt e = (b - a) / d, w = e * Pt(0, 1) * sqrt(max(r * r - x * x, 0.0));
return make_pair(a + e * x - w, a + e * x + w);
}
pair<Pt,Pt> pCL(Pt a, double r, Pt b, Pt c) {
Pt h = b + (c - b) * (c - b).dot(a - b) / (c - b).abs2(); // perp(b, c, a)
double d = (h - a).ABS();
double y = sqrt(max(r * r - d * d, 0.0));
Pt e = (c - b) / (c - b).ABS();
return make_pair(h - e * y, h + e * y);
}
double x[30];
double y[30];
double r[30];
Pt p[30];
vector<Pt> v;
vector<int>now;
vector<pair<double,double> > seg;
int UF[1200];
int FIND(int a){
if(UF[a]<0)return a;
return UF[a]=FIND(UF[a]);
}
void UNION(int a,int b){
a=FIND(a);b=FIND(b);if(a==b)return;UF[a]+=UF[b];UF[b]=a;
}
int to[1200];
int g[1200][1200];
int tg[1200][1200];
int tL[1200];
int L[1200];
int main(){
int a,b;
scanf("%d%d",&a,&b);
for(int i=0;i<1200;i++)UF[i]=-1;
for(int i=0;i<a;i++)scanf("%lf%lf%lf",x+i,y+i,r+i);
for(int i=0;i<a;i++){
p[i]=Pt(x[i],y[i])*Pt(cos(1),sin(1));
}
p[a]=Pt(0,0);
r[a]=1000000;
//a++;
//for(int i=0;i<a;i++)r[i]+=EPS;
for(int i=0;i<a;i++){
bool ok=true;
for(int j=0;j<v.size();j++){
if((p[i]-Pt(r[i],0)-v[j]).ABS()<eps)ok=false;
}
if(ok)v.push_back(p[i]-Pt(r[i],0));
ok=true;
for(int j=0;j<v.size();j++){
if((p[i]+Pt(r[i],0)-v[j]).ABS()<eps)ok=false;
}
if(ok)v.push_back(p[i]+Pt(r[i],0));
}
for(int i=0;i<a;i++){
for(int j=i+1;j<a;j++){
if(iCC(p[i],r[i],p[j],r[j])==1){
pair<Pt,Pt> tmp=pCC(p[i],r[i],p[j],r[j]);
bool ok=true;
for(int k=0;k<v.size();k++){
if((v[k]-tmp.first).ABS()<eps)ok=false;
}
if(ok)v.push_back(tmp.first);
ok=true;
for(int k=0;k<v.size();k++){
if((v[k]-tmp.second).ABS()<eps)ok=false;
}
if(ok)v.push_back(tmp.second);
}
}
}
std::sort(v.begin(),v.end());
v.push_back(Pt(10000,0));
seg.push_back(make_pair(-10000,10000));
int sz=0;
now.push_back(sz++);
for(int i=0;i<v.size()-1;i++){
int t=1;
// printf("%.12f %.12f\n",v[i].x,v[i].y);
double mx=(v[i+1].x+v[i].x)/2;
vector<double>tmp2;
tmp2.push_back(-10000);
tmp2.push_back(10000);
for(int j=0;j<a;j++){
if(dLP(Pt(mx,0),Pt(mx,1),p[j])<r[j]){
t+=2;
pair<Pt,Pt>sc=pCL(p[j],r[j],Pt(mx,0),Pt(mx,1));
tmp2.push_back(sc.first.y);
tmp2.push_back(sc.second.y);
}
}
std::sort(tmp2.begin(),tmp2.end());
vector<double>tmp;
tmp.push_back(tmp2[0]);
for(int j=1;j<tmp2.size();j++)tmp.push_back(tmp2[j]);
// t=tmp.size()-1;
for(int j=0;j<now.size()-1;j++){
tg[now[j]][now[j+1]]=tg[now[j+1]][now[j]]=1;
}
// for(int j=0;j<seg.size();j++)printf("(%.12f, %.12f) ",seg[j].first,seg[j].second);printf("\n");
if(t>now.size()){
int at=-1;
for(int j=0;j<tmp2.size()-1;j++)if(tmp2[j]<v[i].y&&tmp2[j+1]>v[i].y)at=j;
at--;
// printf("%d\n",at);
now.push_back(-1);
now.push_back(-1);
for(int j=now.size()-3;j>=at;j--){
now[j+2]=now[j];
}
if(at%2==0)tL[sz]=1;
now[at+1]=sz++;
}else if(t<now.size()){
int at=-1;
for(int j=0;j<now.size();j++)if(seg[j].first<v[i].y&&v[i].y<seg[j].second)at=j;
// printf("%d\n",at);
UNION(now[at-1],now[at+1]);
for(int j=at;j<now.size()-2;j++)now[j]=now[j+2];
now.pop_back();now.pop_back();
}else{
int at=-1;
for(int j=0;j<now.size();j++){
int ci=-1;
int cj=-1;
for(int k=0;k<a;k++)if(ABS((Pt(mx,tmp2[j])-p[k]).ABS()-r[k])<eps)ci=k;
bool ui=false;
bool uj=false;
if(v[i].y>p[ci].y)ui=true;
for(int k=0;k<a;k++)if(ABS((Pt(mx,tmp2[j+1])-p[k]).ABS()-r[k])<eps)cj=k;
if(v[i].y>p[cj].y)uj=true;
if(!~ci||!~cj)continue;
if(ABS((v[i]-p[ci]).ABS()-r[ci])<eps&&ABS((v[i]-p[cj]).ABS()-r[cj])<eps){
if(ui&&tmp2[j]<p[ci].y)continue;
if(uj&&tmp2[j+1]<p[cj].y)continue;
if(!ui&&tmp2[j]>p[ci].y)continue;
if(!uj&&tmp2[j+1]>p[cj].y)continue;
at=j;
// printf("%d\n",j);
if(at%2)tL[sz]=1;
now[at]=sz++;
}
}
}
seg.clear();
for(int j=0;j<tmp.size()-1;j++){
seg.push_back(make_pair(tmp[j],tmp[j+1]));
}
// for(int j=0;j<now.size();j++)printf("%d ",now[j]);
//printf("\n");
}
int n=0;
for(int i=0;i<sz;i++)if(UF[i]<0)to[i]=n++;
for(int i=0;i<sz;i++)to[i]=to[FIND(i)];
for(int i=0;i<sz;i++)L[to[i]]=tL[i];
for(int i=0;i<sz;i++){
for(int j=0;j<sz;j++){
if(to[i]!=to[j])g[to[i]][to[j]]|=tg[i][j];
}
}
//for(int i=0;i<sz;i++)printf("%d ",to[i]);
//printf("\n");
sz=n;
if(b>=2){
printf("%d\n",sz-1);return 0;
}
int S=sz*2;
int T=sz*2+1;
for(int i=0;i<sz;i++){
if(to[0]==i)continue;
if(L[i])add_edge(S,i,1);
else add_edge(i+sz,T,1);
}
for(int i=0;i<sz;i++)for(int j=0;j<sz;j++){
if(to[0]==i||to[0]==j)continue;
if(L[i]&&g[i][j]){
add_edge(i,j+sz,1);
}
}
//printf("%d\n",sz);
//for(int i=0;i<sz;i++){
// for(int j=0;j<sz;j++){
// printf("%d ",g[i][j]);
// }
// printf("\n");
// }
printf("%d\n",sz-1-max_flow(S,T));
}
|
G: Code Art Online
Code Art Online (CAO) is an online RPG that advances adventures by solving various problems by programming. Since CAO was the world's first game that realized a virtual reality space, it was sold out while it was very popular, and users who purchased the game should enjoy this world. However, players who dive into the game are told a terrifying decree by the gamemaster.
"Unless some of you players solve the last problem of the last dungeon, you can't get out of this virtual space. And in this world, WA and TLE / RE mean death in the real world. I want you to start the problem with your heart. "
You are one of the CAO players, and you are doing your best to capture the game in order to clear this game and return to the real world. One day, you face the following problems.
This time, a party was formed with n members to capture the new dungeon. You are one of the parties. In order to enter the dungeon that you are about to capture, you must pass through a hole that can be seen from the cliff. If you can pass through the hole safely, you can enter the dungeon, but if you can not enter the hole and touch other parts, death is waiting. Furthermore, if someone passes through one hole, that hole will close, so each person must enter a separate hole.
Holes and people are considered on a two-dimensional plane. The shape of the hole is a circle of various sizes, as shown in Fig. G-1. In the input, the length of the radius is given.
<image>
---
Figure G-1: Hole shape
As shown in Fig. G-2, the human shape is given as a polygonal cross section of the human (not necessarily convex). In the input, the vertices are given counterclockwise to represent the shape of the polygon. It can be assumed that any three points of a polygon do not line up on a straight line. Furthermore, it is assumed that polygonal line segments do not intersect each other except for the purpose of forming vertices. It may rotate freely to pass through the hole (however, rotation in the z-axis direction is prohibited). It is assumed that the vertices of a polygon representing a person can pass through the hole even if it is on the circumference of the hole.
<image>
---
Figure G-2: Human shape
You, who have the highest algorithm skills in the party, decided to solve the decision problem of whether everyone can pass through the hole safely. If you can pass it safely, indicate who should pass which hole.
* You will not die in this contest, but if you make a mistake, please solve it with the intention of dying.
Input
On the first line, the integer n (1 <= n <= 100), which represents the number of holes, and the integer m (1 <= m <= n), which represents the number of parties, are entered separated by spaces.
In the next line, n integers ri (1 <= ri <= 1000) representing the radius of the hole are entered, separated by spaces. These holes are counted as the 1st hole, the 2nd hole, ..., and the nth hole in the order of input.
Then, information on the shape of m people is input. For the information of one person, the number of vertices p (3 <= p <= 100) of the polygon is first input to the first line. In the following line p, the coordinates of the vertices of the polygon are given counterclockwise. Integers xi, yi (-1000 <= xi, yi <= 1000) representing one vertex are entered in each line, separated by spaces. People are counted as the 1st person, the 2nd person, ..., and the mth person in the order of input.
Output
Output the number of hole that the person with i (1 <= i <= m) should enter. On the i-line, output the number of the hole that the person i should pass through.
If there are multiple paths, output the smallest path in lexicographical order. When there are two sequences A = {a1, a2, ..., am} and B = {b1, b2, ..., bm}, if A is smaller than B in lexicographical order, ai is bi. For the first i that is different, we say when ai is smaller than bi.
If no way is found, output one line as "NG". Don't forget to print a newline at the end.
Sample Input 1
3 3
25 100 10
8
-10 0
-twenty two
0 10
twenty two
10 0
twenty two
0 -10
-twenty two
Four
30 0
50 0
50 40
30 40
3
30 -10
45 -70
60 -10
Sample Output 1
3
1
2
Sample Input 2
4 3
25 15 15 30
Five
0 0
10 0
20 10
0 20
-20 10
3
20 0
40 0
30 10
3
-50 0
-30 0
-40 10
Sample Output 2
1
2
3
Sample Input 3
twenty two
1 30
Four
0 0
10 0
10 10
0 10
3
5 5
20 20
5 20
Sample Output 3
NG
Example
Input
3 3
25 100 10
8
-10 0
-2 2
0 10
2 2
10 0
2 -2
0 -10
-2 -2
4
30 0
50 0
50 40
30 40
3
30 -10
45 -70
60 -10
Output
3
1
2
|
#include<bits/stdc++.h>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define EPS (1e-8)
#define equals(a,b) (fabs((a)-(b))<EPS)
using namespace std;
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;
class Point{
public:
double x,y;
Point(double x = 0,double y = 0): x(x),y(y){}
Point operator + (Point p){return Point(x+p.x,y+p.y);}
Point operator - (Point p){return Point(x-p.x,y-p.y);}
bool operator < (const Point& p) const{ return !equals(x,p.x)?x<p.x:y<p.y; }
};
typedef Point Vector;
typedef vector<Point> Polygon;
double dot(Point a,Point b){ return a.x*b.x + a.y*b.y; }
double cross(Point a,Point b){ return a.x*b.y - a.y*b.x; }
double norm(Point a){ return a.x*a.x+a.y*a.y; }
double abs(Point a){ return sqrt(norm(a)); }
int ccw(Point p0,Point p1,Point p2){
Point a = p1-p0;
Point b = p2-p0;
if(cross(a,b) > EPS)return COUNTER_CLOCKWISE;
if(cross(a,b) < -EPS)return CLOCKWISE;
if(dot(a,b) < -EPS)return ONLINE_BACK;
if(norm(a) < norm(b))return ONLINE_FRONT;
return ON_SEGMENT;
}
Polygon andrewScan(Polygon s){
Polygon u,l;
if(s.size() < 3)return s;
sort(s.begin(),s.end());
u.push_back(s[0]);
u.push_back(s[1]);
l.push_back(s[s.size()-1]);
l.push_back(s[s.size()-2]);
for(int i=2;i<s.size();i++){
for(int n=u.size();n >= 2 && ccw(u[n-2],u[n-1],s[i]) != CLOCKWISE; n--) u.pop_back();
u.push_back(s[i]);
}
for(int i=s.size()-3; i>=0 ; i--){
for(int n=l.size(); n >= 2 && ccw(l[n-2],l[n-1],s[i]) != CLOCKWISE; n--) l.pop_back();
l.push_back(s[i]);
}
reverse(l.begin(),l.end());
for(int i = u.size()-2; i >= 1; i--) l.push_back(u[i]);
return l;
}
vector<int> G[310];
int match[310];
bool used[310];
int V;
void add_edge(int u,int v){
G[u].push_back(v);
G[v].push_back(u);
}
bool dfs(int v){
used[v] = true;
for(int i=0;i<G[v].size();i++){
int u = G[v][i], w = match[u];
if( w < 0 || !used[w] && dfs(w) ) {
match[v] = u;
match[u] = v;
return true;
}
}
return false;
}
int bipartite_matching(){
int res = 0;
memset(match,-1,sizeof(match));
rep(v,V){
if( match[v] < 0 ) {
memset(used,0,sizeof(used));
if( dfs(v) ) res++;
}
}
return res;
}
int n,m;
double r[110],poly_r[110];
Polygon vec[110];
Point ps[110];
vector<int> cand[110];
inline double dist(Point a) { return sqrt(a.x*a.x+a.y*a.y); }
bool LT(double a,double b) { return !equals(a,b) && a < b; }
bool LTE(double a,double b) { return equals(a,b) || a < b; }
Point calc_ps(Polygon poly) {
poly = andrewScan(poly);
Point mp = poly[0];
double rate = 1;
int max_pos;
double eps = 1e-10;
while( rate > eps ) {
rep(_,60){
max_pos = 0;
REP(j,1,poly.size()) {
double dist1 = dist(mp-poly[max_pos]);
double dist2 = dist(mp-poly[j]);
if( !fabs(dist1-dist2) < eps && dist1 < dist2 ) max_pos = j;
}
mp.x += ( poly[max_pos].x - mp.x ) * rate;
mp.y += ( poly[max_pos].y - mp.y ) * rate;
}
rate *= 0.5;
}
return mp;
}
int main(){
cin >> n >> m;
V = n + m;
rep(i,n) cin >> r[i];
rep(i,m) {
int p;
cin >> p;
vec[i].resize(p);
rep(j,p) cin >> vec[i][j].x >> vec[i][j].y;
}
rep(i,m) ps[i] = calc_ps(vec[i]);
rep(i,m) {
double maxi = dist(ps[i]-vec[i][0]);
REP(j,1,vec[i].size()) maxi = max(maxi,dist(ps[i]-vec[i][j]));
poly_r[i] = maxi;
}
set<int> S[n];
rep(i,n) {
rep(j,m){
if( LTE(poly_r[j],r[i]) ) { cand[i].push_back(j); S[i].insert(j); }
}
}
int ans[m];
bool completed[n];
rep(i,m) ans[i] = -1;
rep(i,n) completed[i] = false;
rep(i,m) {
rep(j,n) if( !completed[j] && !cand[j].empty() ){
if( !S[j].count(i) ) continue;
rep(k,V) G[k].clear();
rep(k,n) if( k != j && !completed[k] )rep(l,cand[k].size()) {
if( cand[k][l] == i || ans[cand[k][l]] != -1 ) continue;
add_edge(cand[k][l],k+m);
}
int res = bipartite_matching();
if( res == m - i - 1 ) {
ans[i] = j + 1;
completed[j] = true;
goto Skip;
}
}
Skip:;
if( ans[i] == -1 ) { puts("NG"); return 0; }
}
rep(i,m) cout << ans[i] << endl;
return 0;
}
|
G --Derangement / Derangement
Story
Person D is doing research on permutations. At one point, D found a permutation class called "Derangement". "It's cool to have a perfect permutation !!! And it starts with D !!!", the person of D who had a crush on Chunibyo decided to rewrite all the permutations given to him.
Problem
Given a permutation of length n, p = (p_1 p_2 ... p_n). The operation of swapping the i-th element and the j-th element requires the cost of (p_i + p_j) \ times | i-j |. At this time, find the minimum cost required to make p into a perfect permutation using only the above swap operation.
However, the fact that the permutation q is a perfect permutation means that q_i \ neq i holds for 1 \ leq i \ leq n. For example, (5 3 1 2 4) is a perfect permutation, but (3 2 5 4 1) is not a perfect permutation because the fourth number is 4.
Input
The input consists of the following format.
n
p_1 p_2 ... p_n
The first row consists of one integer representing the length n of the permutation. The second line consists of n integers, and the i-th integer represents the i-th element of the permutation p. Each is separated by a single blank character.
Constraints:
* 2 \ leq n \ leq 100
* 1 \ leq p_i \ leq n, i \ neq j ⇔ p_i \ neq p_j
Output
Print the minimum cost to sort p into a complete permutation on one line. Be sure to start a new line at the end of the line.
Sample Input 1
Five
1 2 3 5 4
Sample Output 1
7
After swapping 1 and 2, swapping 1 and 3 yields (2 3 1 5 4), which is a complete permutation.
Sample Input 2
Five
5 3 1 2 4
Sample Output 2
0
It is a perfect permutation from the beginning.
Sample Input 3
Ten
1 3 4 5 6 2 7 8 9 10
Sample Output 3
38
Example
Input
5
1 2 3 5 4
Output
7
|
#include <bits/stdc++.h>
#define INF 1e9
using namespace std;
int n,arr[101];
int cal(int a,int b){return (arr[a]+arr[b])*(abs(a-b));}
void Min(int &a,int b){a=min(a,b);}
int mem[3][101][101][101];
int dfs(int f,int num,int l,int r){
if(l>r)return 0;
if(l==r)return (arr[l]==l+1) ? INF:0;
if(r-l==1)return (arr[l]==l+1||arr[r]==r+1)? cal(l,r):0;
if(mem[f][num][l][r]!=-1)return mem[f][num][l][r];
int res=INF;
for(int i=l+1;i<r;i++){
if((f==0||f==1)&&arr[i]!=l+1){
swap(arr[l],arr[i]);
Min(res,cal(l,i)+dfs(0,0,l+1,i-1)+dfs(1,arr[i],i,r));
swap(arr[l],arr[i]);
}
if((f==0||f==2)&&arr[i]!=r+1){
swap(arr[i],arr[r]);
Min(res,cal(i,r)+dfs(2,arr[i],l,i)+dfs(0,0,i+1,r-1));
swap(arr[i],arr[r]);
}
}
for(int i=l;i<r;i++){
if(f==1)Min(res,dfs(1,num,l,i)+dfs(0,0,i+1,r));
else if(f==2)Min(res,dfs(0,0,l,i)+dfs(2,num,i+1,r));
else Min(res,dfs(0,0,l,i)+dfs(0,0,i+1,r));
}
return mem[f][num][l][r]=res;
}
int main(){
cin>>n;
for(int i=0;i<n;i++)cin>>arr[i];
memset(mem,-1,sizeof(mem));
cout<<dfs(0,0,0,n-1)<<endl;
}
|
Example
Input
3 2 3 1 3
1 2 2 1
2 3 1 2
Output
6.0000000
|
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
const int non = 10000000;
struct edge {
int x, y, f, c, r;
};
vector<edge> E[202];
void add(int x, int y, int f, int c) {
int p = E[x].size(), q = E[y].size();
E[x].push_back({ x, y, f, c, q });
E[y].push_back({ y, x, 0, -c, p });
}
int N, M, P, s, t;
vector<int> last_dist;
int spfa(){
vector<int> dist(N, non), viax(N), viap(N);
vector<bool> chk(N);
priority_queue<pair<int, int> > qu;
qu.push({ 0, s }); dist[s] = 0;
while (!qu.empty()) {
int c = -qu.top().first, x = qu.top().second; qu.pop();
if (dist[x] < c) continue;
int p = 0;
for (auto &e : E[x]) {
if (e.f) {
int y = e.y, nc = c + e.c + last_dist[y] - last_dist[x];
if (dist[y] > nc) {
qu.push({ -nc, y });
dist[y] = nc;
viax[y] = x;
viap[y] = p;
}
}
p++;
}
}
if (dist[t] == non) return 0;
int ret = dist[t] - last_dist[t] + last_dist[s];
last_dist = dist;
int y = t;
while (y != s) {
int x = viax[y];
auto &e = E[x][viap[y]];
e.f--;
E[y][e.r].f++;
y = x;
}
return ret;
}
int main(){
scanf("%d %d %d %d %d", &N, &M, &P, &s, &t);
s--; t--;
for (int i = 0; i < M; i++) {
int x, y, d, c;
scanf("%d %d %d %d", &x, &y, &d, &c); x--; y--;
add(x, y, c, d);
}
int sum = 0, flow = 0; double ans = 1e10;
last_dist = vector<int>(N, non);
while (1) {
int now = spfa();
if (now == 0) break;
sum += now; flow++;
ans = min(ans, 1. * (sum + P) / flow);
}
printf("%.12lf\n", ans);
}
|
G： 検閲により置換 (Censored String)
Problem Statement
You are given the string S, and the set of strings \mathcal P whose size is N. Now we consider applying the following operation to S:
* Choose exactly one character in S, and replace it with '*'.
Let s_i be a i-th character of S, S_{ij} be a consecutive substring in S such that S = s_i s_{i+1} $\cdots$ s_j, and p_k as the k-th string of P. Your task is to calculate the minimum number of operations for satisfying the following condition.
* For all pairs (S_{ij}, p_k), it is satisfied that S_{ij} \neq p_k.
Input
An input is given in the following format.
S
N
p_1
p_2
$\vdots$
p_N
* In line 1, you are given the string S.
* In line 2, given an integer N. N means the size of P.
* From line 3 to the end, given p_i, the i-th string of P.
Constraints
* 1 \leq |S| \leq 10^5
* 1 \leq N \leq 10^5
* 1 \leq |p_1| + |p_2| + $\cdots$ + |p_N| \leq 10^5
* If i \neq j, it is guaranteed that p_i \neq p_j
* S, and p_i include lowercase letters only
Output
Print the minimum number of operations in one line.
Sample Input 1
brainfuck
1
fuck
Sample Output 1
1
For example, if you change "brainfuck" into "brainf*ck", you can satisfy the condition. You have to perform operation at least once, and it is the minimum value.
Sample Input 2
aaa
1
a
Sample Output 2
3
You have to operate for all characters.
Sample Input 3
hellshakeyano
3
hell
shake
key
Sample Output 3
2
In this case, for example, if you change "hellshakeyano" into "h*llsha*eyano", you can satisfy the condition. Notice if you replace one character, it might happen that several strings in the set P, which appear as the consecutive substring of S, simultaneously disappear.
Example
Input
brainfuck
1
fuck
Output
1
|
#include<bits/stdc++.h>
using namespace std;
struct Node {
int nxt[28];
int exist; // 子ども以下に存在する文字列の数の合計
vector< int > accept; // その文字列id
Node() : exist(0) {
memset(nxt, -1, sizeof(nxt));
}
};
struct Trie {
vector< Node > nodes;
int root;
Trie() : root(0) {
nodes.push_back(Node());
}
virtual void direct_action(int node, int id) {}
virtual void child_action(int node, int child, int id) {}
void update_direct(int node, int id) {
nodes[node].accept.push_back(id);
direct_action(node, id);
}
void update_child(int node, int child, int id) {
++nodes[node].exist;
child_action(node, child, id);
}
void add(const string &str, int str_index, int node_index, int id) {
if(str_index == str.size()) {
update_direct(node_index, id);
} else {
const int c = str[str_index] - 'a';
if(nodes[node_index].nxt[c] == -1) {
nodes[node_index].nxt[c] = (int) nodes.size();
nodes.push_back(Node());
}
add(str, str_index + 1, nodes[node_index].nxt[c], id);
update_child(node_index, nodes[node_index].nxt[c], id);
}
}
void add(const string &str, int id) {
add(str, 0, 0, id);
}
void add(const string &str) {
add(str, nodes[0].exist);
}
void query(const string &str, const function< void(int) > &f, int str_index, int node_index) {
for(auto &idx : nodes[node_index].accept) f(idx);
if(str_index == str.size()) {
return;
} else {
const int c = str[str_index] - 'a';
if(nodes[node_index].nxt[c] == -1) return;
query(str, f, str_index + 1, nodes[node_index].nxt[c]);
}
}
void query(const string &str, const function< void(int) > &f) {
query(str, f, 0, 0);
}
int size() const {
return (nodes[0].exist);
}
int nodesize() const {
return ((int) nodes.size());
}
};
struct Aho_Corasick : Trie {
static const int FAIL = 27;
vector< int > correct;
void build(bool heavy = true) {
correct.resize(nodes.size());
for(int i = 0; i < nodes.size(); i++) {
correct[i] = (int) nodes[i].accept.size();
}
queue< int > que;
for(int i = 0; i <= 27; i++) {
if(~nodes[0].nxt[i]) {
nodes[nodes[0].nxt[i]].nxt[FAIL] = 0;
que.emplace(nodes[0].nxt[i]);
} else {
nodes[0].nxt[i] = 0;
}
}
while(!que.empty()) {
Node &now = nodes[que.front()];
correct[que.front()] += correct[now.nxt[FAIL]];
que.pop();
for(int i = 0; i < 27; i++) {
if(now.nxt[i] == -1) continue;
int fail = now.nxt[FAIL];
while(nodes[fail].nxt[i] == -1) fail = nodes[fail].nxt[FAIL];
nodes[now.nxt[i]].nxt[FAIL] = nodes[fail].nxt[i];
if(heavy) {
auto &u = nodes[now.nxt[i]].accept;
auto &v = nodes[nodes[fail].nxt[i]].accept;
vector< int > accept;
set_union(begin(u), end(u), begin(v), end(v), back_inserter(accept));
u = accept;
}
que.emplace(now.nxt[i]);
}
}
}
int match(const string &str, vector< int > &result, int now = 0) {
result.assign(size(), 0);
int count = 0;
for(auto &c : str) {
while(nodes[now].nxt[c - 'a'] == -1) now = nodes[now].nxt[FAIL];
now = nodes[now].nxt[c - 'a'];
count += correct[now];
for(auto &v : nodes[now].accept) ++result[v];
}
return (count);
}
int move(const char &c, int &now) {
int count = 0;
while(nodes[now].nxt[c - 'a'] == -1) now = nodes[now].nxt[FAIL];
now = nodes[now].nxt[c - 'a'];
count += correct[now];
return (count);
}
};
int main() {
string S;
cin >> S;
int K;
cin >> K;
Aho_Corasick aho;
for(int i = 0; i < K; i++) {
string x;
cin >> x;
aho.add(x);
}
aho.build(true);
int cur = 0;
int ret = 0;
for(int i = 0; i < S.size(); i++) {
int buff = cur;
if(aho.move(S[i], buff) > 0) {
S[i] = 'z' + 1;
aho.move(S[i], cur);
++ret;
} else {
aho.move(S[i], cur);
}
}
cout << ret << endl;
}
|
Problem
Today, the high-class restaurant "Maizu Restaurant", which is completely invited, has finally opened. Only members of this restaurant have the right to invite new members, initially only the owner of the restaurant with membership number 0.
Due to its luxury, the Maze Restaurant is only open for $ N $ days from the first day of its opening. During that period, every day one of the members invites only one of his friends as a new member. Members invited on the $ i $ day will be assigned a membership number $ i $, and the members will visit the store every day thereafter, including the day they are invited.
Since there is only a table for two in this restaurant, members eat in pairs as much as possible. Since the owner also participates in the meal, other members can also pair with the owner. However, all members are shy and only want to pair with the friend they invited or the friend they invited. Each member eats lonely if he / she cannot pair with a friend.
For each day of the $ N $ day, find out how many pairs you can make when paired to maximize the number of pairs of friends.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq N \ leq 5000 $
* $ 0 \ leq p_i \ leq i-1 $ ($ 1 \ leq i \ leq N $)
* $ N $, $ p_i $ are integers
Input
The input is given in the following format.
$ N $
$ p_1 $
$ p_2 $
...
$ p_N $
The first line gives $ N $ for the number of days the restaurant will be open.
The following $ N $ line is given the membership number $ p_i $ of the member who invited the member whose membership number is $ i $.
Output
The output consists of $ N $ lines.
The $ i $ line outputs the maximum number of pairs of friends that can be made on the $ i $ day. ($ 1 \ leq i \ leq N $)
Examples
Input
3
0
0
2
Output
1
1
2
Input
5
0
1
2
3
4
Output
1
1
2
2
3
|
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#pragma GCC optimize ("-O3")
using namespace std; void _main(); int main() { cin.tie(0); ios::sync_with_stdio(false); _main(); }
//---------------------------------------------------------------------------------------------------
/*---------------------------------------------------------------------------------------------------
????????????????????????????????? ??§?????§
??????????????? ??§?????§ ???????´<_??? ?????? Welcome to My Coding Space!
???????????? ??? ?´_???`??????/??? ???i
?????????????????????????????? ??? |???|
????????? /?????? /??£??£??£??£/??????|
??? ???_(__??????/??? ???/ .| .|????????????
??? ????????????/????????????/??????u??????
---------------------------------------------------------------------------------------------------*/
int N;
vector<int> E[5010];
int f[5010][5010];
int ma[5010];
//--------------------------------------------------------------------------------------------------
void _main() {
cin >> N;
int ans = 0;
rep(i, 1, N + 1) {
int P; cin >> P;
E[i].push_back(P);
E[P].push_back(i);
queue < tuple<int, int, vector<int>>> que;
que.push(make_tuple( i, -1, vector<int>{i} ));
vector<int> zouka = {i};
while (!que.empty()) {
int cu, pa; vector<int> v;
tie(cu, pa, v) = que.front(); que.pop();
if (0 < v.size() && v.size() % 2 == 0 && !ma[v.front()] && !ma[v.back()]) {
zouka = v;
break;
}
int type = 0;
if (pa < 0) type = 1;
else type = f[cu][pa];
fore(to, E[cu]) if (pa != to && f[cu][to] != type) {
v.push_back(to);
que.push(make_tuple( to, cu, v ));
v.pop_back();
}
}
if (zouka.size() % 2 == 0 && !ma[zouka.front()] && !ma[zouka.back()]) {
ans++;
int n = zouka.size();
rep(i, 0, n - 1) {
int a = zouka[i], b = zouka[i + 1];
//printf("%d -> ", f[a][b]);
f[a][b] = 1 - f[a][b];
f[b][a] = 1 - f[b][a];
} //printf("\n");
ma[zouka.front()] = 1;
ma[zouka.back()] = 1;
}
printf("%d\n", ans);
}
}
|
Write a program of the Bubble Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
BubbleSort(A)
1 for i = 0 to A.length-1
2 for j = A.length-1 downto i+1
3 if A[j] < A[j-1]
4 swap A[j] and A[j-1]
Note that, indices for array elements are based on 0-origin.
Your program should also print the number of swap operations defined in line 4 of the pseudocode.
Constraints
1 ≤ N ≤ 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by spaces characters.
Output
The output consists of 2 lines.
In the first line, please print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character.
In the second line, please print the number of swap operations.
Examples
Input
5
5 3 2 4 1
Output
1 2 3 4 5
8
Input
6
5 2 4 6 1 3
Output
1 2 3 4 5 6
9
|
#include<iostream>
using namespace std;
int main(){
int n,tmp,c=0;
bool flag=true;
cin>>n;
int A[n];
for(int i=0;i<n;i++){
cin>>A[i];
}
while(flag){
flag=false;
for(int j=n-1;j>0;j--){
if(A[j]<A[j-1]){
tmp=A[j];
A[j]=A[j-1];
A[j-1]=tmp;
flag=true;
c++;
}
}
}
for(int i=0;i<n-1;i++){
cout<<A[i]<<" ";
}
cout<<A[n-1]<<endl<<c<<endl;
return 0;
}
|
Write a program which reads a sequence and prints it in the reverse order.
Note
解説
Constraints
* n ≤ 100
* 0 ≤ ai < 1000
Input
The input is given in the following format:
n
a1 a2 . . . an
n is the size of the sequence and ai is the ith element of the sequence.
Output
Print the reversed sequence in a line. Print a single space character between adjacent elements (Note that your program should not put a space character after the last element).
Examples
Input
5
1 2 3 4 5
Output
5 4 3 2 1
Input
8
3 3 4 4 5 8 7 9
Output
9 7 8 5 4 4 3 3
|
#include<iostream>
using namespace std;
int main(void){
int n,a[100];
cin>>n;
for(int i=0;i<n;i++)cin>>a[i];
for(int i=n-1;i>=0;i--){
cout<<a[i];
if(i!=0)cout<<" ";
else cout<<endl;
}
}
|
Tanish loves alphabets. He loves alphabets so much that he ignores all other characters.
Also, whenever he is given an alphabet he gives the next alphabet in alphabetical order in same case.
For example, for a-b,for d-e,for z-a.
Given a string guess what would be Tanish's answer.
Input
The first line of the input contains an integer N denoting the number of strings. N strings follow.
Output
For each string, output a single line containing Tanish's answer.
Constraints
1 ≤ N ≤ 20
1 ≤ |s| ≤ 100 where |s| is the length of the string.
Example
Input:
4
nun123
1234
retA34
^ 56az
Output:
ovo
sfuB
ba
Explanation
Example For the second string, there is no output as there are no alphabets.
|
#V 1.01. Forgot to account for uppercase alphabets earlier -_-
T = (int)(raw_input())
while T:
res = ""
s = raw_input()
for i in range(0, len(s)):
if s[i].isalpha():
if ord(s[i])+1==123:
res = res + 'a'
elif ord(s[i])+1==91:
res = res + 'A'
else:
res=res+(chr(ord(s[i])+1))
print res
T-=1
|
Chef spent N days working really hard! He planned loads of tasks: as many as Ai tasks to do on the ith day! Chef's work was brutal, so he only managed to finish Bi tasks on the ith day.
The good news is that Chef has a Time Machine!
The Time Machine has K white buttons and M black buttons. Each button has a positive integer printed on it. Now Chef goes through all N days consequently and presses buttons. Each day Chef can only press one button (either white or black). After using a button once, it becomes inactive.
Pressing a white button with integer x printed on it reduces the number of planned tasks on the day it was pressed by exactly x. Note that this white button can only be pressed if number of planned tasks on the day are greater than or equal to x.
Pressing a black button with integer x printed on it increases the number of completed tasks on the day it was pressed by exactly x. Note that this black button can only be pressed if after pressing it, number of completed tasks don't exceed the number of tasks.
Chef is interested in finding the minimum possible amount of total uncompleted tasks he will still be left with after N days using the Machine in the best way?
Be careful! Time is sensitive! Chef cannot make a day when he completed more tasks then planned, as this may result in a more-work-than-planned paradox, killing all lazy people on the planet!
Input
The first line of input contains a single integer T, denoting the number of test cases. Description of T test cases follows.
The first line of each test case contains three integers — N, K, M — denoting the number of days, white and black buttons appropriately.
The second line contains N space-separated integers A1, A2, … , AN, denoting the number of planned tasks.
The third line contains N space-separated integers B1, B2, … , BN, denoting the number of completed tasks.
The fourth line contains K space-separated integers C1, C2, … , CK, denoting the integers on white buttons.
The fifth and last line contains M space-separated integers D1, D2, … , DM, denoting the integers on black buttons.
Output
In a single line, output an integer — the minimum possible amount of uncompleted tasks.
Constraints
1 ≤ T ≤ 4
1 ≤ N, K, M ≤ 10^5
1 ≤ Bi ≤ Ai ≤ 10^5
1 ≤ Ci, Di ≤ 10^5
Example
Input:
1
4 2 2
5 7 6 1
3 3 1 1
6 3
1 4
Output:
3
Explanation
Example case 1.
In this example Chef goes through the following steps:
Use black button 1 on the first day.
Use black button 4 on the second day.
Use white button 3 on the third day.
The arrays A and B are now effectively changed to:
5 7 3 1
4 7 1 1
So he will have 3 uncompleted tasks.
|
for t in xrange(int(raw_input())):
n, k, m = map(int,raw_input().split())
a = map(int,raw_input().split())
b = map(int,raw_input().split())
y = sorted(map(int,(raw_input()+" "+raw_input()).split()), reverse = True)
x = []
for i in xrange(n):
x.append(a[i]-b[i])
x = sorted(x, reverse = True)
left = sum(x)
i = 0
j = 0
lx = n
ly = k + m
while (i<lx and j<ly):
if (x[i]>=y[j]):
left -= y[j]
i += 1
j += 1
else:
j += 1
print left
|
Problem
Michal Scofield and Lincon burrow are two brothers. By a murder allegation Lincon Burrow was sentenced to jail. Michal Scofield some how came to know that his brother is not guilty and he don’t have time to file case against the allegations as his brother is going to sit on death chair soon enough. So he made a plan for Prison break before handing himself over to police in a robbery allegation he made tattoos on his whole body a way of encrypting messages. He decided secretly on the number of columns and write the message (letters only) down the columns, padding with extra random letters so as to make a rectangular array of letters. For example, if the message is “There’s no place like home on a snowy night” and there are five columns, Michal would write down
t o i o y
h p k n n
e l e a i
r a h s g
e c o n h
s e m o t
n l e w x
Note that Michal Scofield includes only letters in between the tattoos and writes them all in lower case. In this example, Michael used the character ‘x’ to pad the message out to make a rectangle, although he could have used any letter. Michael then tattooed them by writing the letters in each row, alternating left-to-right and right-to-left. So, the above would be encrypted as
toioynnkpheleaigshareconhtomesnlewx
At the time of the break he forget something about encryption .Your job is to recover for Michal the original message (along with any extra padding letters) from the encrypted one.
Input
The first line have a integer T number of test cases. Input for each test case will consist of two lines. The first line will contain an integer c indicating the number of columns used. The next line is a string of up to 200 lower case letters.
Output
Each input set should generate one line of output, giving the original plaintext message, with no spaces.
Constraints
1<T<20
2<C<20
Sample Input
2
5
toioynnkpheleaigshareconhtomesnlewx
3
ttyohhieneesiaabss
Output:
theresnoplacelikehomeonasnowynightx
thisistheeasyoneab
|
import sys;
def main():
tc=int(raw_input());
for x in range(tc):
noc=int(raw_input());
stinp=str(raw_input());
newst=str();
nor=len(stinp) / noc;
for y in range(nor):
if y%2!=0:
for c in range(noc-1,-1,-1):
ind=y*noc+c;
char=stinp[ind];
newst=newst+char;
else:
for c in range(noc):
newst=newst+stinp[y*noc+c];
#print newst;
#now extract
final=str();
for x in range(noc):
for y in range(nor):
final=final+newst[y*noc+x];
print final;
if __name__=="__main__":main();
|
You need to shuffle a series of numbers from 1 To T, inclusive. The numbers are in ascending order, you have to shuffle them using bubble sort algorithm, that is swap every time a number is greater than another in the given list in the input. A number is greater than another in the list if the number appears later than the other in the list, check example for more clarity.
Print the count of swaps done while you run the algorithm to shuffle them.
Following is the bubble sort algorithm
procedure bubbleSort( A : list of items )
n = length(A)-1
for j=0 to n inclusive do
for i = 0 to n-1 inclusive do
/* if this pair is out of order */
if A[i] > A[i+1] then
/* swap them and remember something changed */
swap( A[i], A[i+1] )
end if
end for
end for
end procedure
Input
Input description.
Input will start will an integer N on newline representing the count of test case. Each case will contain a number T on a newline, representing total count of numbers. Next line of each test case will contain T integers representing the final shuffled series of numbers.
Output
For each test case print the desired output, each on a newline.
Constraints
1 ≤ N ≤ 10
1 ≤ N ≤ 20
Example
Input:
1
3
2 1 3
abac
Output:
1
Explanation
Example case 1. One swap between 1 and 2, because 1 appears later than 2, so 1 is greater than 2.
|
for _ in range(input()):
n=input()
a=map(int,raw_input().split())
c=0
for i in range(n):
for j in range(n-i-1):
if a[j]>a[j+1]:
a[j],a[j+1]=a[j+1],a[j]
#print a[j],a[j+1]
c+=1
#print c
print c
|
Little Egor likes to play with positive integers and their divisors. Bigger the number to play with, more the fun! The boy asked you to come up with an algorithm, that could play the following game:
Let's define f(n) as the sum of all odd divisors of n. I.e. f(10) = 1 + 5 = 6 and f(21) = 1 + 3 + 7 + 21 = 32. The game is to calculate f(l) + f(l + 1) + ... + f(r - 1) + f(r) for the given integers l and r.
Have fun! But be careful, the integers might be quite big.
Input
The first line of the input contains one integer T denoting the number of test cases.
The only line of the test case description contains two positive integers l and r.
Output
For each test case, output the required sum on a separate line.
Constraints
1 ≤ T ≤ 10
1 ≤ l ≤ r ≤ 10^5
Example
Input:
2
1 10
42 42
Output:
45
32
Explanation
In the first example case, f(1) + f(2) + ... + f(10) = 1 + 1 + 4 + 1 + 6 + 4 + 8 + 1 + 13 + 6 = 45
In the second example case, f(42) = 32.
|
cases = int(raw_input())
while(cases):
l,r = map(int,raw_input().split())
ans = 0
j = 1
while(j <= r):
#print j
ans += ((r/j)-((l)/j))*j
if(l%j==0):
ans+=j
j+=2
print ans
cases-=1
|
Professor Snape has lots of potions. Bottles containing all types of potions are stacked on shelves which cover the entire wall from floor to ceiling. Professor Snape has broken his bones several times while climbing the top shelf for retrieving a potion. He decided to get a ladder for him. But he has no time to visit Diagon Alley. So he instructed Ron Weasley to make a ladder for him. Professor Snape specifically wants a step ladder which looks like an inverted 'V' from side view.
Professor just mentioned two things before vanishing-
B - separation between left side (LS) and right side (RS) on the ground
LS - the length of left side
What should be the length of RS? At one extreme LS can be vertical and at other RS can be vertical. Ron is angry and confused. Since Harry is busy battling Voldemort, its your duty to help him find the minimum and maximum length of RS.
Input
First line contains single integer T, the number of test cases. Then T lines follow each containing 2 integers - B and LS.
Output
Output T lines, each containing minimum value of RS and maximum value of RS, separated by space. The answer (RS) will be considered correct if it has relative and absolute error less than 10^-2.
Constraints
1 ≤ T ≤ 10001 ≤ B < LS ≤ 1000
Example
Input:
3
4 5
10 12
10 20
Output:
3.0 6.40312
6.63325 15.6205
17.3205 22.3607
|
for i in range(int(raw_input())):
a=map(int,raw_input().split())
print '%g' %(a[1]*a[1]-a[0]*a[0])**0.5,
print '%g' %(a[1]*a[1]+a[0]*a[0])**0.5
|
You are given two strings s and t. In a single move, you can choose any of two strings and delete the first (that is, the leftmost) character. After a move, the length of the string decreases by 1. You can't choose a string if it is empty.
For example:
* by applying a move to the string "where", the result is the string "here",
* by applying a move to the string "a", the result is an empty string "".
You are required to make two given strings equal using the fewest number of moves. It is possible that, in the end, both strings will be equal to the empty string, and so, are equal to each other. In this case, the answer is obviously the sum of the lengths of the initial strings.
Write a program that finds the minimum number of moves to make two given strings s and t equal.
Input
The first line of the input contains s. In the second line of the input contains t. Both strings consist only of lowercase Latin letters. The number of letters in each string is between 1 and 2⋅10^5, inclusive.
Output
Output the fewest number of moves required. It is possible that, in the end, both strings will be equal to the empty string, and so, are equal to each other. In this case, the answer is obviously the sum of the lengths of the given strings.
Examples
Input
test
west
Output
2
Input
codeforces
yes
Output
9
Input
test
yes
Output
7
Input
b
ab
Output
1
Note
In the first example, you should apply the move once to the first string and apply the move once to the second string. As a result, both strings will be equal to "est".
In the second example, the move should be applied to the string "codeforces" 8 times. As a result, the string becomes "codeforces" → "es". The move should be applied to the string "yes" once. The result is the same string "yes" → "es".
In the third example, you can make the strings equal only by completely deleting them. That is, in the end, both strings will be empty.
In the fourth example, the first character of the second string should be deleted.
|
a = str(input())
b = str(input())
a = a[::-1]
b = b[::-1]
na = len(a)
nb = len(b)
d = abs(na-nb)
l = min(na,nb)
k = 0
for i in range(0,l):
if a[i] != b[i]:
k = (l - i)*2
break
print(d+k)
|
We call an array b_1, b_2, …, b_m good, if there exist two indices i < j such that b_i ⋅ b_j is a [perfect square](https://en.wikipedia.org/wiki/Square_number).
Given an array b_1, b_2, …, b_m, in one action you can perform one of the following:
* multiply any element b_i by any prime p;
* divide any element b_i by prime p, if b_i is divisible by p.
Let f(b_1, b_2, …, b_m) be the minimum number of actions needed to make the array b good.
You are given an array of n integers a_1, a_2, …, a_n and q queries of the form l_i, r_i. For each query output f(a_{l_i}, a_{l_i + 1}, …, a_{r_i}).
Input
The first line contains two integers n and q (2 ≤ n ≤ 194 598, 1 ≤ q ≤ 1 049 658) — the length of the array and the number of queries.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 5 032 107) — the elements of the array.
Each of the next q lines contains two integers l_i and r_i (1 ≤ l_i < r_i ≤ n) — the parameters of a query.
Output
Output q lines — the answers for each query in the order they are given in the input.
Example
Input
10 10
34 37 28 16 44 36 43 50 22 13
1 3
4 8
6 10
9 10
3 10
8 9
5 6
1 4
1 7
2 6
Output
2
0
1
3
0
1
1
1
0
0
Note
In the first query of the first sample you can multiply second number by 7 to get 259 and multiply the third one by 37 to get 1036. Then a_2 ⋅ a_3 = 268 324 = 518^2.
In the second query subarray is already good because a_4 ⋅ a_6 = 24^2.
In the third query you can divide 50 by 2 to get 25. Then a_6 ⋅ a_8 = 30^2.
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 200000;
const int MAX_K = 6000000;
const int MAX_Q = 1100000;
const int MAX_T = 10;
const int INF = 1e8;
int N, Q;
int arr[MAX_N + 1];
vector<pair<int, int> > gp[MAX_N + 1];
vector<int> vt[MAX_N + 1];
int idx[MAX_T + 1][MAX_K + 1];
int use, now = 1;
void make_edge(int x, int y, int z) {
gp[x].push_back({y, z});
gp[y].push_back({x, z});
}
void dfs(int x, int y) {
if (y == vt[x].size()) {
for (int j = 0; j < MAX_T; j++) {
if (idx[j][now] != 0) {
make_edge(idx[j][now], x, j + vt[x].size() - use);
}
}
return;
} else {
dfs(x, y + 1);
use++;
now *= vt[x][y];
dfs(x, y + 1);
now /= vt[x][y];
use--;
}
}
void dfs2(int x, int y) {
if (y == vt[x].size()) {
idx[vt[x].size() - use][now] = x;
return;
} else {
dfs2(x, y + 1);
use++;
now *= vt[x][y];
dfs2(x, y + 1);
now /= vt[x][y];
use--;
}
}
struct Query {
int x, y, z;
bool operator<(const Query &a) const { return x < a.x; }
};
vector<Query> query;
struct SEG {
struct NODE {
int l, r;
int mn;
};
int SZ;
vector<NODE> seg;
void add() { seg.push_back({-1, -1, INF}); }
void Init(int x) {
SZ = x;
add();
init(0, 1, SZ);
}
void init(int idx, int s, int e) {
if (s == e) return;
seg[idx].l = seg.size();
add();
seg[idx].r = seg.size();
add();
init(seg[idx].l, s, (s + e) / 2);
init(seg[idx].r, (s + e) / 2 + 1, e);
}
void Update(int x, int y) { update(0, 1, SZ, x, y); }
void update(int idx, int s, int e, int x, int y) {
seg[idx].mn = min(seg[idx].mn, y);
if (s == e) return;
if (x <= (s + e) / 2)
update(seg[idx].l, s, (s + e) / 2, x, y);
else
update(seg[idx].r, (s + e) / 2 + 1, e, x, y);
}
int Mn(int x, int y) { return mn(0, 1, SZ, x, y); }
int mn(int idx, int s, int e, int x, int y) {
if (x <= s && e <= y) {
return seg[idx].mn;
}
if (x > e || y < s) return INF;
return min(mn(seg[idx].l, s, (s + e) / 2, x, y),
mn(seg[idx].r, (s + e) / 2 + 1, e, x, y));
}
} Seg;
int ans[MAX_Q + 1];
void Add(int x) {
for (pair<int, int> i : gp[x]) {
if (i.first > x) {
Seg.Update(i.first, i.second);
}
}
}
int main() {
scanf("%d%d", &N, &Q);
Seg.Init(N);
for (int i = 1; i <= N; i++) {
scanf("%d", &arr[i]);
for (int j = 2; j * j <= arr[i]; j++) {
while (arr[i] % (j * j) == 0) {
arr[i] /= j * j;
}
if (arr[i] % j == 0) {
vt[i].push_back(j);
arr[i] /= j;
}
}
if (arr[i] != 1) {
vt[i].push_back(arr[i]);
arr[i] = 1;
}
use = 0;
now = 1;
dfs(i, 0);
use = 0;
now = 1;
dfs2(i, 0);
}
for (int i = 1; i <= Q; i++) {
int l, r;
scanf("%d%d", &l, &r);
query.push_back({l, r, i});
}
sort(query.begin(), query.end());
int n = N;
while (!query.empty()) {
Query q = query.back();
query.pop_back();
while (n >= q.x) {
Add(n);
n--;
}
ans[q.z] = Seg.Mn(q.x, q.y);
}
for (int i = 1; i <= Q; i++) {
printf("%d\n", ans[i]);
}
}
|
Little C loves number «3» very much. He loves all things about it.
Now he is playing a game on a chessboard of size n × m. The cell in the x-th row and in the y-th column is called (x,y). Initially, The chessboard is empty. Each time, he places two chessmen on two different empty cells, the Manhattan distance between which is exactly 3. The Manhattan distance between two cells (x_i,y_i) and (x_j,y_j) is defined as |x_i-x_j|+|y_i-y_j|.
He want to place as many chessmen as possible on the chessboard. Please help him find the maximum number of chessmen he can place.
Input
A single line contains two integers n and m (1 ≤ n,m ≤ 10^9) — the number of rows and the number of columns of the chessboard.
Output
Print one integer — the maximum number of chessmen Little C can place.
Examples
Input
2 2
Output
0
Input
3 3
Output
8
Note
In the first example, the Manhattan distance between any two cells is smaller than 3, so the answer is 0.
In the second example, a possible solution is (1,1)(3,2), (1,2)(3,3), (2,1)(1,3), (3,1)(2,3).
|
#include <bits/stdc++.h>
using namespace std;
long long N, M;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M;
if (N > M) swap(N, M);
long long Ans = 0;
if (N == 1) {
Ans = (M / 6) * 6 + ((M % 6 == 4) ? 2 : (M % 6 == 5) ? 4 : 0);
} else if (N == 2) {
Ans = (M == 2) ? 0 : (M == 3) ? 4 : (M == 7) ? 12 : M * 2;
} else {
long long Ans2, Ans3;
Ans2 = N / 2 * ((M == 2) ? 0 : (M == 3) ? 4 : (M == 7) ? 12 : M * 2);
if (N % 2 == 1)
Ans2 += (M / 6) * 6 + ((M % 6 == 4) ? 2 : (M % 6 == 5) ? 4 : 0);
Ans3 = N / 3 * 3 * M;
if (M % 2 != 0) Ans3--;
if (N % 3 == 1)
Ans3 += (M / 6) * 6 + ((M % 6 == 4) ? 2 : (M % 6 == 5) ? 4 : 0);
if (N % 3 == 2)
Ans3 += ((M == 2) ? 0 : (M == 3) ? 4 : (M == 7) ? 12 : M * 2);
Ans = max(Ans2, Ans3);
}
cout << Ans << '\n';
return 0;
}
|
Once upon a time Algoland and Berland were a single country, but those times are long gone. Now they are two different countries, but their cities are scattered on a common territory.
All cities are represented as points on the Cartesian plane. Algoland consists of a cities numbered from 1 to a. The coordinates of the i-th Algoland city are a pair of integer numbers (xa_i, ya_i). Similarly, Berland consists of b cities numbered from 1 to b. The coordinates of the j-th Berland city are a pair of integer numbers (xb_j, yb_j). No three of the a+b mentioned cities lie on a single straight line.
As the first step to unite the countries, Berland decided to build several bidirectional freeways. Each freeway is going to be a line segment that starts in a Berland city and ends in an Algoland city. Freeways can't intersect with each other at any point except freeway's start or end. Moreover, the freeways have to connect all a+b cities. Here, connectivity means that one can get from any of the specified a+b cities to any other of the a+b cities using freeways. Note that all freeways are bidirectional, which means that one can drive on each of them in both directions.
Mayor of each of the b Berland cities allocated a budget to build the freeways that start from this city. Thus, you are given the numbers r_1, r_2, ..., r_b, where r_j is the number of freeways that are going to start in the j-th Berland city. The total allocated budget is very tight and only covers building the minimal necessary set of freeways. In other words, r_1+r_2+...+r_b=a+b-1.
Help Berland to build the freeways so that:
* each freeway is a line segment connecting a Berland city and an Algoland city,
* no freeways intersect with each other except for the freeway's start or end,
* freeways connect all a+b cities (all freeways are bidirectional),
* there are r_j freeways that start from the j-th Berland city.
Input
Input contains one or several test cases. The first input line contains a single integer number t (1 ≤ t ≤ 3000) — number of test cases. Then, t test cases follow. Solve test cases separately, test cases are completely independent and do not affect each other.
Each test case starts with a line containing space-separated integers a and b (1 ≤ a, b ≤ 3000) — numbers of Algoland cities and number of Berland cities correspondingly.
The next line contains b space-separated integers r_1, r_2, ..., r_b (1 ≤ r_b ≤ a) where r_j is the number of freeways, that should start in the j-th Berland city. It is guaranteed that r_1+r_2+...+r_b=a+b-1.
The next a lines contain coordinates of the Algoland cities — pairs of space-separated integers xa_i, ya_i (-10000 ≤ xa_i, ya_i ≤ 10000). The next b lines contain coordinates of the Berland cities — pairs of space-separated integers xb_i, yb_i (-10000 ≤ xb_i, yb_i ≤ 10000). All cities are located at distinct points, no three of the a+b cities lie on a single straight line.
Sum of values a across all test cases doesn't exceed 3000. Sum of values b across all test cases doesn't exceed 3000.
Output
For each of the t test cases, first print "YES" if there is an answer or "NO" otherwise.
If there is an answer, print the freeway building plan in the next a+b-1 lines. Each line of the plan should contain two space-separated integers j and i which means that a freeway from the j-th Berland city to the i-th Algoland city should be built. If there are multiple solutions, print any.
Example
Input
2
2 3
1 1 2
0 0
1 1
1 2
3 2
4 0
1 1
1
0 0
0 1
Output
YES
2 2
1 2
3 2
3 1
YES
1 1
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int n = 0, f = 1;
char c;
for (c = getchar(); c != '-' && (c < '0' || c > '9'); c = getchar())
;
if (c == '-') c = getchar(), f = -1;
for (; c >= '0' && c <= '9'; c = getchar()) n = n * 10 + c - 48;
return n * f;
}
struct ar {
int x, y, id, d;
} now;
bool operator<(ar a, ar b) { return a.x == b.x ? a.y < b.y : a.x < b.x; }
int i, a, b, d[3005];
vector<ar> p, an;
bool cmp(ar a, ar b) { return a.x * b.y > a.y * b.x; }
void solve(vector<ar> p) {
int i, j, k, D, n = p.size() - 1;
if (!n) return;
for (i = 1; i <= n; i++)
if (p[i] < p[0]) swap(p[i], p[0]);
for (i = 1; i <= n; i++) p[i].x -= p[0].x, p[i].y -= p[0].y;
sort(p.begin() + 1, p.end(), cmp);
for (i = 1; i <= n; i++) p[i].x += p[0].x, p[i].y += p[0].y;
if (p[0].d < 0) {
for (i = 1; i <= n; i++) {
j = i, D = 0;
for (;; i++) {
D += p[i].d;
if (D >= 0) break;
}
p[i].d--, an.push_back((ar){p[i].id, p[0].id});
p[i].d -= D;
solve(vector<ar>(p.begin() + j, p.begin() + i + 1));
p[j = i].d = D - 1;
for (; D;) D += p[++i].d;
solve(vector<ar>(p.begin() + j, p.begin() + i + 1));
}
return;
}
for (i = 1; p[0].d >= 0;) {
for (j = i, D = 1; D; i++) D += p[i].d;
p[0].d--, an.push_back((ar){p[0].id, p[i - 1].id});
solve(vector<ar>(p.begin() + j, p.begin() + i));
}
solve(vector<ar>(p.begin() + i - 1, p.end()));
}
void work() {
a = read(), b = read();
for (i = 1; i <= b; i++) d[i] = read();
p.clear(), an.clear();
for (i = 1; i <= a + b; i++) {
now.x = read(), now.y = read();
if (i <= a)
now.id = i, now.d = -1;
else
now.d = d[now.id = i - a] - 1;
p.push_back(now);
}
solve(p);
puts("YES");
for (i = 0; i <= a + b - 2; i++) printf("%d %d\n", an[i].x, an[i].y);
}
int main() {
for (int t = read(); t--;) work();
}
|
You are given a string s consisting only of lowercase Latin letters.
You can rearrange all letters of this string as you wish. Your task is to obtain a good string by rearranging the letters of the given string or report that it is impossible to do it.
Let's call a string good if it is not a palindrome. Palindrome is a string which is read from left to right the same as from right to left. For example, strings "abacaba", "aa" and "z" are palindromes and strings "bba", "xd" are not.
You have to answer t independent queries.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — number of queries.
Each of the next t lines contains one string. The i-th line contains a string s_i consisting only of lowercase Latin letter. It is guaranteed that the length of s_i is from 1 to 1000 (inclusive).
Output
Print t lines. In the i-th line print the answer to the i-th query: -1 if it is impossible to obtain a good string by rearranging the letters of s_i and any good string which can be obtained from the given one (by rearranging the letters) otherwise.
Example
Input
3
aa
abacaba
xdd
Output
-1
abaacba
xdd
Note
In the first query we cannot rearrange letters to obtain a good string.
Other examples (not all) of correct answers to the second query: "ababaca", "abcabaa", "baacaba".
In the third query we can do nothing to obtain a good string.
|
def good_string(string):
if string[::-1] != string:
return string
else:
string = string[-1] + string[:-1]
try:
return good_string(string)
except:
return -1
if __name__ == "__main__":
queries = int(input())
for _ in range(queries):
string = input()
print(good_string(string))
|
One day Sasha visited the farmer 2D and his famous magnetic farm. On this farm, the crop grows due to the influence of a special magnetic field. Maintaining of the magnetic field is provided by n machines, and the power of the i-th machine is a_i.
This year 2D decided to cultivate a new culture, but what exactly he didn't say. For the successful growth of the new culture, it is necessary to slightly change the powers of the machines. 2D can at most once choose an arbitrary integer x, then choose one machine and reduce the power of its machine by x times, and at the same time increase the power of one another machine by x times (powers of all the machines must stay positive integers). Note that he may not do that if he wants. More formally, 2D can choose two such indices i and j, and one integer x such that x is a divisor of a_i, and change powers as following: a_i = (a_i)/(x), a_j = a_j ⋅ x
Sasha is very curious, that's why he wants to calculate the minimum total power the farmer can reach. There are too many machines, and Sasha can't cope with computations, help him!
Input
The first line contains one integer n (2 ≤ n ≤ 5 ⋅ 10^4) — the number of machines.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 100) — the powers of the machines.
Output
Print one integer — minimum total power.
Examples
Input
5
1 2 3 4 5
Output
14
Input
4
4 2 4 4
Output
14
Input
5
2 4 2 3 7
Output
18
Note
In the first example, the farmer can reduce the power of the 4-th machine by 2 times, and increase the power of the 1-st machine by 2 times, then the powers will be: [2, 2, 3, 2, 5].
In the second example, the farmer can reduce the power of the 3-rd machine by 2 times, and increase the power of the 2-nd machine by 2 times. At the same time, the farmer can leave is be as it is and the total power won't change.
In the third example, it is optimal to leave it be as it is.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n;
cin >> n;
long int a[n];
long int sum = 0;
for (long int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
sort(a, a + n);
long int maxres = 0;
unordered_map<int, int> mp;
for (long int i = 1; i < n; i++) {
int f = 2, fs = INT_MAX, minfs = INT_MAX;
if (mp[a[i]] == 0) {
while (f * f <= a[i]) {
if (a[i] % f == 0) {
int f1 = a[i] / f;
long a1 = f1 + a[0] * f;
long b = a[0] * f1 + f;
fs = min(a1, b);
}
minfs = min(minfs, fs);
f++;
}
if (a[i] + a[0] - minfs > 0) {
maxres = max(maxres, a[i] + a[0] - minfs);
}
mp[a[i]] = 1;
}
}
cout << sum - maxres;
return 0;
}
|
A superhero fights with a monster. The battle consists of rounds, each of which lasts exactly n minutes. After a round ends, the next round starts immediately. This is repeated over and over again.
Each round has the same scenario. It is described by a sequence of n numbers: d_1, d_2, ..., d_n (-10^6 ≤ d_i ≤ 10^6). The i-th element means that monster's hp (hit points) changes by the value d_i during the i-th minute of each round. Formally, if before the i-th minute of a round the monster's hp is h, then after the i-th minute it changes to h := h + d_i.
The monster's initial hp is H. It means that before the battle the monster has H hit points. Print the first minute after which the monster dies. The monster dies if its hp is less than or equal to 0. Print -1 if the battle continues infinitely.
Input
The first line contains two integers H and n (1 ≤ H ≤ 10^{12}, 1 ≤ n ≤ 2⋅10^5). The second line contains the sequence of integers d_1, d_2, ..., d_n (-10^6 ≤ d_i ≤ 10^6), where d_i is the value to change monster's hp in the i-th minute of a round.
Output
Print -1 if the superhero can't kill the monster and the battle will last infinitely. Otherwise, print the positive integer k such that k is the first minute after which the monster is dead.
Examples
Input
1000 6
-100 -200 -300 125 77 -4
Output
9
Input
1000000000000 5
-1 0 0 0 0
Output
4999999999996
Input
10 4
-3 -6 5 4
Output
-1
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll oo = 0x3f3f3f3f3f3f3f3fLL;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll H, n;
cin >> H >> n;
vector<ll> d(n);
for (auto &a : d) cin >> a;
vector<ll> p(n + 1);
for (ll i = 1; i <= n; i++) p[i] = d[i - 1] + p[i - 1];
ll fr = H;
for (ll i = 0; i < n; i++) {
fr += d[i];
if (fr <= 0) return cout << i + 1 << endl, 0;
}
if (p[n] >= 0) return cout << -1 << endl, 0;
ll res = oo;
cerr << p[n] << endl;
for (ll i = 1; i <= n; i++) {
ll q = -p[i];
ll k = (q - H + p[n] + 1) / p[n];
res = min(n * k + i, res);
}
cout << res << endl;
}
|
Let's define an unambiguous arithmetic expression (UAE) as follows.
* All non-negative integers are UAE's. Integers may have leading zeroes (for example, 0000 and 0010 are considered valid integers).
* If X and Y are two UAE's, then "(X) + (Y)", "(X) - (Y)", "(X) * (Y)", and "(X) / (Y)" (all without the double quotes) are UAE's.
* If X is an UAE, then " - (X)" and " + (X)" (both without the double quotes) are UAE's.
You are given a string consisting only of digits ("0" - "9") and characters "-", "+", "*", and "/". Your task is to compute the number of different possible unambiguous arithmetic expressions such that if all brackets (characters "(" and ")") of that unambiguous arithmetic expression are removed, it becomes the input string. Since the answer may be very large, print it modulo 1000003 (106 + 3).
Input
The first line is a non-empty string consisting of digits ('0'-'9') and characters '-', '+', '*', and/or '/'. Its length will not exceed 2000. The line doesn't contain any spaces.
Output
Print a single integer representing the number of different unambiguous arithmetic expressions modulo 1000003 (106 + 3) such that if all its brackets are removed, it becomes equal to the input string (character-by-character).
Examples
Input
1+2*3
Output
2
Input
03+-30+40
Output
3
Input
5//4
Output
0
Input
5/0
Output
1
Input
1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
Output
100728
Note
For the first example, the two possible unambiguous arithmetic expressions are:
((1) + (2)) * (3)
(1) + ((2) * (3))
For the second example, the three possible unambiguous arithmetic expressions are:
(03) + (( - (30)) + (40))
(03) + ( - ((30) + (40)))
((03) + ( - (30))) + (40)
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
const int MAXN = 2048;
const int MOD = 1e6 + 3;
char s[MAXN], S[MAXN], *ch = s;
int dp[MAXN][MAXN], n = -1;
int sign_l[MAXN], num_p[MAXN], sign_p[MAXN];
inline char getnext() {
if (*ch == 0) return 0;
if (*ch == '+' || *ch == '-') {
++ch;
return '+';
} else if (*ch == '*' || *ch == '/') {
++ch;
return '*';
} else {
while ('0' <= *ch && *ch <= '9') ++ch;
return '0';
}
}
inline bool check() {
if (S[0] == '*' || S[0] == '/' || S[n - 1] != '0') {
return false;
}
for (register int i = (0); i < (n); ++i) {
if (S[i] != '0' && S[i + 1] == '*') {
return false;
}
}
return true;
}
inline int Mod(long long x) { return x - x / MOD * MOD; }
inline int dfs(int l, int r) {
if (r < 0) return 0;
if (~dp[l][r]) return dp[l][r];
if (l == n) return dp[l][r] = (r == 0);
if (S[l] != '0')
return dp[l][r] = dfs(l + 1, r + 1);
else
return dp[l][r] = Mod(dfs(l + 1, r) + dfs(l, r - 1));
}
int main() {
gets(s);
while ((S[++n] = getnext()))
;
if (!check()) {
puts("0");
return 0;
}
memset(dp, -1, sizeof(dp));
cout << dfs(0, 0) << '\n';
return 0;
}
|
You have given tree consist of n vertices. Select a vertex as root vertex that satisfies the condition below.
* For all vertices v_{1} and v_{2}, if distance(root, v_{1}) = distance(root, v_{2}) then degree(v_{1}) = degree(v_{2}), where degree means the number of vertices connected to that vertex, and distance means the number of edges between two vertices.
Determine and find if there is such root vertex in the tree. If there are multiple answers, find any of them.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^{5}) — the number of vertices.
Each of the next n-1 lines contains two integers v_{i} and u_{i} (1 ≤ v_{i} < u_{i} ≤ n) — it means there is an edge exist between v_{i} and u_{i}. It is guaranteed that the graph forms tree.
Output
If there is such root vertex exists, print any of them. Otherwise, print -1.
Examples
Input
7
1 2
2 3
3 4
4 5
3 6
6 7
Output
3
Input
6
1 3
2 3
3 4
4 5
4 6
Output
-1
Note
This is the picture for the first example. 1, 5, 7 also can be a valid answer.
<image>
This is the picture for the second example. You can see that it's impossible to find such root vertex.
<image>
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
vector<int> g[N], v[N];
int d[N], dd[N], dep[N], f[N], o[N], n;
void dfs(int x, int p) {
dep[x] = dep[p] + 1;
for (int i = 0; i < g[x].size(); i++)
if (g[x][i] != p) dfs(g[x][i], x);
}
bool judge(int x) {
for (int i = 0; i <= n; i++) dep[i] = o[i] = 0;
dfs(x, x);
for (int i = 1; i <= n; i++)
if (!o[dep[i]])
o[dep[i]] = dd[i];
else if (o[dep[i]] != dd[i])
return false;
return true;
}
int main() {
scanf("%d", &n);
if (n == 1) {
printf("1\n");
return 0;
}
for (int i = 1, x, y; i < n; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
d[x]++;
d[y]++;
}
for (int i = 1; i <= n; i++) dd[i] = d[i];
int root = 0;
for (int i = 1; i <= n; i++)
if (d[i] == 1) v[0].push_back(i), f[i] = i;
if (v[0].size() <= 2) {
printf("%d\n", v[0][0]);
return 0;
}
int k = 0, flag = 1, lst = 0;
while (flag && v[k].size()) {
int u = v[k][0];
for (auto x : v[k])
if (dd[x] != dd[u]) {
int root1 = f[x];
int root2 = f[u];
if (judge(root1))
printf("%d\n", root1);
else if (judge(root2))
printf("%d\n", root2);
else
printf("-1\n");
return 0;
}
for (auto x : v[k]) {
for (auto y : g[x])
if (d[y] > 1) {
if (!f[y]) f[y] = f[x];
d[y]--;
if (d[y] == 1) {
lst = y;
v[k + 1].push_back(y);
}
}
}
k++;
}
if (lst && judge(lst))
printf("%d\n", lst);
else if (f[lst] && judge(f[lst]))
printf("%d\n", f[lst]);
else
printf("-1\n");
return 0;
}
|
Given a simple graph, output the number of simple cycles in it. A simple cycle is a cycle with no repeated vertices or edges.
Input
The first line of input contains two integers n and m (1 ≤ n ≤ 19, 0 ≤ m) – respectively the number of vertices and edges of the graph. Each of the subsequent m lines contains two integers a and b, (1 ≤ a, b ≤ n, a ≠ b) indicating that vertices a and b are connected by an undirected edge. There is no more than one edge connecting any pair of vertices.
Output
Output the number of cycles in the given graph.
Examples
Input
4 6
1 2
1 3
1 4
2 3
2 4
3 4
Output
7
Note
The example graph is a clique and contains four cycles of length 3 and three cycles of length 4.
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, a, b, g[19][19], dp[1 << 19][19], ans;
int main() {
scanf("%lld%lld", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%lld%lld", &a, &b);
g[--a][--b] = g[b][a] = 1;
dp[(1 << a) | (1 << b)][max(a, b)] = 1;
}
for (int i = 1; i < 1 << n; i++) {
int k = 0;
while (!(i & (1 << k))) k++;
for (int j = k + 1; j < n; j++)
if (dp[i][j]) {
if (g[j][k]) ans += dp[i][j];
for (int p = k + 1; p < n; p++)
if (g[p][j] && !(i & (1 << p))) dp[i | (1 << p)][p] += dp[i][j];
}
}
printf("%lld\n", (ans - m) / 2);
}
|
You are in charge of the BubbleReactor. It consists of N BubbleCores connected with N lines of electrical wiring. Each electrical wiring connects two distinct BubbleCores. There are no BubbleCores connected with more than one line of electrical wiring.
Your task is to start the BubbleReactor by starting each BubbleCore. In order for a BubbleCore to be started it needs to be receiving power from a directly connected BubbleCore which is already started. However, you can kick-start one BubbleCore manually without needing power. It is guaranteed that all BubbleCores can be started.
Before the BubbleCore boot up procedure its potential is calculated as the number of BubbleCores it can power on (the number of inactive BubbleCores which are connected to it directly or with any number of inactive BubbleCores in between, itself included)
Start the BubbleReactor so that the sum of all BubbleCores' potentials is maximum.
Input
First line contains one integer N (3 ≤ N ≤ 15.000), the number of BubbleCores.
The following N lines contain two integers U, V (0 ≤ U ≠ V < N) denoting that there exists electrical wiring between BubbleCores U and V.
Output
Single integer, the maximum sum of all BubbleCores' potentials.
Example
Input
10
0 1
0 3
0 4
0 9
1 2
2 3
2 7
4 5
4 6
7 8
Output
51
Note
If we start by kickstarting BubbleCup 8 and then turning on cores 7, 2, 1, 3, 0, 9, 4, 5, 6 in that order we get potentials 10 + 9 + 8 + 7 + 6 + 5 + 1 + 3 + 1 + 1 = 51
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-9;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 62;
const int mods = 998244353;
const int MAXN = 400005;
const int INF = 0x3f3f3f3f;
namespace FastIO {
constexpr int SIZE = (1 << 21) + 1;
int num = 0, f;
char ibuf[SIZE], obuf[SIZE], que[65], *iS, *iT, *oS = obuf,
*oT = obuf + SIZE - 1, c;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char c) {
*oS++ = c;
if (oS == oT) flush();
}
template <class I>
inline void read(I &x) {
for (f = 1, c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (x = 0; c >= '0' && c <= '9';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
x = (x << 3) + (x << 1) + (c & 15);
x *= f;
}
template <class I>
inline void print(I x) {
if (x < 0) putc('-'), x = -x;
if (!x) putc('0');
while (x) que[++num] = x % 10 + 48, x /= 10;
while (num) putc(que[num--]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_Flusher_;
} // namespace FastIO
using FastIO ::print;
using FastIO ::putc;
using FastIO ::read;
vector<int> cir, e[MAXN];
int vis[MAXN], fa[MAXN], rt[MAXN], sz[MAXN], flag[MAXN], g[MAXN], f[MAXN],
tmp[MAXN], s[MAXN], h[MAXN][2], c[MAXN], sum, mx, n;
int upd(int x, int y) { return x + y >= mods ? x + y - mods : x + y; }
void dfs(int x, int father) {
vis[x] = 1, fa[x] = father;
for (auto v : e[x]) {
if (v == father) continue;
if (vis[v]) {
if (cir.size()) continue;
int nw = x;
while (nw != fa[v]) cir.push_back(nw), flag[nw] = 1, nw = fa[nw];
} else
dfs(v, x);
}
}
void tree_dp(int x, int father) {
rt[x] = rt[father], sz[x] = 1;
for (auto v : e[x]) {
if (v == father) continue;
tree_dp(v, x);
sz[x] += sz[v];
g[x] += g[v];
}
g[x] += sz[x];
}
void Tree_dp(int x, int father, int all) {
upmax(mx, all);
for (auto v : e[x]) {
if (v == father) continue;
Tree_dp(v, x, all + n - sz[v] - sz[v]);
}
}
signed main() {
read(n);
for (int i = 1, u, v; i <= n; ++i)
read(u), read(v), ++u, ++v, e[u].push_back(v), e[v].push_back(u);
dfs(1, 0);
for (auto u : cir) {
rt[u] = u, sz[u] = 1, sum = 0;
for (auto v : e[u])
if (!flag[v]) tree_dp(v, u), sz[u] += sz[v], sum += g[v];
mx = 0;
for (auto v : e[u])
if (!flag[v]) Tree_dp(v, u, n - sz[v] - sz[v]);
h[u][0] = sum, h[u][1] = mx;
}
int len = (int)cir.size();
for (int i = 1; i <= len; ++i) f[i] = n + h[cir[i - 1]][0] + h[cir[i - 1]][1];
for (int i = 1; i <= len + len; ++i)
s[i] = s[i - 1] + sz[cir[(i - 1) % len]], c[i] = h[cir[(i - 1) % len]][0];
for (int i = 1; i < len; ++i) {
for (int j = 1; j <= len; ++j) tmp[j] = f[j], f[j] = 0;
for (int j = 1; j <= len; ++j)
upmax(f[j], tmp[j] + n - (s[j + i - 1] - s[j - 1]) + c[j + i]),
upmax(
f[j == 1 ? len : j - 1],
tmp[j] + n - (s[j + i - 1] - s[j - 1]) + c[j == 1 ? len : j - 1]);
}
int ans = 0;
for (int i = 1; i <= len; ++i) upmax(ans, f[i]);
print(ans);
return 0;
}
|
Let's look at the following process: initially you have an empty stack and an array s of the length l. You are trying to push array elements to the stack in the order s_1, s_2, s_3, ... s_{l}. Moreover, if the stack is empty or the element at the top of this stack is not equal to the current element, then you just push the current element to the top of the stack. Otherwise, you don't push the current element to the stack and, moreover, pop the top element of the stack.
If after this process the stack remains empty, the array s is considered stack exterminable.
There are samples of stack exterminable arrays:
* [1, 1];
* [2, 1, 1, 2];
* [1, 1, 2, 2];
* [1, 3, 3, 1, 2, 2];
* [3, 1, 3, 3, 1, 3];
* [3, 3, 3, 3, 3, 3];
* [5, 1, 2, 2, 1, 4, 4, 5];
Let's consider the changing of stack more details if s = [5, 1, 2, 2, 1, 4, 4, 5] (the top of stack is highlighted).
1. after pushing s_1 = 5 the stack turn into [5];
2. after pushing s_2 = 1 the stack turn into [5, 1];
3. after pushing s_3 = 2 the stack turn into [5, 1, 2];
4. after pushing s_4 = 2 the stack turn into [5, 1];
5. after pushing s_5 = 1 the stack turn into [5];
6. after pushing s_6 = 4 the stack turn into [5, 4];
7. after pushing s_7 = 4 the stack turn into [5];
8. after pushing s_8 = 5 the stack is empty.
You are given an array a_1, a_2, …, a_n. You have to calculate the number of its subarrays which are stack exterminable.
Note, that you have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the length of array a.
The second line of each query contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n) — the elements.
It is guaranteed that the sum of all n over all queries does not exceed 3 ⋅ 10^5.
Output
For each test case print one integer in single line — the number of stack exterminable subarrays of the array a.
Example
Input
3
5
2 1 1 2 2
6
1 2 1 1 3 2
9
3 1 2 2 1 6 6 3 3
Output
4
1
8
Note
In the first query there are four stack exterminable subarrays: a_{1 … 4} = [2, 1, 1, 2], a_{2 … 3} = [1, 1], a_{2 … 5} = [1, 1, 2, 2], a_{4 … 5} = [2, 2].
In the second query, only one subarray is exterminable subarray — a_{3 … 4}.
In the third query, there are eight stack exterminable subarrays: a_{1 … 8}, a_{2 … 5}, a_{2 … 7}, a_{2 … 9}, a_{3 … 4}, a_{6 … 7}, a_{6 … 9}, a_{8 … 9}.
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 300000;
int n;
int a[MAXN];
int nxt[MAXN + 1];
map<int, int> mp[MAXN + 1];
int mpidx[MAXN + 1];
int len[MAXN + 1];
long long solve() {
nxt[n] = -1;
mpidx[n] = n, mp[n].clear();
for (int i = n - 1; i >= 0; --i) {
int idx = mpidx[i + 1];
auto it = mp[idx].find(a[i]);
if (it != mp[idx].end()) {
nxt[i] = it->second + 1;
assert(mpidx[nxt[i]] != -1);
mpidx[i] = mpidx[nxt[i]];
mpidx[nxt[i]] = -1;
if (nxt[i] < n) mp[mpidx[i]][a[nxt[i]]] = nxt[i];
} else {
nxt[i] = -1;
mpidx[i] = i, mp[i].clear();
}
mp[mpidx[i]][a[i]] = i;
}
len[n] = 0;
for (int i = n - 1; i >= 0; --i) {
len[i] = nxt[i] == -1 ? 0 : 1 + len[nxt[i]];
}
long long ret = 0;
for (int i = (0); i < (n); ++i) ret += len[i];
return ret;
}
void run() {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) scanf("%d", &a[i]);
printf("%lld\n", solve());
}
int main() {
int ncase;
scanf("%d", &ncase);
for (int i = (1); i <= (ncase); ++i) run();
return 0;
}
|
You are organizing a boxing tournament, where n boxers will participate (n is a power of 2), and your friend is one of them. All boxers have different strength from 1 to n, and boxer i wins in the match against boxer j if and only if i is stronger than j.
The tournament will be organized as follows: n boxers will be divided into pairs; the loser in each pair leaves the tournament, and n/2 winners advance to the next stage, where they are divided into pairs again, and the winners in all pairs advance to the next stage, and so on, until only one boxer remains (who is declared the winner).
Your friend really wants to win the tournament, but he may be not the strongest boxer. To help your friend win the tournament, you may bribe his opponents: if your friend is fighting with a boxer you have bribed, your friend wins even if his strength is lower.
Furthermore, during each stage you distribute the boxers into pairs as you wish.
The boxer with strength i can be bribed if you pay him a_i dollars. What is the minimum number of dollars you have to spend to make your friend win the tournament, provided that you arrange the boxers into pairs during each stage as you wish?
Input
The first line contains one integer n (2 ≤ n ≤ 2^{18}) — the number of boxers. n is a power of 2.
The second line contains n integers a_1, a_2, ..., a_n, where a_i is the number of dollars you have to pay if you want to bribe the boxer with strength i. Exactly one of a_i is equal to -1 — it means that the boxer with strength i is your friend. All other values are in the range [1, 10^9].
Output
Print one integer — the minimum number of dollars you have to pay so your friend wins.
Examples
Input
4
3 9 1 -1
Output
0
Input
8
11 -1 13 19 24 7 17 5
Output
12
Note
In the first test case no matter how you will distribute boxers into pairs, your friend is the strongest boxer and anyway wins the tournament.
In the second test case you can distribute boxers as follows (your friend is number 2):
1 : 2, 8 : 5, 7 : 3, 6 : 4 (boxers 2, 8, 7 and 6 advance to the next stage);
2 : 6, 8 : 7 (boxers 2 and 8 advance to the next stage, you have to bribe the boxer with strength 6);
2 : 8 (you have to bribe the boxer with strength 8);
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
long long int log = log2(n), rem;
rem = log;
vector<long long int> arr(n);
for (long long int i = 0; i < n; i++) cin >> arr[i];
reverse((arr).begin(), (arr).end());
while (arr.back() != -1) arr.pop_back();
arr.pop_back();
reverse((arr).begin(), (arr).end());
long long int win = n - arr.size();
while (win > 1) {
rem--;
win /= 2;
}
if (arr.size() == 0) {
cout << 0;
return 0;
}
long long int ans = 0;
long long int lose = n / 2;
priority_queue<long long int, vector<long long int>, greater<long long int>>
Q;
Q.push(arr.back());
arr.pop_back();
while (rem > 0) {
ans += Q.top();
Q.pop();
for (long long int i = 0; i < lose && !arr.empty(); i++) {
Q.push(arr.back());
arr.pop_back();
}
lose /= 2;
rem--;
}
cout << ans;
}
|
We are committed to the well being of all participants. Therefore, instead of the problem, we suggest you enjoy a piece of cake.
Uh oh. Somebody cut the cake. We told them to wait for you, but they did it anyway. There is still some left, though, if you hurry back. Of course, before you taste the cake, you thought about how the cake was cut.
It is known that the cake was originally a regular n-sided polygon, each vertex of which had a unique number from 1 to n. The vertices were numbered in random order.
Each piece of the cake is a triangle. The cake was cut into n - 2 pieces as follows: each time one cut was made with a knife (from one vertex to another) such that exactly one triangular piece was separated from the current cake, and the rest continued to be a convex polygon. In other words, each time three consecutive vertices of the polygon were selected and the corresponding triangle was cut off.
A possible process of cutting the cake is presented in the picture below.
<image> Example of 6-sided cake slicing.
You are given a set of n-2 triangular pieces in random order. The vertices of each piece are given in random order — clockwise or counterclockwise. Each piece is defined by three numbers — the numbers of the corresponding n-sided cake vertices.
For example, for the situation in the picture above, you could be given a set of pieces: [3, 6, 5], [5, 2, 4], [5, 4, 6], [6, 3, 1].
You are interested in two questions.
* What was the enumeration of the n-sided cake vertices?
* In what order were the pieces cut?
Formally, you have to find two permutations p_1, p_2, ..., p_n (1 ≤ p_i ≤ n) and q_1, q_2, ..., q_{n - 2} (1 ≤ q_i ≤ n - 2) such that if the cake vertices are numbered with the numbers p_1, p_2, ..., p_n in order clockwise or counterclockwise, then when cutting pieces of the cake in the order q_1, q_2, ..., q_{n - 2} always cuts off a triangular piece so that the remaining part forms one convex polygon.
For example, in the picture above the answer permutations could be: p=[2, 4, 6, 1, 3, 5] (or any of its cyclic shifts, or its reversal and after that any cyclic shift) and q=[2, 4, 1, 3].
Write a program that, based on the given triangular pieces, finds any suitable permutations p and q.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases. Then there are t independent sets of input data.
The first line of each set consists of a single integer n (3 ≤ n ≤ 10^5) — the number of vertices in the cake.
The following n - 2 lines describe the numbers of the pieces vertices: each line consists of three different integers a, b, c (1 ≤ a, b, c ≤ n) — the numbers of the pieces vertices of cake given in random order. The pieces are given in random order.
It is guaranteed that the answer to each of the tests exists. It is also guaranteed that the sum of n for all test cases does not exceed 10^5.
Output
Print 2t lines — answers to given t test cases in the order in which they are written in the input. Each answer should consist of 2 lines.
In the first line of an answer on a test case print n distinct numbers p_1, p_2, ..., p_n(1 ≤ p_i ≤ n) — the numbers of the cake vertices in clockwise or counterclockwise order.
In the second line of an answer on a test case print n - 2 distinct numbers q_1, q_2, ..., q_{n - 2}(1 ≤ q_i ≤ n - 2) — the order of cutting pieces of the cake. The number of a piece of the cake corresponds to its number in the input.
If there are several answers, print any. It is guaranteed that the answer to each of the tests exists.
Example
Input
3
6
3 6 5
5 2 4
5 4 6
6 3 1
6
2 5 6
2 5 1
4 1 2
1 3 5
3
1 2 3
Output
1 6 4 2 5 3
4 2 3 1
1 4 2 6 5 3
3 4 2 1
1 3 2
1
|
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
public class Main {
static int inf = (int) 1e9 + 7;
static int n, tri[][];
static ArrayList<Integer> gr[];
static TreeSet<Integer> cnt[];
public static void main(String[] args) throws IOException {
sc = new Scanner(System.in);
pw = new PrintWriter(System.out);
for(int test = sc.nextInt();test > 0;test--) {
n = sc.nextInt();
cnt = new TreeSet[n + 1];
gr = new ArrayList[n + 1];
for(int i = 0;i <= n;i++) {
cnt[i] = new TreeSet<>();
gr[i] = new ArrayList<>();
}
tri = new int [n - 2][3];
for(int i = 0;i < n - 2;i++) {
for(int j = 0;j < 3;j++) {
tri[i][j] = sc.nextInt();
cnt[tri[i][j]].add(i);
}
}
if (n == 3) {
pw.println(1 + " " + 2 + " " + 3);
pw.println(1);
continue;
}
ArrayDeque<Integer> bfs = new ArrayDeque<>();
for(int i = 0;i <= n;i++) {
if (cnt[i].size() == 1) bfs.add(i);
}
ArrayList<Integer> ans2 = new ArrayList<>();
ArrayList<Integer> ans1 = new ArrayList<>();
dsu cal = new dsu(n + 1);
while(!bfs.isEmpty()) {
int v = bfs.pollFirst();
if (cnt[v].isEmpty()) continue;
int id = cnt[v].first();
ans2.add(id + 1);
for(int i = 0;i < 3;i++) {
cnt[tri[id][i]].remove(id);
if (tri[id][i] == v) continue;
if (cal.get(tri[id][i]) != cal.get(v)) {
gr[v].add(tri[id][i]);
gr[tri[id][i]].add(v);
cal.union(tri[id][i], v);
}
if (cnt[tri[id][i]].size() == 1) bfs.add(tri[id][i]);
}
}
int v = 1;
for(int i = 1;i <= n;i++) if (gr[i].size() == 1) v = i;
int pr = -1;
while(ans1.size() != n) {
ans1.add(v);
for(int to : gr[v]) {
if (to != pr) {
pr = v;
v = to;
break;
}
}
}
for(int i : ans1) pw.print(i + " ");
pw.println();
for(int i : ans2) pw.print(i + " ");
pw.println();
}
pw.close();
}
static Scanner sc;
static PrintWriter pw;
static class Scanner {
BufferedReader br;
StringTokenizer st = new StringTokenizer("");
Scanner(InputStream in) throws FileNotFoundException {
br = new BufferedReader(new InputStreamReader(in));
}
Scanner(String in) throws FileNotFoundException {
br = new BufferedReader(new FileReader(in));
}
String next() throws IOException {
while (!st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
return st.nextToken();
}
int nextInt() throws IOException {
return Integer.parseInt(next());
}
long nextLong() throws IOException {
return Long.parseLong(next());
}
double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
}
class matrix {
long a[][];
static long mod = (long) 1e18 + 7;
int n;
matrix(int n) {
this.n = n;
a = new long[n][n];
}
matrix(long b[][]) {
n = b.length;
a = new long [n][n];
for(int i = 0;i < n;i++) {
for(int j = 0;j < n;j++) {
a[i][j] = b[i][j];
}
}
}
matrix add(matrix b) {
matrix c = new matrix(n);
for(int i = 0;i < n;i++) {
for(int j = 0;j < n;j++) {
c.a[i][j] = (a[i][j] + b.a[i][j]) % mod;
}
}
return c;
}
matrix mul(matrix b) {
matrix c = new matrix(n);
for(int i = 0;i < n;i++) {
for(int j = 0;j < n;j++) {
for(int k = 0;k < n;k++) {
c.a[i][j] = (c.a[i][j] + a[i][k] * b.a[k][j]) % mod;
}
}
}
return c;
}
matrix pow(long pow) {
matrix ans = new matrix(n);
matrix temp = new matrix(a);
for(int i = 0;i < n;i++) ans.a[i][i] = 1;
while(pow != 0) {
if ((pow & 1) == 1) ans = ans.mul(temp);
temp = temp.mul(temp);
pow >>= 1;
}
return ans;
}
}
class dsu {
int parent[];
dsu(int n) {
parent = new int [n];
for(int i = 0;i < n;i++) parent[i] = i;
}
int get(int v) {
if (parent[v] != v) return parent[v] = get(parent[v]);
return v;
}
void union(int a1, int b1) {
parent[get(a1)] = get(b1);
}
}
|
You are given a permutation, p_1, p_2, …, p_n.
Imagine that some positions of the permutation contain bombs, such that there exists at least one position without a bomb.
For some fixed configuration of bombs, consider the following process. Initially, there is an empty set, A.
For each i from 1 to n:
* Add p_i to A.
* If the i-th position contains a bomb, remove the largest element in A.
After the process is completed, A will be non-empty. The cost of the configuration of bombs equals the largest element in A.
You are given another permutation, q_1, q_2, …, q_n.
For each 1 ≤ i ≤ n, find the cost of a configuration of bombs such that there exists a bomb in positions q_1, q_2, …, q_{i-1}.
For example, for i=1, you need to find the cost of a configuration without bombs, and for i=n, you need to find the cost of a configuration with bombs in positions q_1, q_2, …, q_{n-1}.
Input
The first line contains a single integer, n (2 ≤ n ≤ 300 000).
The second line contains n distinct integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n).
The third line contains n distinct integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).
Output
Print n space-separated integers, such that the i-th of them equals the cost of a configuration of bombs in positions q_1, q_2, …, q_{i-1}.
Examples
Input
3
3 2 1
1 2 3
Output
3 2 1
Input
6
2 3 6 1 5 4
5 2 1 4 6 3
Output
6 5 5 5 4 1
Note
In the first test:
* If there are no bombs, A is equal to \{1, 2, 3\} at the end of the process, so the cost of the configuration is 3.
* If there is one bomb in position 1, A is equal to \{1, 2\} at the end of the process, so the cost of the configuration is 2;
* If there are two bombs in positions 1 and 2, A is equal to \{1\} at the end of the process, so the cost of the configuration is 1.
In the second test:
Let's consider the process for i = 4. There are three bombs on positions q_1 = 5, q_2 = 2, and q_3 = 1.
At the beginning, A = \{\}.
* Operation 1: Add p_1 = 2 to A, so A is equal to \{2\}. There exists a bomb in position 1, so we should delete the largest element from A. A is equal to \{\}.
* Operation 2: Add p_2 = 3 to A, so A is equal to \{3\}. There exists a bomb in position 2, so we should delete the largest element from A. A is equal to \{\}.
* Operation 3: Add p_3 = 6 to A, so A is equal to \{6\}. There is no bomb in position 3, so we do nothing.
* Operation 4: Add p_4 = 1 to A, so A is equal to \{1, 6\}. There is no bomb in position 4, so we do nothing.
* Operation 5: Add p_5 = 5 to A, so A is equal to \{1, 5, 6\}. There exists a bomb in position 5, so we delete the largest element from A. Now, A is equal to \{1, 5\}.
* Operation 6: Add p_6 = 4 to A, so A is equal to \{1, 4, 5\}. There is no bomb in position 6, so we do nothing.
In the end, we have A = \{1, 4, 5\}, so the cost of the configuration is equal to 5.
|
#include <bits/stdc++.h>
using namespace std;
int n, p[300005], pp[300005], q[300005];
struct SegTree {
int a[300005 << 2], tg[300005 << 2];
inline int lc(int x) { return x << 1; }
inline int rc(int x) { return x << 1 | 1; }
inline void push_up(int p) { a[p] = max(a[lc(p)], a[rc(p)]); }
inline void f(int p, int k) {
a[p] += k;
tg[p] += k;
}
inline void push_down(int p) {
f(lc(p), tg[p]);
f(rc(p), tg[p]);
tg[p] = 0;
}
inline void update(int p, int l, int r, int L, int R, int k) {
if (L > R) return;
if (L <= l && r <= R) {
f(p, k);
return;
}
int mid = l + r >> 1;
push_down(p);
if (L <= mid) update(lc(p), l, mid, L, R, k);
if (mid < R) update(rc(p), mid + 1, r, L, R, k);
push_up(p);
}
inline int query(int p, int l, int r, int L, int R) {
if (L <= l && r <= R) return a[p];
int mid = l + r >> 1, res = 0;
push_down(p);
if (L <= mid) res = max(res, query(lc(p), l, mid, L, R));
if (mid < R) res = max(res, query(rc(p), mid + 1, r, L, R));
return res;
}
} tr;
int main() {
scanf("%d", &n);
int ans = n + 1;
for (int i = 1; i <= n; ++i) {
scanf("%d", p + i);
pp[p[i]] = i;
}
for (int i = 1; i <= n; ++i) {
scanf("%d", q + i);
tr.update(1, 1, n, 1, q[i - 1], -1);
while (tr.query(1, 1, n, 1, n) <= 0) {
--ans;
tr.update(1, 1, n, 1, pp[ans], 1);
}
printf("%d ", ans);
}
return 0;
}
|
Logical quantifiers are very useful tools for expressing claims about a set. For this problem, let's focus on the set of real numbers specifically. The set of real numbers includes zero and negatives. There are two kinds of quantifiers: universal (∀) and existential (∃). You can read more about them here.
The universal quantifier is used to make a claim that a statement holds for all real numbers. For example:
* ∀ x,x<100 is read as: for all real numbers x, x is less than 100. This statement is false.
* ∀ x,x>x-1 is read as: for all real numbers x, x is greater than x-1. This statement is true.
The existential quantifier is used to make a claim that there exists some real number for which the statement holds. For example:
* ∃ x,x<100 is read as: there exists a real number x such that x is less than 100. This statement is true.
* ∃ x,x>x-1 is read as: there exists a real number x such that x is greater than x-1. This statement is true.
Moreover, these quantifiers can be nested. For example:
* ∀ x,∃ y,x<y is read as: for all real numbers x, there exists a real number y such that x is less than y. This statement is true since for every x, there exists y=x+1.
* ∃ y,∀ x,x<y is read as: there exists a real number y such that for all real numbers x, x is less than y. This statement is false because it claims that there is a maximum real number: a number y larger than every x.
Note that the order of variables and quantifiers is important for the meaning and veracity of a statement.
There are n variables x_1,x_2,…,x_n, and you are given some formula of the form $$$ f(x_1,...,x_n):=(x_{j_1}<x_{k_1})∧ (x_{j_2}<x_{k_2})∧ ⋅⋅⋅∧ (x_{j_m}<x_{k_m}), $$$
where ∧ denotes logical AND. That is, f(x_1,…, x_n) is true if every inequality x_{j_i}<x_{k_i} holds. Otherwise, if at least one inequality does not hold, then f(x_1,…,x_n) is false.
Your task is to assign quantifiers Q_1,…,Q_n to either universal (∀) or existential (∃) so that the statement $$$ Q_1 x_1, Q_2 x_2, …, Q_n x_n, f(x_1,…, x_n) $$$
is true, and the number of universal quantifiers is maximized, or determine that the statement is false for every possible assignment of quantifiers.
Note that the order the variables appear in the statement is fixed. For example, if f(x_1,x_2):=(x_1<x_2) then you are not allowed to make x_2 appear first and use the statement ∀ x_2,∃ x_1, x_1<x_2. If you assign Q_1=∃ and Q_2=∀, it will only be interpreted as ∃ x_1,∀ x_2,x_1<x_2.
Input
The first line contains two integers n and m (2≤ n≤ 2⋅ 10^5; 1≤ m≤ 2⋅ 10^5) — the number of variables and the number of inequalities in the formula, respectively.
The next m lines describe the formula. The i-th of these lines contains two integers j_i,k_i (1≤ j_i,k_i≤ n, j_i≠ k_i).
Output
If there is no assignment of quantifiers for which the statement is true, output a single integer -1.
Otherwise, on the first line output an integer, the maximum possible number of universal quantifiers.
On the next line, output a string of length n, where the i-th character is "A" if Q_i should be a universal quantifier (∀), or "E" if Q_i should be an existential quantifier (∃). All letters should be upper-case. If there are multiple solutions where the number of universal quantifiers is maximum, print any.
Examples
Input
2 1
1 2
Output
1
AE
Input
4 3
1 2
2 3
3 1
Output
-1
Input
3 2
1 3
2 3
Output
2
AAE
Note
For the first test, the statement ∀ x_1, ∃ x_2, x_1<x_2 is true. Answers of "EA" and "AA" give false statements. The answer "EE" gives a true statement, but the number of universal quantifiers in this string is less than in our answer.
For the second test, we can show that no assignment of quantifiers, for which the statement is true exists.
For the third test, the statement ∀ x_1, ∀ x_2, ∃ x_3, (x_1<x_3)∧ (x_2<x_3) is true: We can set x_3=max\\{x_1,x_2\}+1.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int INF = 0x3f3f3f3f;
const long long inf = 0x3f3f3f3f3f3f3f3f;
int n, m;
vector<int> G[N], GG[N];
int vis[N], mn[N], mn2[N];
bool dfs(int u) {
vis[u] = 1;
mn[u] = u;
for (int v : G[u]) {
if (vis[v] == 1) return false;
if (!vis[v]) {
if (!dfs(v)) return false;
}
mn[u] = min(mn[u], mn[v]);
}
vis[u] = 2;
return true;
}
bool dfs2(int u) {
vis[u] = 1;
mn2[u] = u;
for (int v : GG[u]) {
if (vis[v] == 1) return false;
if (!vis[v]) {
if (!dfs2(v)) return false;
}
mn2[u] = min(mn2[u], mn2[v]);
}
vis[u] = 2;
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[v].push_back(u);
GG[u].push_back(v);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) {
if (!dfs(i)) {
puts("-1");
return 0;
}
}
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++)
if (!vis[i]) {
if (!dfs2(i)) {
puts("-1");
return 0;
}
}
int ans = 0;
for (int i = 1; i <= n; i++)
if (mn[i] >= i && mn2[i] >= i) ans++;
printf("%d\n", ans);
for (int i = 1; i <= n; i++)
printf("%c", mn[i] >= i && mn2[i] >= i ? 'A' : 'E');
puts("");
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.