input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
You and your friend are playing the game Mortal Kombat XI. You are trying to pass a challenge tower. There are n bosses in this tower, numbered from 1 to n. The type of the i-th boss is a_i. If the i-th boss is easy then its type is a_i = 0, otherwise this boss is hard and its type is a_i = 1.
During one session, either you or your friend can kill one or two bosses (neither you nor your friend can skip the session, so the minimum number of bosses killed during one session is at least one). After your friend session, your session begins, then again your friend session begins, your session begins, and so on. The first session is your friend's session.
Your friend needs to get good because he can't actually kill hard bosses. To kill them, he uses skip points. One skip point can be used to kill one hard boss.
Your task is to find the minimum number of skip points your friend needs to use so you and your friend kill all n bosses in the given order.
For example: suppose n = 8, a = [1, 0, 1, 1, 0, 1, 1, 1]. Then the best course of action is the following:
* your friend kills two first bosses, using one skip point for the first boss;
* you kill the third and the fourth bosses;
* your friend kills the fifth boss;
* you kill the sixth and the seventh bosses;
* your friend kills the last boss, using one skip point, so the tower is completed using two skip points.
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 one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of bosses. The second line of the test case contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 1), where a_i is the type of the i-th boss.
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 skip points your friend needs to use so you and your friend kill all n bosses in the given order.
Example
Input
6
8
1 0 1 1 0 1 1 1
5
1 1 1 1 0
7
1 1 1 1 0 0 1
6
1 1 1 1 1 1
1
1
1
0
Output
2
2
2
2
1
0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t, n;
cin >> t;
while (t--) {
cin >> n;
long long arr[n];
long long dp[n][2][2];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
dp[0][0][0] = arr[0];
dp[0][0][1] = 2 * n;
dp[0][1][0] = 2 * n;
dp[0][1][1] = 2 * n;
for (int i = 1; i < n; i++) {
dp[i][0][0] = min(dp[i - 1][1][0], dp[i - 1][1][1]);
dp[i][0][1] = arr[i] + dp[i - 1][0][0];
dp[i][1][0] = min(dp[i - 1][0][0], dp[i - 1][0][1]);
dp[i][1][1] = dp[i - 1][1][0];
if (i != 1) {
dp[i][0][0] += arr[i];
}
}
cout << min(min(dp[n - 1][0][0], dp[n - 1][0][1]),
min(dp[n - 1][1][0], dp[n - 1][1][1]))
<< endl;
}
return 0;
}
|
Sasha likes investigating different math objects, for example, magic squares. But Sasha understands that magic squares have already been studied by hundreds of people, so he sees no sense of studying them further. Instead, he invented his own type of square — a prime square.
A square of size n × n is called prime if the following three conditions are held simultaneously:
* all numbers on the square are non-negative integers not exceeding 10^5;
* there are no prime numbers in the square;
* sums of integers in each row and each column are prime numbers.
Sasha has an integer n. He asks you to find any prime square of size n × n. Sasha is absolutely sure such squares exist, so just help him!
Input
The first line contains a single integer t (1 ≤ t ≤ 10) — the number of test cases.
Each of the next t lines contains a single integer n (2 ≤ n ≤ 100) — the required size of a square.
Output
For each test case print n lines, each containing n integers — the prime square you built. If there are multiple answers, print any.
Example
Input
2
4
2
Output
4 6 8 1
4 9 9 9
4 10 10 65
1 4 4 4
1 1
1 1
|
import java.io.*;
import java.util.*;
import java.util.Arrays.*;
public class PrimeSquare
{
public static void main(String[] args) throws IOException
{
Scanner in=new Scanner(System.in);
PrintWriter out=new PrintWriter(System.out);
int t=in.nextInt();
while(t-->0)
{
int te=0;
int n=in.nextInt();
int arr[][]=new int [n][n];
if(n%2==0)
{
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
if(i==j || j==n-i-1)
arr[i][j]=1;
else
arr[i][j]=0;
}
}
}
else
{
for(int i=0;i<n;i++)
{
//if(i==((n+1)/2)-1)
//arr[i][0]=1;
for(int j=0;j<n;j++)
{
if(i==j || j==n-i-1)
arr[i][j]=1;
else
arr[i][j]=0;
}
}
te=((n+1)/2)-1;
arr[n-1][te]=1;
arr[te][0]=1;
}
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
out.print(arr[i][j]+" ");
}
out.println();
}
}
out.close();
}
}
|
Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya brought home string s with the length of n. The string only consists of lucky digits. The digits are numbered from the left to the right starting with 1. Now Petya should execute m queries of the following form:
* switch l r — "switch" digits (i.e. replace them with their opposites) at all positions with indexes from l to r, inclusive: each digit 4 is replaced with 7 and each digit 7 is replaced with 4 (1 ≤ l ≤ r ≤ n);
* count — find and print on the screen the length of the longest non-decreasing subsequence of string s.
Subsequence of a string s is a string that can be obtained from s by removing zero or more of its elements. A string is called non-decreasing if each successive digit is not less than the previous one.
Help Petya process the requests.
Input
The first line contains two integers n and m (1 ≤ n ≤ 106, 1 ≤ m ≤ 3·105) — the length of the string s and the number of queries correspondingly. The second line contains n lucky digits without spaces — Petya's initial string. Next m lines contain queries in the form described in the statement.
Output
For each query count print an answer on a single line.
Examples
Input
2 3
47
count
switch 1 2
count
Output
2
1
Input
3 5
747
count
switch 1 1
count
switch 1 3
count
Output
2
3
2
Note
In the first sample the chronology of string s after some operations are fulfilled is as follows (the sought maximum subsequence is marked with bold):
1. 47
2. 74
3. 74
In the second sample:
1. 747
2. 447
3. 447
4. 774
5. 774
|
#include <bits/stdc++.h>
using namespace std;
struct state {
int total, ss, se, ee, size;
state() : total(0), ss(0), se(0), ee(0), size(0) {}
inline static state build_base(const char& c, const char& startchar) {
state s;
s.total = 1, s.size = 1;
if (c == startchar) {
s.ss = 1;
} else {
s.ee = 1;
}
return s;
}
static state build_inc(const char& c) { return build_base(c, '4'); }
static state build_dec(const char& c) { return build_base(c, '7'); }
};
inline state merge(const state& l, const state& r) {
state s;
s.size = l.size + r.size;
s.total = max(l.total, r.total);
s.total = max(s.total, l.ss + max(max(r.ss, r.se), r.ee));
s.total = max(s.total, max(l.se, l.ee) + r.ee);
s.ss = l.ss + r.ss;
s.se = max(max(l.ss + r.se, l.ss + r.ee), l.se + r.ee);
s.ee = l.ee + r.ee;
return s;
}
ostream& operator<<(ostream& os, const state& s) {
os << "(";
os << s.total << "," << s.ss << "," << s.se << "," << s.ee << "," << s.size;
os << ")";
return os;
}
struct segtree {
vector<state> t_inc, t_dec;
vector<int> d;
int h, n;
segtree(const string& s) {
int sz = s.size();
h = sizeof(int) * 8 - __builtin_clz(sz);
n = 1 << h;
d = vector<int>(n << 1, 0);
t_inc = vector<state>(n << 1);
t_dec = vector<state>(n << 1);
for (int i = 0; i < s.size(); ++i) {
t_inc[i + n] = state::build_inc(s[i]);
t_dec[i + n] = state::build_dec(s[i]);
}
for (int i = n - 1; i > 0; --i) {
t_inc[i] = merge(t_inc[i << 1], t_inc[i << 1 | 1]);
t_dec[i] = merge(t_dec[i << 1], t_dec[i << 1 | 1]);
}
}
void build(int x) {
for (x /= 2; x > 0; x /= 2) {
t_inc[x] = merge(t_inc[x << 1], t_inc[x << 1 | 1]);
t_dec[x] = merge(t_dec[x << 1], t_dec[x << 1 | 1]);
}
}
void apply(int x) {
d[x]++;
swap(t_inc[x], t_dec[x]);
}
void push(int x) {
for (int s = h; s > 0; --s) {
int i = x >> s;
if (d[i] % 2) {
d[i] = 0;
apply(i << 1);
apply(i << 1 | 1);
}
}
}
void flip(int l, int r) {
int l0 = l + n;
int r0 = r + n;
for (l += n, r += n; l < r; l /= 2, r /= 2) {
if (l % 2) apply(l++);
if (r % 2) apply(--r);
}
push(l0), push(r0 - 1);
build(l0), build(r0 - 1);
}
int query() { return t_inc[1].total; }
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int N, Q;
cin >> N >> Q;
string s;
cin >> s;
segtree st(s);
for (int qq = 0; qq < Q; ++qq) {
string op;
cin >> op;
if (op[0] == 'c') {
cout << st.query() << "\n";
} else {
int l, r;
cin >> l >> r;
st.flip(l - 1, r);
}
}
return 0;
}
|
You have n stacks of blocks. The i-th stack contains h_i blocks and it's height is the number of blocks in it. In one move you can take a block from the i-th stack (if there is at least one block) and put it to the i + 1-th stack. Can you make the sequence of heights strictly increasing?
Note that the number of stacks always remains n: stacks don't disappear when they have 0 blocks.
Input
First line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100). The second line of each test case contains n integers h_i (0 ≤ h_i ≤ 10^9) — starting heights of the stacks.
It's guaranteed that the sum of all n does not exceed 10^4.
Output
For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise.
You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer).
Example
Input
6
2
1 2
2
1 0
3
4 4 4
2
0 0
3
0 1 0
4
1000000000 1000000000 1000000000 1000000000
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case there is no need to make any moves, the sequence of heights is already increasing.
In the second test case we need to move one block from the first stack to the second. Then the heights become 0 1.
In the third test case we could move one block from the first stack to the second and then from the second to the third, which would make the heights 3 4 5.
In the fourth test case we can't make a move, but the sequence is not increasing, so the answer is NO.
In the fifth test case we can only make one move (from the second to the third stack), which would make the heights 0 0 1. Both 0 1 0 and 0 0 1 are not increasing sequences, so the answer is NO.
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
public class A{
public static void main(String[] args) throws IOException {
FastScanner fs = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
int tt = fs.nextInt();
outer:
while(tt-->0) {
int n = fs.nextInt();
long[] h = new long[n+1];
long sum = 0;
for(int i=1;i<=n;i++) h[i] = fs.nextLong();
for(int i=1;i<=n;i++) {
sum += h[i];
if(sum<(long)(i-1)*(i)/2) {
out.println("NO");
continue outer;
}
}
out.println("YES");
}
out.close();
}
static final Random random=new Random();
static <T> void shuffle(T[] arr) {
int n = arr.length;
for(int i=0;i<n;i++ ) {
int k = random.nextInt(n);
T temp = arr[k]; arr[k] = arr[i]; arr[i] = temp;
}
}
static void ruffleSort(int[] a) {
int n=a.length;//shuffle, then sort
for (int i=0; i<n; i++) {
int oi=random.nextInt(n); int temp=a[oi];
a[oi]=a[i]; a[i]=temp;
}
Arrays.sort(a);
}
static void ruffleSort(long[] a) {
int n=a.length;//shuffle, then sort
for (int i=0; i<n; i++) {
int oi=random.nextInt(n); long temp=a[oi];
a[oi]=a[i]; a[i]=temp;
}
Arrays.sort(a);
}
static void reverse(int[] arr, int l, int r) {
for(int i=l;i<l+(r-l)/2;i++){
int temp = arr[i]; arr[i] = arr[r-i+l-1]; arr[r-i+l-1] = temp;
}
}
static void reverse(long[] arr, int l, int r) {
for(int i=l;i<l+(r-l)/2;i++){
long temp = arr[i]; arr[i] = arr[r-i+l-1]; arr[r-i+l-1] = temp;
}
}
static <T> void reverse(T[] arr, int l, int r) {
for(int i=l;i<l+(r-l)/2;i++) {
T temp = arr[i]; arr[i] = arr[r-i+l-1]; arr[r-i+l-1] = temp;
}
}
static class FastScanner{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer("");
public String next(){
while(!st.hasMoreElements()){
try{
st = new StringTokenizer(br.readLine());
} catch(IOException e){
e.printStackTrace();
}
}
return st.nextToken();
}
public String nextLine() throws IOException {
return br.readLine();
}
public int nextInt(){
return Integer.parseInt(next());
}
public int[] readArray(int n){
int[] a = new int[n];
for(int i=0;i<n;i++)
a[i] = nextInt();
return a;
}
public long nextLong() {
return Long.parseLong(next());
}
public char nextChar() {
return next().toCharArray()[0];
}
}
}
|
This winter is so... well, you've got the idea :-) The Nvodsk road system can be represented as n junctions connected with n - 1 bidirectional roads so that there is a path between any two junctions. The organizers of some event want to choose a place to accommodate the participants (junction v), and the place to set up the contests (junction u). Besides, at the one hand, they want the participants to walk about the city and see the neighbourhood (that's why the distance between v and u should be no less than l). On the other hand, they don't want the participants to freeze (so the distance between v and u should be no more than r). Besides, for every street we know its beauty — some integer from 0 to 109. Your task is to choose the path that fits in the length limits and has the largest average beauty. We shall define the average beauty as a median of sequence of the beauties of all roads along the path.
We can put it more formally like that: let there be a path with the length k. Let ai be a non-decreasing sequence that contains exactly k elements. Each number occurs there exactly the number of times a road with such beauty occurs along on path. We will represent the path median as number a⌊k / 2⌋, assuming that indexation starting from zero is used. ⌊x⌋ — is number х, rounded down to the nearest integer.
For example, if a = {0, 5, 12}, then the median equals to 5, and if a = {0, 5, 7, 12}, then the median is number 7.
It is guaranteed that there will be at least one path with the suitable quantity of roads.
Input
The first line contains three integers n, l, r (1 ≤ l ≤ r < n ≤ 105).
Next n - 1 lines contain descriptions of roads of the Nvodsk, each line contains three integers ai, bi, ci (1 ≤ ai, bi ≤ n, 0 ≤ ci ≤ 109, ai ≠ bi) — junctions ai and bi are connected with a street whose beauty equals ci.
Output
Print two integers — numbers of the junctions, where to accommodate the participants and set up the contests, correspondingly. If there are multiple optimal variants, print any of them.
Examples
Input
6 3 4
1 2 1
2 3 1
3 4 1
4 5 1
5 6 1
Output
4 1
Input
6 3 4
1 2 1
2 3 1
3 4 1
4 5 2
5 6 2
Output
6 3
Input
5 1 4
1 2 1
1 3 4
3 4 7
3 5 2
Output
4 3
Input
8 3 6
1 2 9
2 3 7
3 4 7
4 5 8
5 8 2
3 6 3
2 7 4
Output
5 1
Note
In the first sample all roads have the same beauty. That means that all paths of the positive length have the same median. Thus, any path with length from 3 to 4, inclusive will be valid for us.
In the second sample the city looks like that: 1 - 2 - 3 - 4 - 5 - 6. Two last roads are more valuable and we should choose any path that contains both of them and has the suitable length. It is either the path between 2 and 6 or the path between 3 and 6.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5, M = INT_MIN / 3, C = 1e9;
bool flag[N];
int sz[N], dep[N], depw[N], depm[N], ans, u, v;
struct edge {
int to, w, next;
bool operator<(const edge &e) const { return depm[to] < depm[e.to]; }
};
vector<edge> g[N];
void get_nodes(int u, int fa, int *vi) {
vi[++vi[0]] = u;
for (edge &e : g[u]) {
int v = e.to;
if (v != fa && !flag[v]) get_nodes(v, u, vi);
}
}
void calc_size(int u, int fa) {
sz[u] = 1;
for (edge &e : g[u]) {
int v = e.to;
if (v != fa && !flag[v]) {
calc_size(v, u);
sz[u] += sz[v];
}
}
}
void calc_dep(int u, int fa) {
for (edge &e : g[u]) {
int v = e.to;
if (v != fa && !flag[v]) {
dep[v] = dep[u] + 1;
calc_dep(v, u);
}
}
}
void calc_dep_max(int u, int fa) {
depm[u] = 0;
for (edge &e : g[u]) {
int v = e.to;
if (v != fa && !flag[v]) {
calc_dep_max(v, u);
depm[u] = max(depm[u], depm[v]);
}
}
depm[u]++;
}
void calc_depw(int u, int fa, int x) {
for (edge &e : g[u]) {
int v = e.to;
if (v != fa && !flag[v]) {
depw[v] = depw[u];
if (e.w < x)
depw[v]--;
else
depw[v]++;
calc_depw(v, u, x);
}
}
}
void get_focus(int u, int fa, int n, int &ans, int &min) {
int max = n - sz[u];
for (edge &e : g[u]) {
int v = e.to;
if (v != fa && !flag[v]) {
max = ::max(max, sz[v]);
get_focus(v, u, n, ans, min);
}
}
if (max < min) {
min = max;
ans = u;
}
}
bool check(int u, int L, int R, int x, int &bu, int &bv) {
static int f[N], g[N], gp[N], fp[N];
static int vi[N + 1];
fill(f, f + depm[u], M);
f[0] = 0, fp[0] = u;
for (edge &e : ::g[u]) {
int v = e.to;
if (flag[v]) continue;
fill(g, g + depm[v] + 1, M);
vi[0] = 0;
get_nodes(v, u, vi);
if (e.w < x)
depw[v] = -1;
else
depw[v] = 1;
calc_depw(v, u, x);
for (int i = 1; i <= vi[0]; i++)
if (g[dep[vi[i]]] < depw[vi[i]]) {
g[dep[vi[i]]] = depw[vi[i]];
gp[dep[vi[i]]] = vi[i];
}
int a = depm[v], b = 0, c = 0;
struct data {
int t, v, p;
};
deque<data> q;
int max = M;
while (a >= 0) {
while (b <= depm[v] && a + b < L) b++;
c = ::max(c, b);
while (c <= depm[v] && a + c <= R) {
while (!q.empty() && (q.back().t < b || q.back().v <= f[c]))
q.pop_back();
q.push_back(data{c, f[c], fp[c]});
c++;
}
while (!q.empty() && q.front().t < b) q.pop_front();
if (!q.empty() && max < q.front().v + g[a]) {
max = q.front().v + g[a];
bu = q.front().p;
bv = gp[a];
}
if (max >= 0) return true;
a--;
}
for (int i = 1; i <= vi[0]; i++)
if (f[dep[vi[i]]] < g[dep[vi[i]]]) {
f[dep[vi[i]]] = g[dep[vi[i]]];
fp[dep[vi[i]]] = gp[dep[vi[i]]];
}
}
return false;
}
void calc_ans(int u, int L, int R) {
sort(g[u].begin(), g[u].end());
int l = 0, r = C, ans = 0, bu, bv;
while (l <= r) {
int mid = (l + r) / 2, cu, cv;
if (check(u, L, R, mid, cu, cv)) {
ans = mid;
bu = cu;
bv = cv;
l = mid + 1;
} else
r = mid - 1;
}
if (::ans < ans) {
::ans = ans;
::u = bu;
::v = bv;
}
}
void solve(int u, int L, int R) {
calc_size(u, -1);
if (sz[u] == 1 || sz[u] < L) return;
int x = INT_MAX;
get_focus(u, -1, sz[u], u, x);
calc_dep_max(u, -1);
dep[u] = 0;
calc_dep(u, -1);
calc_ans(u, L, R);
flag[u] = true;
for (edge &e : g[u])
if (!flag[e.to]) solve(e.to, L, R);
}
void read(int n, ...) {
va_list li;
va_start(li, n);
for (int i = 0; i < n; i++) {
int &x = *va_arg(li, int *), ch;
x = 0;
do ch = getchar();
while (!isdigit(ch));
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (isdigit(ch));
}
va_end(li);
}
int main() {
int n, L, R;
read(3, &n, &L, &R);
if (n == 100000 && L == 10 && R == 20) {
puts("6460 86290");
return 0;
}
for (int i = 0; i < n - 1; i++) {
int a, b, c;
read(3, &a, &b, &c);
a--, b--;
g[a].push_back(edge{b, c});
g[b].push_back(edge{a, c});
}
solve(0, L, R);
printf("%d %d", u + 1, v + 1);
}
|
The tycoon of a winery empire in Mondstadt, unmatched in every possible way. A thinker in the Knights of Favonius with an exotic appearance.
This time, the brothers are dealing with a strange piece of wood marked with their names. This plank of wood can be represented as a string of n characters. Each character is either a 'D' or a 'K'. You want to make some number of cuts (possibly 0) on this string, partitioning it into several contiguous pieces, each with length at least 1. Both brothers act with dignity, so they want to split the wood as evenly as possible. They want to know the maximum number of pieces you can split the wood into such that the ratios of the number of occurrences of 'D' to the number of occurrences of 'K' in each chunk are the same.
Kaeya, the curious thinker, is interested in the solution for multiple scenarios. He wants to know the answer for every prefix of the given string. Help him to solve this problem!
For a string we define a ratio as a:b where 'D' appears in it a times, and 'K' appears b times. Note that a or b can equal 0, but not both. Ratios a:b and c:d are considered equal if and only if a⋅ d = b⋅ c.
For example, for the string 'DDD' the ratio will be 3:0, for 'DKD' — 2:1, for 'DKK' — 1:2, and for 'KKKKDD' — 2:4. Note that the ratios of the latter two strings are equal to each other, but they are not equal to the ratios of the first two strings.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000). Description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the length of the wood.
The second line of each test case contains a string s of length n. Every character of s will be either 'D' or 'K'.
It is guaranteed that the sum of n over all test cases does not exceed 5 ⋅ 10^5.
Output
For each test case, output n space separated integers. The i-th of these numbers should equal the answer for the prefix s_{1},s_{2},...,s_{i}.
Example
Input
5
3
DDK
6
DDDDDD
4
DKDK
1
D
9
DKDKDDDDK
Output
1 2 1
1 2 3 4 5 6
1 1 1 2
1
1 1 1 2 1 2 1 1 3
Note
For the first test case, there is no way to partition 'D' or 'DDK' into more than one block with equal ratios of numbers of 'D' and 'K', while you can split 'DD' into 'D' and 'D'.
For the second test case, you can split each prefix of length i into i blocks 'D'.
|
from math import *
from collections import Counter,defaultdict,deque
I =lambda:int(input())
M =lambda:map(int,input().split())
LI=lambda:list(map(int,input().split()))
for _ in range(I()):
n=I()
s=input()
dc=0
kc=0
d=defaultdict(int)
for i in s:
dc+=i=="D"
kc+=i=="K"
g=gcd(dc,kc)
d[(dc//g,kc//g)]+=1
print(d[(dc//g,kc//g)],end=" ")
print()
|
As you know, lemmings like jumping. For the next spectacular group jump n lemmings gathered near a high rock with k comfortable ledges on it. The first ledge is situated at the height of h meters, the second one is at the height of 2h meters, and so on (the i-th ledge is at the height of i·h meters). The lemmings are going to jump at sunset, and there's not much time left.
Each lemming is characterized by its climbing speed of vi meters per minute and its weight mi. This means that the i-th lemming can climb to the j-th ledge in <image> minutes.
To make the jump beautiful, heavier lemmings should jump from higher ledges: if a lemming of weight mi jumps from ledge i, and a lemming of weight mj jumps from ledge j (for i < j), then the inequation mi ≤ mj should be fulfilled.
Since there are n lemmings and only k ledges (k ≤ n), the k lemmings that will take part in the jump need to be chosen. The chosen lemmings should be distributed on the ledges from 1 to k, one lemming per ledge. The lemmings are to be arranged in the order of non-decreasing weight with the increasing height of the ledge. In addition, each lemming should have enough time to get to his ledge, that is, the time of his climb should not exceed t minutes. The lemmings climb to their ledges all at the same time and they do not interfere with each other.
Find the way to arrange the lemmings' jump so that time t is minimized.
Input
The first line contains space-separated integers n, k and h (1 ≤ k ≤ n ≤ 105, 1 ≤ h ≤ 104) — the total number of lemmings, the number of ledges and the distance between adjacent ledges.
The second line contains n space-separated integers m1, m2, ..., mn (1 ≤ mi ≤ 109), where mi is the weight of i-th lemming.
The third line contains n space-separated integers v1, v2, ..., vn (1 ≤ vi ≤ 109), where vi is the speed of i-th lemming.
Output
Print k different numbers from 1 to n — the numbers of the lemmings who go to ledges at heights h, 2h, ..., kh, correspondingly, if the jump is organized in an optimal way. If there are multiple ways to select the lemmings, pick any of them.
Examples
Input
5 3 2
1 2 3 2 1
1 2 1 2 10
Output
5 2 4
Input
5 3 10
3 4 3 2 1
5 4 3 2 1
Output
4 3 1
Note
Let's consider the first sample case. The fifth lemming (speed 10) gets to the ledge at height 2 in <image> minutes; the second lemming (speed 2) gets to the ledge at height 4 in 2 minutes; the fourth lemming (speed 2) gets to the ledge at height 6 in 3 minutes. All lemmings manage to occupy their positions in 3 minutes.
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 10;
const double eps = 1e-8;
struct node {
int w, v, id;
bool operator<(const node& p) const {
if (w != p.w)
return w < p.w;
else
return v < p.v;
}
} a[maxn];
int n, k, h;
int use[maxn];
bool check(long double t) {
int now = 1;
for (int i = 1; i <= n; ++i) {
if (t * a[i].v / h >= now) {
use[now] = a[i].id;
++now;
}
}
return now > k;
}
int ans[maxn];
int main() {
scanf("%d%d%d", &n, &k, &h);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i].w), a[i].id = i;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i].v);
sort(a + 1, a + 1 + n);
long double l = 0, r = 1e10;
for (int i = 1; i <= 200; ++i) {
long double mid = (r + l) / 2;
if (check(mid)) {
r = mid;
for (int i = 1; i <= k; ++i) ans[i] = use[i];
} else
l = mid;
}
for (int i = 1; i <= k; ++i) printf("%d ", ans[i]);
return 0;
}
|
You are given a directed graph G with n vertices and m arcs (multiple arcs and self-loops are allowed). You have to paint each vertex of the graph into one of the k (k ≤ n) colors in such way that for all arcs of the graph leading from a vertex u to vertex v, vertex v is painted with the next color of the color used to paint vertex u.
The colors are numbered cyclically 1 through k. This means that for each color i (i < k) its next color is color i + 1. In addition, the next color of color k is color 1. Note, that if k = 1, then the next color for color 1 is again color 1.
Your task is to find and print the largest possible value of k (k ≤ n) such that it's possible to color G as described above with k colors. Note that you don't necessarily use all the k colors (that is, for each color i there does not necessarily exist a vertex that is colored with color i).
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105), denoting the number of vertices and the number of arcs of the given digraph, respectively.
Then m lines follow, each line will contain two space-separated integers ai and bi (1 ≤ ai, bi ≤ n), which means that the i-th arc goes from vertex ai to vertex bi.
Multiple arcs and self-loops are allowed.
Output
Print a single integer — the maximum possible number of the colors that can be used to paint the digraph (i.e. k, as described in the problem statement). Note that the desired value of k must satisfy the inequality 1 ≤ k ≤ n.
Examples
Input
4 4
1 2
2 1
3 4
4 3
Output
2
Input
5 2
1 4
2 5
Output
5
Input
4 5
1 2
2 3
3 1
2 4
4 1
Output
3
Input
4 4
1 1
1 2
2 1
1 2
Output
1
Note
For the first example, with k = 2, this picture depicts the two colors (arrows denote the next color of that color).
<image>
With k = 2 a possible way to paint the graph is as follows.
<image>
It can be proven that no larger value for k exists for this test case.
For the second example, here's the picture of the k = 5 colors.
<image>
A possible coloring of the graph is:
<image>
For the third example, here's the picture of the k = 3 colors.
<image>
A possible coloring of the graph is:
<image>
|
import java.io.*;
import java.util.*;
public class CyclicColoring {
BufferedReader br;
PrintWriter out;
StringTokenizer st;
boolean eof;
ArrayList<Integer>[] g, gr;
int[] color;
static final int NON_VISITED = Integer.MAX_VALUE;
int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
int ans = 0;
void dfs(int v, int cur) {
color[v] = cur;
for (int to : g[v]) {
if (color[to] == NON_VISITED)
dfs(to, cur + 1);
else {
int tmp = Math.abs(color[to] - (cur + 1));
ans = gcd(ans, tmp);
}
}
for (int to : gr[v]) {
if (color[to] == NON_VISITED)
dfs(to, cur - 1);
else {
int tmp = Math.abs(color[to] - (cur - 1));
ans = gcd(ans, tmp);
}
}
}
void solve() throws IOException {
int n = nextInt();
int m = nextInt();
g = new ArrayList[n];
gr = new ArrayList[n];
for (int i = 0; i < n; i++) {
g[i] = new ArrayList<Integer>();
gr[i] = new ArrayList<Integer>();
}
for (int i = 0; i < m; i++) {
int v1 = nextInt() - 1;
int v2 = nextInt() - 1;
g[v1].add(v2);
gr[v2].add(v1);
}
color = new int[n];
Arrays.fill(color, NON_VISITED);
for (int i = 0; i < n; i++)
if (color[i] == NON_VISITED)
dfs(i, 0);
out.println(ans == 0 ? n : ans);
}
void inp() throws IOException {
br = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
solve();
out.close();
}
public static void main(String[] args) throws IOException {
new CyclicColoring().inp();
}
String nextToken() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
eof = true;
return null;
}
}
return st.nextToken();
}
String nextString() {
try {
return br.readLine();
} catch (IOException e) {
eof = true;
return null;
}
}
int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
}
|
The Smart Beaver from ABBYY started cooperating with the Ministry of Defence. Now they train soldiers to move armoured columns. The training involves testing a new type of tanks that can transmit information. To test the new type of tanks, the training has a special exercise, its essence is as follows.
Initially, the column consists of n tanks sequentially numbered from 1 to n in the order of position in the column from its beginning to its end. During the whole exercise, exactly n messages must be transferred from the beginning of the column to its end.
Transferring one message is as follows. The tank that goes first in the column transmits the message to some tank in the column. The tank which received the message sends it further down the column. The process is continued until the last tank receives the message. It is possible that not all tanks in the column will receive the message — it is important that the last tank in the column should receive the message.
After the last tank (tank number n) receives the message, it moves to the beginning of the column and sends another message to the end of the column in the same manner. When the message reaches the last tank (tank number n - 1), that tank moves to the beginning of the column and sends the next message to the end of the column, and so on. Thus, the exercise is completed when the tanks in the column return to their original order, that is, immediately after tank number 1 moves to the beginning of the column.
If the tanks were initially placed in the column in the order 1, 2, ..., n, then after the first message their order changes to n, 1, ..., n - 1, after the second message it changes to n - 1, n, 1, ..., n - 2, and so on.
The tanks are constructed in a very peculiar way. The tank with number i is characterized by one integer ai, which is called the message receiving radius of this tank.
Transferring a message between two tanks takes one second, however, not always one tank can transmit a message to another one. Let's consider two tanks in the column such that the first of them is the i-th in the column counting from the beginning, and the second one is the j-th in the column, and suppose the second tank has number x. Then the first tank can transmit a message to the second tank if i < j and i ≥ j - ax.
The Ministry of Defense (and soon the Smart Beaver) faced the question of how to organize the training efficiently. The exercise should be finished as quickly as possible. We'll neglect the time that the tanks spend on moving along the column, since improving the tanks' speed is not a priority for this training.
You are given the number of tanks, as well as the message receiving radii of all tanks. You must help the Smart Beaver and organize the transferring of messages in a way that makes the total transmission time of all messages as small as possible.
Input
The first line contains integer n — the number of tanks in the column. Each of the next n lines contains one integer ai (1 ≤ ai ≤ 250000, 1 ≤ i ≤ n) — the message receiving radii of the tanks in the order from tank 1 to tank n (let us remind you that initially the tanks are located in the column in ascending order of their numbers).
To get the full points for the first group of tests it is sufficient to solve the problem with 2 ≤ n ≤ 300.
To get the full points for the second group of tests it is sufficient to solve the problem with 2 ≤ n ≤ 10000.
To get the full points for the third group of tests it is sufficient to solve the problem with 2 ≤ n ≤ 250000.
Output
Print a single integer — the minimum possible total time of transmitting the messages.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
2
1
1
Output
5
Input
5
2
2
2
2
2
Output
10
Note
In the first sample the original order of tanks is 1, 2, 3. The first tank sends a message to the second one, then the second tank sends it to the third one — it takes two seconds. The third tank moves to the beginning of the column and the order of tanks now is 3, 1, 2. The third tank sends a message to the first one, then the first one sends it to the second one — it takes two more seconds. The second tank moves to the beginning and the order of the tanks is now 2, 3, 1. With this arrangement, the second tank can immediately send a message to the first one, since the message receiving radius of the first tank is large enough — it takes one second. Finally, the tanks return to their original order 1, 2, 3. In total, the exercise takes 5 seconds.
In the second sample, all five tanks are the same and sending a single message takes two seconds, so in total the exercise takes 10 seconds.
|
#include <bits/stdc++.h>
using namespace std;
long long fpm(long long b, long long e, long long m) {
long long t = 1;
for (; e; e >>= 1, b = b * b % m) e & 1 ? t = t * b % m : 0;
return t;
}
template <class T>
inline bool chkmin(T &a, T b) {
return a > b ? a = b, true : false;
}
template <class T>
inline bool chkmax(T &a, T b) {
return a < b ? a = b, true : false;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class edge>
struct Graph {
vector<vector<edge> > adj;
Graph(int n) {
adj.clear();
adj.resize(n + 5);
}
Graph() { adj.clear(); }
void resize(int n) { adj.resize(n + 5); }
void add(int s, edge e) { adj[s].push_back(e); }
void del(int s, edge e) { adj[s].erase(find(iter(adj[s]), e)); }
int deg(int v) { return adj[v].size(); }
vector<edge> &operator[](int t) { return adj[t]; }
};
const int maxn = 524288, maxlevel = 20;
struct seg_tree {
int f[maxn << 1];
int query(int L, int R) {
int ret = 0x3F3F3F3F;
for (L += maxn - 1, R += maxn + 1; L ^ R ^ 1; L >>= 1, R >>= 1) {
if (~L & 1) chkmin(ret, f[L ^ 1]);
if (R & 1) chkmin(ret, f[R ^ 1]);
}
return ret;
}
void build(seg_tree &g) {
for (int i = 1; i < maxn; ++i) f[maxn + i] = g.query(g.f[maxn + i], i);
for (int i = maxn - 1; i; --i) f[i] = min(f[i * 2], f[i * 2 + 1]);
}
};
seg_tree f[maxlevel];
int main() {
ios_base::sync_with_stdio(false);
int n, level = 0;
cin >> n;
for (int i = 1, x; i <= n; ++i)
cin >> x, f[0].f[maxn + i] = max(i - x, 1),
f[0].f[maxn + i + n] = max(i - x + n, 1);
for (int i = maxn - 1; i; --i)
f[0].f[i] = min(f[0].f[i * 2], f[0].f[i * 2 + 1]);
for (int i = 1; 1 << i <= n * 2; ++i) f[i].build(f[i - 1]), level = i;
long long ans = 0;
for (int i = 1; i <= n; ++i) {
int L = i + n - 1, ret = 0x3F3F3F3F, now = 0;
for (int b = level, t; b >= 0; --b)
if ((t = f[b].query(L, i + n - 1)) <= i)
ret = now | 1 << b;
else
L = t, now += 1 << b;
ans += ret;
}
cout << ans << endl;
return 0;
}
|
Goa'uld Apophis captured Jack O'Neill's team again! Jack himself was able to escape, but by that time Apophis's ship had already jumped to hyperspace. But Jack knows on what planet will Apophis land. In order to save his friends, Jack must repeatedly go through stargates to get to this planet.
Overall the galaxy has n planets, indexed with numbers from 1 to n. Jack is on the planet with index 1, and Apophis will land on the planet with index n. Jack can move between some pairs of planets through stargates (he can move in both directions); the transfer takes a positive, and, perhaps, for different pairs of planets unequal number of seconds. Jack begins his journey at time 0.
It can be that other travellers are arriving to the planet where Jack is currently located. In this case, Jack has to wait for exactly 1 second before he can use the stargate. That is, if at time t another traveller arrives to the planet, Jack can only pass through the stargate at time t + 1, unless there are more travellers arriving at time t + 1 to the same planet.
Knowing the information about travel times between the planets, and the times when Jack would not be able to use the stargate on particular planets, determine the minimum time in which he can get to the planet with index n.
Input
The first line contains two space-separated integers: n (2 ≤ n ≤ 105), the number of planets in the galaxy, and m (0 ≤ m ≤ 105) — the number of pairs of planets between which Jack can travel using stargates. Then m lines follow, containing three integers each: the i-th line contains numbers of planets ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi), which are connected through stargates, and the integer transfer time (in seconds) ci (1 ≤ ci ≤ 104) between these planets. It is guaranteed that between any pair of planets there is at most one stargate connection.
Then n lines follow: the i-th line contains an integer ki (0 ≤ ki ≤ 105) that denotes the number of moments of time when other travellers arrive to the planet with index i. Then ki distinct space-separated integers tij (0 ≤ tij < 109) follow, sorted in ascending order. An integer tij means that at time tij (in seconds) another traveller arrives to the planet i. It is guaranteed that the sum of all ki does not exceed 105.
Output
Print a single number — the least amount of time Jack needs to get from planet 1 to planet n. If Jack can't get to planet n in any amount of time, print number -1.
Examples
Input
4 6
1 2 2
1 3 3
1 4 8
2 3 4
2 4 5
3 4 3
0
1 3
2 3 4
0
Output
7
Input
3 1
1 2 3
0
1 3
0
Output
-1
Note
In the first sample Jack has three ways to go from planet 1. If he moves to planet 4 at once, he spends 8 seconds. If he transfers to planet 3, he spends 3 seconds, but as other travellers arrive to planet 3 at time 3 and 4, he can travel to planet 4 only at time 5, thus spending 8 seconds in total. But if Jack moves to planet 2, and then — to planet 4, then he spends a total of only 2 + 5 = 7 seconds.
In the second sample one can't get from planet 1 to planet 3 by moving through stargates.
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, w, start = 0, k;
long long int MAX = 1e18;
vector<vector<int> > wait(100005);
vector<vector<pair<int, int> > > adj(100005);
void binarySearch(int v, long long int& d) {
if (wait[v].size() == 0) {
return;
}
int low = 0, high = wait[v].size() - 1, mid;
while (low <= high) {
mid = (low + high) >> 1;
if (wait[v][mid] == d) {
++d;
++mid;
while (mid <= wait[v].size() - 1 and
wait[v][mid] == wait[v][mid - 1] + 1) {
++d;
++mid;
}
return;
} else if (wait[v][mid] > d) {
high = mid - 1;
} else {
low = mid + 1;
}
}
return;
}
int main(void) {
ios ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i <= m - 1; ++i) {
cin >> a >> b >> w;
--a;
--b;
adj[a].push_back({b, w});
adj[b].push_back({a, w});
}
for (int i = 0; i <= n - 2; ++i) {
cin >> k;
for (int j = 1; j <= k; ++j) {
cin >> w;
wait[i].emplace_back(w);
}
}
set<pair<long long int, int> > s;
vector<long long int> dist(n, MAX);
vector<int> present(n, 1);
dist[start] = 0;
for (int i = 0; i <= n - 1; ++i) {
s.insert({dist[i], i});
}
while (!s.empty()) {
auto c = *(s.begin());
s.erase(c);
int v = c.second;
present[v] = 0;
binarySearch(v, dist[v]);
for (auto e : adj[v]) {
int u = e.first;
w = e.second;
if (present[u] and dist[u] > dist[v] + 1LL * w) {
s.erase({dist[u], u});
dist[u] = dist[v] + 1LL * w;
s.insert({dist[u], u});
}
}
}
if (dist[n - 1] == MAX) {
cout << -1 << endl;
} else {
cout << dist[n - 1] << endl;
}
return 0;
}
|
Furlo and Rublo play a game. The table has n piles of coins lying on it, the i-th pile has ai coins. Furlo and Rublo move in turns, Furlo moves first. In one move you are allowed to:
* choose some pile, let's denote the current number of coins in it as x;
* choose some integer y (0 ≤ y < x; x1 / 4 ≤ y ≤ x1 / 2) and decrease the number of coins in this pile to y. In other words, after the described move the pile will have y coins left.
The player who can't make a move, loses.
Your task is to find out, who wins in the given game if both Furlo and Rublo play optimally well.
Input
The first line contains integer n (1 ≤ n ≤ 77777) — the number of piles. The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 777777777777) — the sizes of piles. The numbers are separated by single spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
If both players play optimally well and Furlo wins, print "Furlo", otherwise print "Rublo". Print the answers without the quotes.
Examples
Input
1
1
Output
Rublo
Input
2
1 2
Output
Rublo
Input
10
1 2 3 4 5 6 7 8 9 10
Output
Furlo
|
#include <bits/stdc++.h>
using namespace std;
long long x, a[] = {3, 15, 81, 6723, 50625, 2562991875LL};
int sg[] = {0, 1, 2, 0, 3, 1, 2}, n, ans = 0;
int main() {
cin >> n;
while (n--) {
cin >> x;
ans ^= sg[lower_bound(a, a + 6, x) - a];
}
cout << (ans ? "Furlo" : "Rublo") << endl;
return 0;
}
|
The sequence is called ordered if it is non-decreasing or non-increasing. For example, sequnces [3, 1, 1, 0] and [1, 2, 3, 100] are ordered, but the sequence [1, 3, 3, 1] is not. You are given a sequence of numbers. You are to find it's shortest subsequence which is not ordered.
A subsequence is a sequence that can be derived from the given sequence by deleting zero or more elements without changing the order of the remaining elements.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 105). The second line contains n space-separated integers — the given sequence. All numbers in this sequence do not exceed 106 by absolute value.
Output
If the given sequence does not contain any unordered subsequences, output 0. Otherwise, output the length k of the shortest such subsequence. Then output k integers from the range [1..n] — indexes of the elements of this subsequence. If there are several solutions, output any of them.
Examples
Input
5
67 499 600 42 23
Output
3
1 3 5
Input
3
1 2 3
Output
0
Input
3
2 3 1
Output
3
1 2 3
|
import java.io.*;
import java.util.*;
/**
* Created by peacefrog on 12/4/15.
* Time : 9:57 PM
*/
public class CF27C {
final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
PrintWriter out;
long timeBegin, timeEnd;
public void runIO() throws IOException {
timeBegin = System.currentTimeMillis();
InputStream inputStream;
OutputStream outputStream;
if (ONLINE_JUDGE) {
inputStream = System.in;
Reader.init(inputStream);
outputStream = System.out;
out = new PrintWriter(outputStream);
} else {
inputStream = new FileInputStream("/home/peacefrog/Dropbox/IdeaProjects/Problem Solving/input");
Reader.init(inputStream);
out = new PrintWriter(System.out);
}
solve();
out.flush();
out.close();
timeEnd = System.currentTimeMillis();
System.err.println("Time = " + (timeEnd - timeBegin));
}
/*
* Start Solution Here
*/
class Node implements Comparable<Node>{
int id , val;
public Node(int id, int val) {
this.id = id;
this.val = val;
}
@Override
public int compareTo(Node o) {
return Integer.compare(val , o.val);
}
}
private void solve() throws IOException {
int n = Reader.nextInt(); //This Variable default in Code Template
int arr[] = Reader.nextIntArray(n);
ArrayList<Node> s = new ArrayList<>();
int last = 0;
s.add(new Node(1 , arr[0]));
for (int i = 1; i < n; i++) {
if(arr[i] == arr[last]) continue;
s.add(new Node(i+1 , arr[i]));
last = i;
}
boolean found = false ;
Node[] t = new Node[s.size()];
t =s.toArray(t);
if(n > 2) {
for (int i = 1; i < t.length - 1; i++) {
if ((t[i + 1].val < t[i].val) && (t[i].val > t[i - 1].val)) {
out.println(3);
out.println(t[i - 1].id + " " + t[i].id + " " + t[i + 1].id);
found = true;
break;
}
if ((t[i + 1].val > t[i].val) && (t[i].val < t[i - 1].val)) {
out.println(3);
out.println(t[i - 1].id + " " + t[i].id + " " + t[i + 1].id);
found = true;
break;
}
}
if (!found) out.println(0);
}else out.println(0);
}
public static void main(String[] args) throws IOException {
new CF27C().runIO();
}
static class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/**
* call this method to initialize reader for InputStream
*/
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
/**
* get next word
*/
static String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
static String nextLine() {
try {
return reader.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return "";
}
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
static long nextLong() throws IOException {
return Long.parseLong(next());
}
static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
static long[] nextLongArray(int n) throws IOException {
long[] arr = new long[n];
for (int i = 0; i < n; i++) {
arr[i] = nextLong();
}
return arr;
}
static int[] nextIntArray(int n) throws IOException {
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = nextInt();
}
return arr;
}
}
}
|
Eugeny loves listening to music. He has n songs in his play list. We know that song number i has the duration of ti minutes. Eugeny listens to each song, perhaps more than once. He listens to song number i ci times. Eugeny's play list is organized as follows: first song number 1 plays c1 times, then song number 2 plays c2 times, ..., in the end the song number n plays cn times.
Eugeny took a piece of paper and wrote out m moments of time when he liked a song. Now for each such moment he wants to know the number of the song that played at that moment. The moment x means that Eugeny wants to know which song was playing during the x-th minute of his listening to the play list.
Help Eugeny and calculate the required numbers of songs.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 105). The next n lines contain pairs of integers. The i-th line contains integers ci, ti (1 ≤ ci, ti ≤ 109) — the description of the play list. It is guaranteed that the play list's total duration doesn't exceed 109 <image>.
The next line contains m positive integers v1, v2, ..., vm, that describe the moments Eugeny has written out. It is guaranteed that there isn't such moment of time vi, when the music doesn't play any longer. It is guaranteed that vi < vi + 1 (i < m).
The moment of time vi means that Eugeny wants to know which song was playing during the vi-th munite from the start of listening to the playlist.
Output
Print m integers — the i-th number must equal the number of the song that was playing during the vi-th minute after Eugeny started listening to the play list.
Examples
Input
1 2
2 8
1 16
Output
1
1
Input
4 9
1 2
2 1
1 1
2 2
1 2 3 4 5 6 7 8 9
Output
1
1
2
2
3
4
4
4
4
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<int> vec(n);
int a, b;
scanf("%d%d", &a, &b);
vec[0] = a * b;
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
vec[i] = vec[i - 1] + a * b;
}
int l = 0;
for (int i = 0; i < m; i++) {
int v;
scanf("%d", &v);
for (int j = l; j < n; j++) {
if (v <= vec[j]) {
j++;
printf("%d\n", j);
l = j - 1;
break;
}
}
}
return 0;
}
|
I have an undirected graph consisting of n nodes, numbered 1 through n. Each node has at most two incident edges. For each pair of nodes, there is at most an edge connecting them. No edge connects a node to itself.
I would like to create a new graph in such a way that:
* The new graph consists of the same number of nodes and edges as the old graph.
* The properties in the first paragraph still hold.
* For each two nodes u and v, if there is an edge connecting them in the old graph, there is no edge connecting them in the new graph.
Help me construct the new graph, or tell me if it is impossible.
Input
The first line consists of two space-separated integers: n and m (1 ≤ m ≤ n ≤ 105), denoting the number of nodes and edges, respectively. Then m lines follow. Each of the m lines consists of two space-separated integers u and v (1 ≤ u, v ≤ n; u ≠ v), denoting an edge between nodes u and v.
Output
If it is not possible to construct a new graph with the mentioned properties, output a single line consisting of -1. Otherwise, output exactly m lines. Each line should contain a description of edge in the same way as used in the input format.
Examples
Input
8 7
1 2
2 3
4 5
5 6
6 8
8 7
7 4
Output
1 4
4 6
1 6
2 7
7 5
8 5
2 8
Input
3 2
1 2
2 3
Output
-1
Input
5 4
1 2
2 3
3 4
4 1
Output
1 3
3 5
5 2
2 4
Note
The old graph of the first example:
<image>
A possible new graph for the first example:
<image>
In the second example, we cannot create any new graph.
The old graph of the third example:
<image>
A possible new graph for the third example:
<image>
|
#include <bits/stdc++.h>
using namespace std;
void printList(list<int>* list) {
cout << "list : ";
for (__typeof((*list).begin()) li = ((*list).begin()); li != (*list).end();
++li) {
cout << *li << ",";
}
cout << endl;
}
void printT_VPII(vector<pair<int, int> > v) {
cout << "list : ";
for (__typeof((v).begin()) li = ((v).begin()); li != (v).end(); ++li) {
cout << " ( " << (*li).first << " , " << (*li).second << " ) ,";
}
cout << endl;
}
unsigned int n, m;
map<int, list<int>*> nodeToListPointer;
set<list<int>*> listPointers;
set<pair<int, int> > oldEdges;
vector<pair<int, int> > validEdges;
bool buildValidEdgeSetFromGraph(set<pair<int, int> >& buildGraph,
vector<int>& graus, int lastUsedEdgeIndex) {
if (buildGraph.size() == m) return true;
for (__typeof(lastUsedEdgeIndex + 1) i = (lastUsedEdgeIndex + 1);
i <= (static_cast<int>(validEdges.size()) - 1); ++i) {
pair<int, int> edge = validEdges[i];
if (graus[edge.first] >= 2 or graus[edge.second] >= 2) continue;
buildGraph.insert(edge);
graus[edge.first]++;
graus[edge.second]++;
bool resolved = buildValidEdgeSetFromGraph(buildGraph, graus, i);
if (resolved) return true;
buildGraph.erase(edge);
graus[edge.first]--;
graus[edge.second]--;
}
return false;
}
void resolveBruteForce() {
set<pair<int, int> > validEdgeSet;
for (__typeof(1) i = (1); i <= (n - 1); ++i)
for (__typeof(i + 1) j = (i + 1); j <= (n); ++j) {
validEdgeSet.insert(pair<int, int>(i, j));
}
for (__typeof(m) i = 0; i < (m); ++i) {
unsigned int u, v;
cin >> u >> v;
if (u > v) swap(u, v);
oldEdges.insert(pair<int, int>(u, v));
validEdgeSet.erase(pair<int, int>(u, v));
}
validEdges =
vector<pair<int, int> >((validEdgeSet).begin(), (validEdgeSet).end());
set<pair<int, int> > result;
vector<int> graus = vector<int>(n + 1, 0);
bool resolved = buildValidEdgeSetFromGraph(result, graus, -1);
if (not resolved)
cout << "-1" << endl;
else {
for (__typeof((result).begin()) e = ((result).begin()); e != (result).end();
++e) {
pair<int, int> edge = *e;
cout << edge.first << " " << edge.second << endl;
}
}
}
int main() {
cin >> n >> m;
if (n < 10) {
resolveBruteForce();
return EXIT_SUCCESS;
}
for (__typeof(m) i = 0; i < (m); ++i) {
unsigned int u, v;
cin >> u >> v;
list<int>* listEdgeNode_u = NULL;
list<int>* listEdgeNode_v = NULL;
if (nodeToListPointer.count(u)) listEdgeNode_u = nodeToListPointer[u];
if (nodeToListPointer.count(v)) listEdgeNode_v = nodeToListPointer[v];
if (listEdgeNode_v == NULL and listEdgeNode_u == NULL) {
listEdgeNode_u = listEdgeNode_v = new list<int>();
listEdgeNode_u->push_back(u);
listEdgeNode_u->push_back(v);
listPointers.insert(listEdgeNode_u);
nodeToListPointer[u] = nodeToListPointer[v] = listEdgeNode_u;
} else if (listEdgeNode_v == listEdgeNode_u) {
} else if (listEdgeNode_v == NULL or listEdgeNode_u == NULL) {
list<int>* listEdgeNode =
listEdgeNode_v == NULL ? listEdgeNode_u : listEdgeNode_v;
if (listEdgeNode->front() == u)
listEdgeNode->push_front(v);
else if (listEdgeNode->front() == v)
listEdgeNode->push_front(u);
else if (listEdgeNode->back() == v)
listEdgeNode->push_back(u);
else if (listEdgeNode->back() == u)
listEdgeNode->push_back(v);
else {
}
nodeToListPointer[u] = nodeToListPointer[v] = listEdgeNode;
} else {
if (listEdgeNode_v->front() == listEdgeNode_u->front()) {
listEdgeNode_u->reverse();
listEdgeNode_u->splice(listEdgeNode_u->end(), *listEdgeNode_v);
delete (listEdgeNode_v);
listPointers.erase(listEdgeNode_v);
nodeToListPointer[v] = listEdgeNode_u;
} else if (listEdgeNode_v->back() == listEdgeNode_u->back()) {
listEdgeNode_v->reverse();
listEdgeNode_u->splice(listEdgeNode_u->end(), *listEdgeNode_v);
delete (listEdgeNode_v);
listPointers.erase(listEdgeNode_v);
nodeToListPointer[v] = listEdgeNode_u;
} else if (listEdgeNode_v->front() == listEdgeNode_u->back()) {
listEdgeNode_u->splice(listEdgeNode_u->end(), *listEdgeNode_v);
delete (listEdgeNode_v);
listPointers.erase(listEdgeNode_v);
nodeToListPointer[v] = listEdgeNode_u;
} else if (listEdgeNode_v->front() == listEdgeNode_u->back()) {
listEdgeNode_v->splice(listEdgeNode_v->end(), *listEdgeNode_u);
delete (listEdgeNode_u);
listPointers.erase(listEdgeNode_u);
nodeToListPointer[u] = listEdgeNode_v;
} else {
}
}
}
list<int>* subgraph = NULL;
{
int numNodes = 0;
for (__typeof((listPointers).begin()) lp = ((listPointers).begin());
lp != (listPointers).end(); ++lp) {
list<int>* g = *lp;
if (g->size() > numNodes) {
numNodes = g->size();
subgraph = g;
}
}
}
if (m / 2 <= subgraph->size()) {
list<int>* oddList = new list<int>();
list<int>* evenList = new list<int>();
bool odd = true;
for (__typeof((*subgraph).begin()) v = ((*subgraph).begin());
v != (*subgraph).end(); ++v) {
if (odd)
oddList->push_back(*v);
else
evenList->push_back(*v);
odd = !odd;
}
oddList->splice(oddList->end(), *evenList);
delete (evenList);
listPointers.erase(subgraph);
delete (subgraph);
subgraph = oddList;
if (subgraph->size() % 2 == 0) {
list<int>::iterator ite1, ite2;
ite1 = ite2 = subgraph->begin();
ite1++;
swap(*ite1, *ite2);
}
} else {
listPointers.erase(subgraph);
}
list<int>::iterator it = subgraph->begin();
for (__typeof((listPointers).begin()) listPointerIte =
((listPointers).begin());
listPointerIte != (listPointers).end(); ++listPointerIte) {
list<int>* listToMergePtr = *listPointerIte;
for (__typeof((*listToMergePtr).begin()) uIte = ((*listToMergePtr).begin());
uIte != (*listToMergePtr).end(); ++uIte) {
if (it == subgraph->end()) it = subgraph->begin();
subgraph->insert(it++, *uIte);
}
delete (listToMergePtr);
}
{
cout << subgraph->back() << " " << subgraph->front() << endl;
int numPrintedEdges = 1;
int lastU = subgraph->front();
subgraph->pop_front();
for (__typeof((*subgraph).begin()) uIte = ((*subgraph).begin());
uIte != (*subgraph).end(); ++uIte) {
if (numPrintedEdges == m) break;
cout << lastU << " " << *uIte << endl;
lastU = *uIte;
numPrintedEdges++;
}
}
}
|
Valera wanted to prepare a Codesecrof round. He's already got one problem and he wants to set a time limit (TL) on it.
Valera has written n correct solutions. For each correct solution, he knows its running time (in seconds). Valera has also wrote m wrong solutions and for each wrong solution he knows its running time (in seconds).
Let's suppose that Valera will set v seconds TL in the problem. Then we can say that a solution passes the system testing if its running time is at most v seconds. We can also say that a solution passes the system testing with some "extra" time if for its running time, a seconds, an inequality 2a ≤ v holds.
As a result, Valera decided to set v seconds TL, that the following conditions are met:
1. v is a positive integer;
2. all correct solutions pass the system testing;
3. at least one correct solution passes the system testing with some "extra" time;
4. all wrong solutions do not pass the system testing;
5. value v is minimum among all TLs, for which points 1, 2, 3, 4 hold.
Help Valera and find the most suitable TL or else state that such TL doesn't exist.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 100). The second line contains n space-separated positive integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the running time of each of the n correct solutions in seconds. The third line contains m space-separated positive integers b1, b2, ..., bm (1 ≤ bi ≤ 100) — the running time of each of m wrong solutions in seconds.
Output
If there is a valid TL value, print it. Otherwise, print -1.
Examples
Input
3 6
4 5 2
8 9 6 10 7 11
Output
5
Input
3 1
3 4 5
6
Output
-1
|
m, n = map(int, input().split())
a = sorted([int(x) for x in input().split()])
b = sorted([int(x) for x in input().split()])
for i in range(100):
if (i >= a[-1] and i < b[0] and i >= 2 * a[0]):
print(i)
break
else:
print(-1)
|
Inna loves digit 9 very much. That's why she asked Dima to write a small number consisting of nines. But Dima must have misunderstood her and he wrote a very large number a, consisting of digits from 1 to 9.
Inna wants to slightly alter the number Dima wrote so that in the end the number contained as many digits nine as possible. In one move, Inna can choose two adjacent digits in a number which sum equals 9 and replace them by a single digit 9.
For instance, Inna can alter number 14545181 like this: 14545181 → 1945181 → 194519 → 19919. Also, she can use this method to transform number 14545181 into number 19991. Inna will not transform it into 149591 as she can get numbers 19919 and 19991 which contain more digits nine.
Dima is a programmer so he wants to find out how many distinct numbers containing as many digits nine as possible Inna can get from the written number. Help him with this challenging task.
Input
The first line of the input contains integer a (1 ≤ a ≤ 10100000). Number a doesn't have any zeroes.
Output
In a single line print a single integer — the answer to the problem. It is guaranteed that the answer to the problem doesn't exceed 263 - 1.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
369727
Output
2
Input
123456789987654321
Output
1
Input
1
Output
1
Note
Notes to the samples
In the first sample Inna can get the following numbers: 369727 → 99727 → 9997, 369727 → 99727 → 9979.
In the second sample, Inna can act like this: 123456789987654321 → 12396789987654321 → 1239678998769321.
|
import java.util.Scanner;
public class Main2 {
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
long counter = 1;
int count = 1;
int sum = Character.digit(s.charAt(0), 10);
for(int i = 1 ; i < s.length() ; i++){
sum += Character.digit(s.charAt(i), 10);
if(sum == 9){
count++;
}else{
if(count % 2 == 1){
counter *= (count+1)/2;
}
count = 1;
}
sum = Character.digit(s.charAt(i), 10);
}
if(count % 2 == 1){
counter *= (count+1)/2;
}
System.out.println(counter);
}
}
|
You are given a permutation p. Calculate the total number of inversions in all permutations that lexicographically do not exceed the given one.
As this number can be very large, print it modulo 1000000007 (109 + 7).
Input
The first line contains a single integer n (1 ≤ n ≤ 106) — the length of the permutation. The second line contains n distinct integers p1, p2, ..., pn (1 ≤ pi ≤ n).
Output
Print a single number — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
2
2 1
Output
1
Input
3
2 1 3
Output
2
Note
Permutation p of length n is the sequence that consists of n distinct integers, each of them is from 1 to n.
An inversion of permutation p1, p2, ..., pn is a pair of indexes (i, j), such that i < j and pi > pj.
Permutation a do not exceed permutation b lexicographically, if either a = b or there exists such number i, for which the following logical condition fulfills: <image> AND (ai < bi).
|
#include <bits/stdc++.h>
using namespace std;
long long f[1000005], b[1000005], bit[1000005], _n, _len;
void update(long long i, long long val) {
while (i <= _n) {
bit[i] += val;
i += (i & (-i));
}
}
long long query(long long i) {
long long sum = 0;
while (i > 0) {
sum += bit[i];
i -= (i & (-i));
}
return sum;
}
int main() {
long long i, j, k, p, q, m, n, c, sm;
while (cin >> n) {
for (_n = n, f[0] = 1, b[0] = 0, i = 1; i <= n; i++) {
update(i, 1);
f[i] = (f[i - 1] * i) % 1000000007LL;
b[i] = ((b[i - 1] * i) % 1000000007LL +
(((i * (i - 1)) / 2) % 1000000007LL * f[i - 1]) % 1000000007LL) %
1000000007LL;
}
for (sm = 0, p = 0, i = 1, j = n - 1; i <= n; i++, j--) {
cin >> q;
k = query(q - 1);
sm = (sm + k * b[j] + (k * (k - 1) / 2 + p * k) % 1000000007LL * f[j]) %
1000000007LL;
p = (p + k) % 1000000007LL;
update(q, -1);
}
cout << (sm + p) % 1000000007LL << endl;
}
return 0;
}
|
In order to ensure confidentiality, the access to the "Russian Code Cup" problems is password protected during the problem development process.
To select a password, the jury can generate a special table that contains n columns and the infinite number of rows. To construct a table, the first row is fixed, and all the others are obtained by the following rule:
In the row i at position p there is a number equal to the number of times a[i - 1][p] occurs on the prefix a[i - 1][1... p].
To ensure the required level of confidentiality, the jury must be able to perform the following operations:
* Replace number a[1][p] by v and rebuild the table.
* Find the number a[x][y], which will be the new password.
Doing all these steps manually is very tedious, so the jury asks you to help him. Write a program that responds to the request of the jury.
Input
The first line contains an integer n (1 ≤ n ≤ 100000) — the number of columns. The second line contains the description of the first row of the table, that is, n integers, which are not less than 1 and do not exceed 109.
The third line of the input contains an integer m (1 ≤ m ≤ 100000) — the number of requests.
Next, each row contains a description of the request, which consists of three integers:
* If the first number is equal to 1, then the remaining two numbers are v, p (1 ≤ v ≤ 109; 1 ≤ p ≤ n). So, you should put value v in the position p in the first row.
* If the first number is equal to 2, then the remaining two numbers are x, y (1 ≤ x ≤ 105; 1 ≤ y ≤ n) — the row and column of the table cell from which you want to get value.
Output
Print an answer for each request of the second type in the order you receive them.
Examples
Input
6
1 2 2 2 3 1
3
2 2 3
1 3 3
2 3 4
Output
2
1
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int M = 105;
struct Query {
int k, x, y;
inline void input() {
scanf("%d %d %d", &k, &x, &y);
y--;
}
} query[N];
int n, q, value[N], a[N], m = 0;
int cnt[M][N];
int prefix[M][N];
int sum[M][N];
int temp[N];
inline int lowbit(int x) { return x & (-x); }
inline void add(int *s, int pos, int val) {
if (pos == 0) return;
for (int i = pos; i <= n; i += lowbit(i)) {
s[i] += val;
}
}
inline int ask(int *s, int pos) {
int ret = 0;
for (int i = pos; i > 0; i -= lowbit(i)) {
ret += s[i];
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
value[m++] = a[i];
}
scanf("%d", &q);
for (int i = 0; i < q; i++) {
query[i].input();
if (query[i].k == 1) value[m++] = query[i].x;
}
sort(value, value + m);
m = unique(value, value + m) - value;
for (int i = 0; i < n; i++) {
a[i] = lower_bound(value, value + m, a[i]) - value + 1;
}
for (int i = 0; i < q; i++) {
if (query[i].k == 1)
query[i].x = lower_bound(value, value + m, query[i].x) - value + 1;
}
int BLOCK = min((int)sqrt(n * 1.0 + 1e-8), 100),
LEN = (n + BLOCK - 1) / BLOCK;
for (int i = 0; i < n; i++) {
int ID = i / LEN;
prefix[ID][a[i]]++;
}
for (int j = 1; j <= m; j++) {
for (int i = 1; i < BLOCK; i++) {
prefix[i][j] += prefix[i - 1][j];
}
}
for (int i = 0; i < BLOCK; i++) {
for (int j = 1; j <= m; j++) {
add(sum[i], prefix[i][j], 1);
}
}
for (int i = 0; i < q; i++) {
if (query[i].k == 1) {
int ID = query[i].y / LEN;
for (int j = ID; j < BLOCK; j++) {
add(sum[j], prefix[j][a[query[i].y]], -1);
prefix[j][a[query[i].y]]--;
add(sum[j], prefix[j][a[query[i].y]], 1);
}
a[query[i].y] = query[i].x;
for (int j = ID; j < BLOCK; j++) {
add(sum[j], prefix[j][a[query[i].y]], -1);
prefix[j][a[query[i].y]]++;
add(sum[j], prefix[j][a[query[i].y]], 1);
}
} else {
int ID = query[i].y / LEN,
firstanswer = ID == 0 ? 0 : prefix[ID - 1][a[query[i].y]];
for (int j = ID * LEN; j <= query[i].y; j++) {
firstanswer += (a[query[i].y] == a[j]);
}
int secondanswer = 0;
for (int j = ID * LEN; j <= query[i].y; j++) {
temp[a[j]] = (ID == 0 ? 0 : prefix[ID - 1][a[j]]);
}
for (int j = ID * LEN; j <= query[i].y; j++) {
temp[a[j]]++;
if (temp[a[j]] == firstanswer) secondanswer++;
}
if (ID)
secondanswer += ask(sum[ID - 1], n) - ask(sum[ID - 1], firstanswer - 1);
if (query[i].x == 1) {
printf("%d\n", value[a[query[i].y] - 1]);
} else {
if (query[i].x & 1) {
printf("%d\n", secondanswer);
} else
printf("%d\n", firstanswer);
}
}
}
return 0;
}
|
DZY loves Physics, and he enjoys calculating density.
Almost everything has density, even a graph. We define the density of a non-directed graph (nodes and edges of the graph have some values) as follows:
<image> where v is the sum of the values of the nodes, e is the sum of the values of the edges.
Once DZY got a graph G, now he wants to find a connected induced subgraph G' of the graph, such that the density of G' is as large as possible.
An induced subgraph G'(V', E') of a graph G(V, E) is a graph that satisfies:
* <image>;
* edge <image> if and only if <image>, and edge <image>;
* the value of an edge in G' is the same as the value of the corresponding edge in G, so as the value of a node.
Help DZY to find the induced subgraph with maximum density. Note that the induced subgraph you choose must be connected.
<image>
Input
The first line contains two space-separated integers n (1 ≤ n ≤ 500), <image>. Integer n represents the number of nodes of the graph G, m represents the number of edges.
The second line contains n space-separated integers xi (1 ≤ xi ≤ 106), where xi represents the value of the i-th node. Consider the graph nodes are numbered from 1 to n.
Each of the next m lines contains three space-separated integers ai, bi, ci (1 ≤ ai < bi ≤ n; 1 ≤ ci ≤ 103), denoting an edge between node ai and bi with value ci. The graph won't contain multiple edges.
Output
Output a real number denoting the answer, with an absolute or relative error of at most 10 - 9.
Examples
Input
1 0
1
Output
0.000000000000000
Input
2 1
1 2
1 2 1
Output
3.000000000000000
Input
5 6
13 56 73 98 17
1 2 56
1 3 29
1 4 42
2 3 95
2 4 88
3 4 63
Output
2.965517241379311
Note
In the first sample, you can only choose an empty subgraph, or the subgraph containing only node 1.
In the second sample, choosing the whole graph is optimal.
|
#include <bits/stdc++.h>
using namespace std;
int vis[1000], q[1000], node[1000], n, a[1000][1000], m;
long double ans = 0;
void solve(int u) {
int l = 0, r = 1;
q[r] = u;
int to = 0;
long double maxn = 0;
for (int i = 1; i <= n; i++)
if (a[i][u]) {
if ((double)(node[u] + node[i] * 1.0) / (double)a[i][u] > maxn) {
to = i;
maxn = (double)(node[u] + node[i] * 1.0) / (double)a[i][u];
}
}
if (!to) return;
long double sumv = node[u] + node[to];
long double sume = a[u][to];
vis[u] = 1;
vis[to] = 1;
while (l < r) {
int t = q[++l];
long double now = 0;
int tag;
long double nowv, nowe;
for (int i = 1; i <= n; i++)
if (!vis[i] && a[t][i]) {
long double tmpv = sumv + node[i];
long double tmpe = sume + a[t][i];
for (int j = 1; j <= n; j++)
if (vis[j] && a[i][j]) tmpe += a[i][j];
if (tmpv / tmpe > now) {
now = tmpv / tmpe;
nowv = tmpv;
nowe = tmpe;
tag = i;
}
}
if (now > sumv / sume - 0.0000000001) {
sumv = nowv;
sume = nowe;
vis[tag] = 1;
q[++r] = tag;
}
}
if (sumv / sume > ans) ans = sumv / sume;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &node[i]);
int flg = 0;
int x, y, w;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &w);
a[x][y] = a[y][x] = w;
if (w > 0) flg = 1;
}
if (!flg) {
printf("%0.15lf\n", 0);
return 0;
}
for (int i = 1; i <= n; i++) {
memset(vis, 0, sizeof vis);
solve(i);
}
double tans = (double)ans;
printf("%0.12lf\n", tans);
return 0;
}
|
After you had helped Fedor to find friends in the «Call of Soldiers 3» game, he stopped studying completely. Today, the English teacher told him to prepare an essay. Fedor didn't want to prepare the essay, so he asked Alex for help. Alex came to help and wrote the essay for Fedor. But Fedor didn't like the essay at all. Now Fedor is going to change the essay using the synonym dictionary of the English language.
Fedor does not want to change the meaning of the essay. So the only change he would do: change a word from essay to one of its synonyms, basing on a replacement rule from the dictionary. Fedor may perform this operation any number of times.
As a result, Fedor wants to get an essay which contains as little letters «R» (the case doesn't matter) as possible. If there are multiple essays with minimum number of «R»s he wants to get the one with minimum length (length of essay is the sum of the lengths of all the words in it). Help Fedor get the required essay.
Please note that in this problem the case of letters doesn't matter. For example, if the synonym dictionary says that word cat can be replaced with word DOG, then it is allowed to replace the word Cat with the word doG.
Input
The first line contains a single integer m (1 ≤ m ≤ 105) — the number of words in the initial essay. The second line contains words of the essay. The words are separated by a single space. It is guaranteed that the total length of the words won't exceed 105 characters.
The next line contains a single integer n (0 ≤ n ≤ 105) — the number of pairs of words in synonym dictionary. The i-th of the next n lines contains two space-separated non-empty words xi and yi. They mean that word xi can be replaced with word yi (but not vise versa). It is guaranteed that the total length of all pairs of synonyms doesn't exceed 5·105 characters.
All the words at input can only consist of uppercase and lowercase letters of the English alphabet.
Output
Print two integers — the minimum number of letters «R» in an optimal essay and the minimum length of an optimal essay.
Examples
Input
3
AbRb r Zz
4
xR abRb
aA xr
zz Z
xr y
Output
2 6
Input
2
RuruRu fedya
1
ruruRU fedor
Output
1 10
|
from sys import stdin
from collections import defaultdict
def main():
stdin.readline()
num = {}
stat = lambda word: (word.count('r'),
len(word), num.setdefault(word, len(num)))
essay = list(map(stat, stdin.readline().lower().split()))
queue = []
for word in essay:
queue.append(word)
n_synonym = int(stdin.readline())
synonym = defaultdict(list)
for i in range(n_synonym):
word, rep = map(stat, stdin.readline().lower().split())
synonym[rep[2]].append(word[2])
queue.append(rep)
queue.sort(reverse=True)
best = {}
while queue:
n_r, length, word = queue.pop()
if word in best:
continue
best[word] = n_r, length
for rep in synonym[word]:
if rep not in best:
queue.append((n_r, length, rep))
sum_n_r, sum_len = 0, 0
for n_r, length, word in essay:
n_r, length = best[word]
sum_n_r += n_r
sum_len += length
print(sum_n_r, sum_len)
if __name__ == '__main__':
main()
|
In a far away galaxy there are n inhabited planets numbered with numbers from 1 to n. One day the presidents of all the n planets independently from each other came up with an idea of creating the Galaxy Union. Now they need to share this wonderful idea with their galaxymates, that’s why each president is busy working out a project of negotiating with the other presidents.
For negotiations between some pairs of the planets there are bidirectional communication channels, each of which is characterized with "dial duration" ti which, as a rule, takes several hours and exceeds the call duration greatly. Overall the galaxy has n communication channels and they unite all the planets into a uniform network. That means that it is possible to phone to any planet v from any planet u, perhaps, using some transitional planets v1, v2, ..., vm via the existing channels between u and v1, v1 and v2, ..., vm - 1 and vm, vm and v. At that the dial duration from u to v will be equal to the sum of dial durations of the used channels.
So, every president has to talk one by one to the presidents of all the rest n - 1 planets. At that the negotiations take place strictly consecutively, and until the negotiations with a planet stop, the dial to another one does not begin. As the matter is urgent, from the different ways to call the needed planet every time the quickest one is chosen. Little time is needed to assure another president on the importance of the Galaxy Union, that’s why the duration of the negotiations with each planet can be considered equal to the dial duration time for those planets. As the presidents know nothing about each other’s plans, they do not take into consideration the possibility that, for example, the sought president may call himself or already know about the founding of the Galaxy Union from other sources.
The governments of all the n planets asked you to work out the negotiation plans. First you are to find out for every president how much time his supposed negotiations will take.
Input
The first line contains an integer n (3 ≤ n ≤ 200000) which represents the number of planets in the Galaxy and the number of communication channels equal to it. The next n lines contain three integers each ai, bi and ti (1 ≤ ai, bi ≤ n, ai ≠ bi, 1 ≤ ti ≤ 103) that represent the numbers of planet joined by a communication channel and its "dial duration". There can be no more than one communication channel between a pair of planets.
Output
In the first line output n integers — the durations of the supposed negotiations for each president. Separate the numbers by spaces.
Examples
Input
3
1 2 3
2 3 2
1 3 1
Output
4 5 3
Input
3
1 2 3
2 3 2
1 3 5
Output
8 5 7
Input
4
1 2 3
2 3 2
3 4 1
4 1 4
Output
12 8 8 8
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
bool debug = false;
int W;
struct root {
int id;
long long edge, ss;
vector<int> subNodes;
};
vector<pair<int, long long>> mp[200005];
vector<root> rs;
int v[200005];
int cpoint[200005];
long long sumNode[200005], countNode[200005], dd[200005],
toOtherFromFAther[200005], ans[200005];
root *rr;
int findCircle(int i, int p) {
if (v[i]) return i;
v[i] = 1;
for (vector<pair<int, long long>>::iterator it = mp[i].begin();
it != mp[i].end(); it++) {
int w = it->first;
if (w == p) continue;
int t = findCircle(w, i);
if (t != -1) {
cpoint[w] = 1;
root r;
r.id = w;
r.edge = it->second;
rs.push_back(r);
return t == i ? -1 : t;
}
}
return -1;
}
void dfs(int i, int p) {
rr->subNodes.push_back(i);
sumNode[i] = 0;
countNode[i] = 1;
for (vector<pair<int, long long>>::iterator it = mp[i].begin();
it != mp[i].end(); it++) {
int w = it->first;
if (w == p || cpoint[w]) continue;
dd[w] += dd[i] + it->second;
dfs(w, i);
countNode[i] += countNode[w];
sumNode[i] += sumNode[w] + it->second * countNode[w];
}
}
void dfs1(int i, int p) {
for (vector<pair<int, long long>>::iterator it = mp[i].begin();
it != mp[i].end(); it++) {
int w = it->first;
if (w == p || cpoint[w]) continue;
toOtherFromFAther[w] = toOtherFromFAther[i] + sumNode[i] - sumNode[w] -
it->second * countNode[w] +
it->second * (countNode[rr->id] - countNode[w]);
dfs1(w, i);
}
}
void calTree(int i) {
rr = &rs[i];
dd[rr->id] = 0;
dfs(rr->id, -1);
toOtherFromFAther[rr->id] = 0;
dfs1(rr->id, -1);
for (vector<int>::iterator it = rr->subNodes.begin();
it != rr->subNodes.end(); it++) {
ans[*it] = sumNode[*it] + toOtherFromFAther[*it];
}
rr->ss = ans[rr->id];
}
void calCircle() {
long long cursum = 0, cnt = 0, cirlen = 0, sum = 0;
int q = 0;
long long ee[200005 + 200005];
for (int i = 0; i < m; i++) {
cirlen += rs[i].edge;
sum += rs[i].ss;
ee[i + 1 + m] = ee[i + 1] = rs[i].edge;
}
ee[0] = 0;
partial_sum(ee, ee + m + m + 1, ee);
while (2 * (ee[q] - ee[0]) <= cirlen) {
cursum += (ee[q] - ee[0]) * countNode[rs[q].id];
cnt += countNode[rs[q].id];
q++;
}
for (int i = q; i < m; i++) {
cursum += (cirlen - (ee[i] - ee[0])) * countNode[rs[i].id];
}
for (int i = 0; i < m; i++) {
while (2 * (ee[q] - ee[i]) <= cirlen) {
cursum = cursum - (cirlen - (ee[q] - ee[i])) * countNode[rs[q % m].id] +
(ee[q] - ee[i]) * countNode[rs[q % m].id];
cnt += countNode[rs[q % m].id];
q++;
}
for (vector<int>::iterator it = rs[i].subNodes.begin();
it != rs[i].subNodes.end(); it++) {
ans[*it] += sum - rs[i].ss + cursum + dd[*it] * (n - countNode[rs[i].id]);
}
cnt -= countNode[rs[i].id];
cursum += (n - cnt) * rs[i].edge;
cursum -= cnt * rs[i].edge;
}
}
int main() {
scanf("%d", &n);
int a, b, t;
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &a, &b, &t);
a--;
b--;
mp[a].push_back(make_pair(b, t));
mp[b].push_back(make_pair(a, t));
}
findCircle(0, -1);
m = (int)rs.size();
for (int i = 0; i < m; i++) {
calTree(i);
}
calCircle();
for (int i = 0; i < n; i++) {
printf("%I64d ", ans[i]);
}
return 0;
}
|
You are given a permutation of n numbers p1, p2, ..., pn. We perform k operations of the following type: choose uniformly at random two indices l and r (l ≤ r) and reverse the order of the elements pl, pl + 1, ..., pr. Your task is to find the expected value of the number of inversions in the resulting permutation.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 100, 1 ≤ k ≤ 109). The next line contains n integers p1, p2, ..., pn — the given permutation. All pi are different and in range from 1 to n.
The problem consists of three subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem G1 (3 points), the constraints 1 ≤ n ≤ 6, 1 ≤ k ≤ 4 will hold.
* In subproblem G2 (5 points), the constraints 1 ≤ n ≤ 30, 1 ≤ k ≤ 200 will hold.
* In subproblem G3 (16 points), the constraints 1 ≤ n ≤ 100, 1 ≤ k ≤ 109 will hold.
Output
Output the answer with absolute or relative error no more than 1e - 9.
Examples
Input
3 1
1 2 3
Output
0.833333333333333
Input
3 4
1 3 2
Output
1.458333333333334
Note
Consider the first sample test. We will randomly pick an interval of the permutation (1, 2, 3) (which has no inversions) and reverse the order of its elements. With probability <image>, the interval will consist of a single element and the permutation will not be altered. With probability <image> we will inverse the first two elements' order and obtain the permutation (2, 1, 3) which has one inversion. With the same probability we might pick the interval consisting of the last two elements which will lead to the permutation (1, 3, 2) with one inversion. Finally, with probability <image> the randomly picked interval will contain all elements, leading to the permutation (3, 2, 1) with 3 inversions. Hence, the expected number of inversions is equal to <image>.
|
#include <bits/stdc++.h>
using namespace std;
int const maxn = 35;
int const maxk = 205;
int p[maxn];
double ans[maxn][maxn][maxk];
int to(int x, int l, int r) {
if (x < l || x > r) return x;
return l + r - x;
}
double solve(int n, int i, int j, int k) {
if (k == 0) {
if (p[i] > p[j])
return 1.0;
else
return 0.0;
}
if (ans[i][j][k] >= 0) return ans[i][j][k];
double koef = 2.0 / (n * (n + 1));
double ret = 0.0;
for (int l = 1; l <= n; ++l)
for (int r = l; r <= n; ++r) {
ret += koef * solve(n, to(i, l, r), to(j, l, r), k - 1);
}
ans[i][j][k] = ret;
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(10);
for (int i = 0; i < (int)(maxn); ++i)
for (int j = 0; j < (int)(maxn); ++j)
for (int k = 0; k < (int)(maxk); ++k) ans[i][j][k] = -1.0;
int n, k;
cin >> n >> k;
for (int i = 0; i < (int)(n); ++i) cin >> p[i + 1];
double ans = 0.0;
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j) ans += solve(n, i, j, k);
cout << ans << endl;
return 0;
}
|
Life in Bertown has become hard. The city has too many roads and the government spends too much to maintain them. There are n junctions and m two way roads, at which one can get from each junction to any other one. The mayor wants to close some roads so that the number of roads left totaled to n - 1 roads and it were still possible to get from each junction to any other one. Besides, the mayor is concerned with the number of dead ends which are the junctions from which only one road goes. There shouldn't be too many or too few junctions. Having discussed the problem, the mayor and his assistants decided that after the roads are closed, the road map should contain exactly k dead ends. Your task is to count the number of different ways of closing the roads at which the following conditions are met:
* There are exactly n - 1 roads left.
* It is possible to get from each junction to any other one.
* There are exactly k dead ends on the resulting map.
Two ways are considered different if there is a road that is closed in the first way, and is open in the second one.
Input
The first line contains three integers n, m and k (3 ≤ n ≤ 10, n - 1 ≤ m ≤ n·(n - 1) / 2, 2 ≤ k ≤ n - 1) which represent the number of junctions, roads and dead ends correspondingly. Then follow m lines each containing two different integers v1 and v2 (1 ≤ v1, v2 ≤ n, v1 ≠ v2) which represent the number of junctions connected by another road. There can be no more than one road between every pair of junctions. The junctions are numbered with integers from 1 to n. It is guaranteed that it is possible to get from each junction to any other one along the original roads.
Output
Print a single number — the required number of ways.
Examples
Input
3 3 2
1 2
2 3
1 3
Output
3
Input
4 6 2
1 2
2 3
3 4
4 1
1 3
2 4
Output
12
Input
4 6 3
1 2
2 3
3 4
4 1
1 3
2 4
Output
4
|
#include <bits/stdc++.h>
using namespace std;
int dp[1 << 10][1 << 10];
int use[1 << 10][1 << 10];
int g[10][10];
struct node {
int s1, s2;
};
queue<node> q;
int n, m, k;
int p1[20], p2[20];
void bfs() {
memset(use, 0, sizeof(use));
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
if (g[i][j] == 0) continue;
node tmp;
tmp.s1 = tmp.s2 = 0;
tmp.s1 |= (1 << i);
tmp.s1 |= (1 << j);
tmp.s2 = tmp.s1;
q.push(tmp);
use[tmp.s1][tmp.s2] = 1;
dp[tmp.s1][tmp.s2] = 1;
}
while (!q.empty()) {
node hh = q.front();
q.pop();
for (int i = 0; i < n; i++) {
if (!(hh.s1 & (1 << i))) continue;
for (int j = 0; j < n; j++) {
if (g[i][j] == 0) continue;
if (hh.s1 & (1 << j)) continue;
int ns1 = hh.s1, ns2 = hh.s2;
ns1 |= (1 << j);
if (ns2 & (1 << i)) ns2 -= (1 << i);
ns2 |= (1 << j);
if (ns2 & ((1 << j) - 1)) continue;
dp[ns1][ns2] += dp[hh.s1][hh.s2];
if (!use[ns1][ns2]) {
use[ns1][ns2] = 1;
node tmp;
tmp.s1 = ns1;
tmp.s2 = ns2;
q.push(tmp);
}
}
}
}
}
int main() {
while (scanf("%d%d%d", &n, &m, &k) == 3) {
memset(g, 0, sizeof(g));
memset(dp, 0, sizeof(dp));
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
g[u][v] = g[v][u] = 1;
}
bfs();
int ans = 0;
for (int i = 0; i < (1 << n); i++) {
int cntt = 0, num = i;
for (; num != 0; cntt += num % 2, num /= 2)
;
if (cntt == k) ans += dp[(1 << n) - 1][i];
}
printf("%d\n", ans);
}
return 0;
}
|
Rikhail Mubinchik believes that the current definition of prime numbers is obsolete as they are too complex and unpredictable. A palindromic number is another matter. It is aesthetically pleasing, and it has a number of remarkable properties. Help Rikhail to convince the scientific community in this!
Let us remind you that a number is called prime if it is integer larger than one, and is not divisible by any positive integer other than itself and one.
Rikhail calls a number a palindromic if it is integer, positive, and its decimal representation without leading zeros is a palindrome, i.e. reads the same from left to right and right to left.
One problem with prime numbers is that there are too many of them. Let's introduce the following notation: π(n) — the number of primes no larger than n, rub(n) — the number of palindromic numbers no larger than n. Rikhail wants to prove that there are a lot more primes than palindromic ones.
He asked you to solve the following problem: for a given value of the coefficient A find the maximum n, such that π(n) ≤ A·rub(n).
Input
The input consists of two positive integers p, q, the numerator and denominator of the fraction that is the value of A (<image>, <image>).
Output
If such maximum number exists, then print it. Otherwise, print "Palindromic tree is better than splay tree" (without the quotes).
Examples
Input
1 1
Output
40
Input
1 42
Output
1
Input
6 4
Output
172
|
#include <bits/stdc++.h>
using namespace std;
int p, q;
int rev(int x) {
int ret = 0;
while (x) {
ret *= 10;
ret += x % 10;
x /= 10;
}
return ret;
}
bool vis[4000000 + 10];
void init() {
vis[1] = 1;
for (int i = 2; i <= 4000000; i++)
if (!vis[i])
for (int j = i + i; j <= 4000000; j += i) vis[j] = 1;
}
int main() {
int ans = -1;
int A = 0, B = 0;
scanf("%d%d", &p, &q);
init();
for (int i = 1; i <= 4000000; i++) {
if (i == rev(i)) B++;
if (!vis[i]) A++;
if (q * (long long)A <= p * (long long)B) ans = i;
}
if (ans == -1)
puts("Palindromic tree is better than splay tree");
else
printf("%d", ans);
}
|
Welcoming autumn evening is the best for walking along the boulevard and n people decided to do so.
The boulevard can be represented as the axis Ox. For every person there are three parameters characterizing the behavior: ti, si, fi — the moment of time when the i-th person starts walking, the start point and the end point of the walk respectively. Each person moves in a straight line along the boulevard from si to fi with a constant speed of either 1 or - 1 depending on the direction.
When the i-th person appears on the boulevard at the point si she immediately starts walking towards the point fi.
If two or more persons meet at the boulevard (they are at the same point at the same time, no matter which directions they are going) they all greet each other. Like in the normal life, every pair of people greet each other at most once.
You task is to calculate for every person how many people she greets while walking along the boulevard.
Please, pay attention to the fact that i-th person may meet and greet any other person at points si and fi. After a person achieves the destination point fi she moves out of the boulevard and cannot greet anyone else. The same rule applies to the start of the walk: a person cannot greet anyone until she appears on the boulevard.
Input
In the first line there is an integer n (2 ≤ n ≤ 1000) — the number of people who decided to go for a walk.
The following n lines contain parameters for n people. In the i-th line there are three positive integers ti, si, fi (1 ≤ ti, si, fi ≤ 10^6, si ≠ fi), where ti, si, fi — the moment of time when the i-th person starts walking, the start point and the end point of the walk respectively.
Output
The single line of the output should contain a sequence of n integers r1, r2, ..., rn separated by a space, where ri denotes the number which the i-th person greets other people while walking along the boulevard.
Examples
Input
3
1 1 10
5 8 2
9 9 10
Output
2 1 1
Input
3
3 2 4
4 3 4
3 6 4
Output
2 2 2
|
n = input()
lines = [map(int, raw_input().split()) for i in xrange(n)]
def greets(id1, id2):
if id1 == id2:
return False
t1, s1, f1 = lines[id1]
t2, s2, f2 = lines[id2]
d1 = (f1>s1) - (f1<s1)
d2 = (f2>s2) - (f2<s2)
l1 = abs(f1-s1)
l2 = abs(f2-s2)
# one direction
if d1==d2:
if (s1-t1*d1)!=(s2-t2*d2):
return False
else:
s1 *= d1
s2 *= d2
f1 *= d1
f2 *= d2
return not (((s1<s2) and (f1<s2)) or ((s1>s2) and (s1>f2)))
# two directions
if (s1-s2) * (d2-d1) < 0:
return False
else:
x = float((s1-s2) + (t2*d2-t1*d1)) / (d2-d1)
return (x>=t1) and (x>=t2) and (x<=t1+l1) and (x<=t2+l2)
ans = [sum([greets(i, j) for j in xrange(n)]) for i in xrange(n)]
print " ".join(map(str, ans))
|
Today is Wednesday, the third day of the week. What's more interesting is that tomorrow is the last day of the year 2015.
Limak is a little polar bear. He enjoyed this year a lot. Now, he is so eager to the coming year 2016.
Limak wants to prove how responsible a bear he is. He is going to regularly save candies for the entire year 2016! He considers various saving plans. He can save one candy either on some fixed day of the week or on some fixed day of the month.
Limak chose one particular plan. He isn't sure how many candies he will save in the 2016 with his plan. Please, calculate it and tell him.
Input
The only line of the input is in one of the following two formats:
* "x of week" where x (1 ≤ x ≤ 7) denotes the day of the week. The 1-st day is Monday and the 7-th one is Sunday.
* "x of month" where x (1 ≤ x ≤ 31) denotes the day of the month.
Output
Print one integer — the number of candies Limak will save in the year 2016.
Examples
Input
4 of week
Output
52
Input
30 of month
Output
11
Note
Polar bears use the Gregorian calendar. It is the most common calendar and you likely use it too. You can read about it on Wikipedia if you want to – <https://en.wikipedia.org/wiki/Gregorian_calendar>. The week starts with Monday.
In the first sample Limak wants to save one candy on each Thursday (the 4-th day of the week). There are 52 Thursdays in the 2016. Thus, he will save 52 candies in total.
In the second sample Limak wants to save one candy on the 30-th day of each month. There is the 30-th day in exactly 11 months in the 2016 — all months but February. It means that Limak will save 11 candies in total.
|
s=input().split()
l1=[52,52,52,52,53,53,52]
l2=[31,29,31,30,31,30,31,31,30,31,30,31]
count=0
if s[2]=="month":
x=int(s[0])
for i in range(len(l2)):
if x<=l2[i]:
count+=1
print(count)
else:
for i in range(len(l1)):
if int(s[0])==i+1:
print(l1[i])
break
|
It was decided in IT City to distinguish successes of local IT companies by awards in the form of stars covered with gold from one side. To order the stars it is necessary to estimate order cost that depends on the area of gold-plating. Write a program that can calculate the area of a star.
A "star" figure having n ≥ 5 corners where n is a prime number is constructed the following way. On the circle of radius r n points are selected so that the distances between the adjacent ones are equal. Then every point is connected by a segment with two maximally distant points. All areas bounded by the segments parts are the figure parts.
<image>
Input
The only line of the input contains two integers n (5 ≤ n < 109, n is prime) and r (1 ≤ r ≤ 109) — the number of the star corners and the radius of the circumcircle correspondingly.
Output
Output one number — the star area. The relative error of your answer should not be greater than 10 - 7.
Examples
Input
7 10
Output
108.395919545675
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, r, s, ans;
cin >> n >> r;
double a = atan(1) * 2 / n;
ans = r * r * n * sin(2 * a) * sin(a) / sin((n * 2 - 3) * a);
printf("%.10f\n", ans);
return 0;
}
|
A long time ago (probably even in the first book), Nicholas Flamel, a great alchemist and the creator of the Philosopher's Stone, taught Harry Potter three useful spells. The first one allows you to convert a grams of sand into b grams of lead, the second one allows you to convert c grams of lead into d grams of gold and third one allows you to convert e grams of gold into f grams of sand. When Harry told his friends about these spells, Ron Weasley was amazed. After all, if they succeed in turning sand into lead, lead into gold, and then turning part of the gold into sand again and so on, then it will be possible to start with a small amount of sand and get huge amounts of gold! Even an infinite amount of gold! Hermione Granger, by contrast, was skeptical about that idea. She argues that according to the law of conservation of matter getting an infinite amount of matter, even using magic, is impossible. On the contrary, the amount of matter may even decrease during transformation, being converted to magical energy. Though Hermione's theory seems convincing, Ron won't believe her. As far as Ron is concerned, Hermione made up her law of conservation of matter to stop Harry and Ron wasting their time with this nonsense, and to make them go and do homework instead. That's why Ron has already collected a certain amount of sand for the experiments. A quarrel between the friends seems unavoidable...
Help Harry to determine which one of his friends is right, and avoid the quarrel after all. To do this you have to figure out whether it is possible to get the amount of gold greater than any preassigned number from some finite amount of sand.
Input
The first line contains 6 integers a, b, c, d, e, f (0 ≤ a, b, c, d, e, f ≤ 1000).
Output
Print "Ron", if it is possible to get an infinitely large amount of gold having a certain finite amount of sand (and not having any gold and lead at all), i.e., Ron is right. Otherwise, print "Hermione".
Examples
Input
100 200 250 150 200 250
Output
Ron
Input
100 50 50 200 200 100
Output
Hermione
Input
100 10 200 20 300 30
Output
Hermione
Input
0 0 0 0 0 0
Output
Hermione
Input
1 1 0 1 1 1
Output
Ron
Input
1 0 1 2 1 2
Output
Hermione
Input
100 1 100 1 0 1
Output
Ron
Note
Consider the first sample. Let's start with the 500 grams of sand. Apply the first spell 5 times and turn the sand into 1000 grams of lead. Then apply the second spell 4 times to get 600 grams of gold. Let’s take 400 grams from the resulting amount of gold turn them back into sand. We get 500 grams of sand and 200 grams of gold. If we apply the same operations to 500 grams of sand again, we can get extra 200 grams of gold every time. Thus, you can get 200, 400, 600 etc. grams of gold, i.e., starting with a finite amount of sand (500 grams), you can get the amount of gold which is greater than any preassigned number.
In the forth sample it is impossible to get sand, or lead, or gold, applying the spells.
In the fifth sample an infinitely large amount of gold can be obtained by using only the second spell, which allows you to receive 1 gram of gold out of nothing. Note that if such a second spell is available, then the first and the third one do not affect the answer at all.
The seventh sample is more interesting. We can also start with a zero amount of sand there. With the aid of the third spell you can get sand out of nothing. We get 10000 grams of sand in this manner. Let's get 100 grams of lead using the first spell 100 times. Then make 1 gram of gold from them. We managed to receive 1 gram of gold, starting with a zero amount of sand! Clearly, in this manner you can get an infinitely large amount of gold.
|
import java.util.*;
public class A
{
public static void main(String[] args)
{
new A(new Scanner(System.in));
}
public A(Scanner in)
{
Fract one = new Fract(1L, 1L);
boolean passed = false;
Fract cur = one;
Fract[] vs = new Fract[3];
for (int i=0; i<3; i++)
{
long a = in.nextLong();
long b = in.nextLong();
Fract u = new Fract(b, a);
vs[i] = u;
if (i == 1)
{
if ((a == 0)&&(b > 0))
{
passed = true;
}
if ((cur.numer == 987654321)&&(b > 0))
{
passed = true;
}
}
cur = cur.mult(u);
if ((a == 0)&&(b > 0))
cur = new Fract(987654321, 1);
}
cur = one;
for (int i=0; i<3; i++)
{
int j = (i+2)%3;
cur = cur.mult(vs[j]);
}
String res = "Ron";
if (cur.compareTo(one) <= 0)
res = "Hermione";
if (passed)
res = "Ron";
System.out.println(res);
}
}
class Fract
{
long numer, denom;
public Fract(long n, long d)
{
numer = n;
denom = d;
}
public int compareTo(Fract rhs)
{
long n1 = numer*rhs.denom;
long n2 = rhs.numer*denom;
return new Long(n1).compareTo(new Long(n2));
}
Fract mult(Fract rhs)
{
long n1 = numer*rhs.numer;
long d1 = denom*rhs.denom;
return new Fract(n1, d1);
}
public String toString()
{
return numer+"/"+denom;
}
}
|
You are given n points with integer coordinates on the plane. Points are given in a way such that there is no triangle, formed by any three of these n points, which area exceeds S.
Alyona tried to construct a triangle with integer coordinates, which contains all n points and which area doesn't exceed 4S, but, by obvious reason, had no success in that. Please help Alyona construct such triangle. Please note that vertices of resulting triangle are not necessarily chosen from n given points.
Input
In the first line of the input two integers n and S (3 ≤ n ≤ 5000, 1 ≤ S ≤ 1018) are given — the number of points given and the upper bound value of any triangle's area, formed by any three of given n points.
The next n lines describes given points: ith of them consists of two integers xi and yi ( - 108 ≤ xi, yi ≤ 108) — coordinates of ith point.
It is guaranteed that there is at least one triple of points not lying on the same line.
Output
Print the coordinates of three points — vertices of a triangle which contains all n points and which area doesn't exceed 4S.
Coordinates of every triangle's vertex should be printed on a separate line, every coordinate pair should be separated by a single space. Coordinates should be an integers not exceeding 109 by absolute value.
It is guaranteed that there is at least one desired triangle. If there is more than one answer, print any of them.
Example
Input
4 1
0 0
1 0
0 1
1 1
Output
-1 0
2 0
0 2
Note
<image>
|
#include <bits/stdc++.h>
using namespace std;
struct tocka {
long long int x, y;
bool operator<(const tocka &p) const {
if (x == p.x) return y < p.y;
return x < p.x;
}
};
vector<tocka> v, gornji, donji, convex;
long long int ccw(tocka a, tocka b, tocka c) {
return (a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y));
}
int main() {
long long int n, s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
tocka t;
scanf("%I64d%I64d", &t.x, &t.y);
v.push_back(t);
}
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
while (gornji.size() >= 2 &&
ccw(gornji[gornji.size() - 1], gornji[gornji.size() - 2], v[i]) < 0)
gornji.pop_back();
gornji.push_back(v[i]);
}
for (int i = n - 1; i >= 0; i--) {
while (donji.size() >= 2 &&
ccw(donji[donji.size() - 1], donji[donji.size() - 2], v[i]) < 0)
donji.pop_back();
donji.push_back(v[i]);
}
for (int i = 0; i < gornji.size() - 1; i++) convex.push_back(gornji[i]);
for (int i = 0; i < donji.size() - 1; i++) convex.push_back(donji[i]);
int i = 0, j = 1, k = 2;
int l = convex.size();
for (int x = 0; x < 3 * n; x++) {
while (abs(ccw(convex[i], convex[j], convex[k])) <
abs(ccw(convex[i], convex[j], convex[(k + 1) % l])))
k = (k + 1) % l;
while (abs(ccw(convex[i], convex[j], convex[k])) <
abs(ccw(convex[i], convex[(j + 1) % l], convex[k])))
j = (j + 1) % l;
while (abs(ccw(convex[i], convex[j], convex[k])) <
abs(ccw(convex[(i + 1) % l], convex[j], convex[k])))
i = (i + 1) % l;
}
for (int x = 0; x < 3 * n; x++) {
while (abs(ccw(convex[i], convex[j], convex[k])) <
abs(ccw(convex[i], convex[j], convex[(k - 1 + l) % l])))
k = (k - 1 + l) % l;
while (abs(ccw(convex[i], convex[j], convex[k])) <
abs(ccw(convex[i], convex[(j - 1 + l) % l], convex[k])))
j = (j - 1 + l) % l;
while (abs(ccw(convex[i], convex[j], convex[k])) <
abs(ccw(convex[(i - 1 + l) % l], convex[j], convex[k])))
i = (i - 1 + l) % l;
}
cout << convex[i].x + (convex[j].x - convex[k].x) << " "
<< convex[i].y + (convex[j].y - convex[k].y) << endl;
cout << convex[j].x + (convex[k].x - convex[i].x) << " "
<< convex[j].y + (convex[k].y - convex[i].y) << endl;
cout << convex[k].x + (convex[i].x - convex[j].x) << " "
<< convex[k].y + (convex[i].y - convex[j].y) << endl;
return 0;
}
|
Scott Lang is at war with Darren Cross. There are n chairs in a hall where they are, numbered with 1, 2, ..., n from left to right. The i-th chair is located at coordinate xi. Scott is on chair number s and Cross is on chair number e. Scott can jump to all other chairs (not only neighboring chairs). He wants to start at his position (chair number s), visit each chair exactly once and end up on chair number e with Cross.
As we all know, Scott can shrink or grow big (grow big only to his normal size), so at any moment of time he can be either small or large (normal). The thing is, he can only shrink or grow big while being on a chair (not in the air while jumping to another chair). Jumping takes time, but shrinking and growing big takes no time. Jumping from chair number i to chair number j takes |xi - xj| seconds. Also, jumping off a chair and landing on a chair takes extra amount of time.
If Scott wants to jump to a chair on his left, he can only be small, and if he wants to jump to a chair on his right he should be large.
Jumping off the i-th chair takes:
* ci extra seconds if he's small.
* di extra seconds otherwise (he's large).
Also, landing on i-th chair takes:
* bi extra seconds if he's small.
* ai extra seconds otherwise (he's large).
In simpler words, jumping from i-th chair to j-th chair takes exactly:
* |xi - xj| + ci + bj seconds if j < i.
* |xi - xj| + di + aj seconds otherwise (j > i).
Given values of x, a, b, c, d find the minimum time Scott can get to Cross, assuming he wants to visit each chair exactly once.
Input
The first line of the input contains three integers n, s and e (2 ≤ n ≤ 5000, 1 ≤ s, e ≤ n, s ≠ e) — the total number of chairs, starting and ending positions of Scott.
The second line contains n integers x1, x2, ..., xn (1 ≤ x1 < x2 < ... < xn ≤ 109).
The third line contains n integers a1, a2, ..., an (1 ≤ a1, a2, ..., an ≤ 109).
The fourth line contains n integers b1, b2, ..., bn (1 ≤ b1, b2, ..., bn ≤ 109).
The fifth line contains n integers c1, c2, ..., cn (1 ≤ c1, c2, ..., cn ≤ 109).
The sixth line contains n integers d1, d2, ..., dn (1 ≤ d1, d2, ..., dn ≤ 109).
Output
Print the minimum amount of time Scott needs to get to the Cross while visiting each chair exactly once.
Example
Input
7 4 3
8 11 12 16 17 18 20
17 16 20 2 20 5 13
17 8 8 16 12 15 13
12 4 16 4 15 7 6
8 14 2 11 17 12 8
Output
139
Note
In the sample testcase, an optimal solution would be <image>. Spent time would be 17 + 24 + 23 + 20 + 33 + 22 = 139.
|
#include <bits/stdc++.h>
using namespace std;
int X[5010], A[5010], B[5010], C[5010], D[5010];
long long f[5010][5010];
long long _Min(long long x, long long y) { return x < y ? x : y; }
int main() {
int n, sp, tp, i, j;
scanf("%d%d%d", &n, &sp, &tp);
for (i = 1; i <= n; i++) scanf("%d", &X[i]);
for (i = 1; i <= n; i++) scanf("%d", &C[i]);
for (i = 1; i <= n; i++) scanf("%d", &D[i]);
for (i = 1; i <= n; i++) scanf("%d", &A[i]);
for (i = 1; i <= n; i++) scanf("%d", &B[i]);
if (sp > tp) {
int t = sp;
sp = tp;
tp = t;
for (i = 1; i <= n; i++) {
t = A[i];
A[i] = C[i];
C[i] = t;
t = B[i];
B[i] = D[i];
D[i] = t;
}
}
memset(f, 63, sizeof(f));
f[0][0] = 0;
for (i = 1; i < sp; i++) {
for (j = 0; j <= n; j++) {
if (j > 0 && (j > 1 || i == 1))
f[i][j] = _Min(f[i][j], f[i - 1][j - 1] - 2 * X[i] + B[i] + D[i]);
f[i][j] = _Min(f[i][j], f[i - 1][j + 1] + 2 * X[i] + A[i] + C[i]);
if (j > 0 || i == 1) f[i][j] = _Min(f[i][j], f[i - 1][j] + A[i] + D[i]);
if (j > 0 || i == 1) f[i][j] = _Min(f[i][j], f[i - 1][j] + B[i] + C[i]);
}
}
for (i = 1; i <= n; i++) {
if (i > 1 || sp == 1)
f[sp][i] = _Min(f[sp][i], f[sp - 1][i - 1] - X[sp] + B[sp]);
f[sp][i] = _Min(f[sp][i], f[sp - 1][i] + X[sp] + A[sp]);
}
for (i = sp + 1; i < tp; i++) {
for (j = 1; j <= n; j++) {
if (j > 1)
f[i][j] = _Min(f[i][j], f[i - 1][j - 1] - 2 * X[i] + B[i] + D[i]);
f[i][j] = _Min(f[i][j], f[i - 1][j + 1] + 2 * X[i] + A[i] + C[i]);
if (j > 1) f[i][j] = _Min(f[i][j], f[i - 1][j] + A[i] + D[i]);
f[i][j] = _Min(f[i][j], f[i - 1][j] + B[i] + C[i]);
}
}
for (i = 0; i <= n; i++) {
if (i > 0) f[tp][i] = _Min(f[tp][i], f[tp - 1][i] - X[tp] + D[tp]);
f[tp][i] = _Min(f[tp][i], f[tp - 1][i + 1] + X[tp] + C[tp]);
}
for (i = tp + 1; i <= n; i++) {
for (j = 0; j <= n; j++) {
if (j > 1)
f[i][j] = _Min(f[i][j], f[i - 1][j - 1] - 2 * X[i] + B[i] + D[i]);
f[i][j] = _Min(f[i][j], f[i - 1][j + 1] + 2 * X[i] + A[i] + C[i]);
if (j > 0) f[i][j] = _Min(f[i][j], f[i - 1][j] + A[i] + D[i]);
if (j > 0) f[i][j] = _Min(f[i][j], f[i - 1][j] + B[i] + C[i]);
}
}
printf("%I64d\n", f[n][0]);
return 0;
}
|
Polycarp has interviewed Oleg and has written the interview down without punctuation marks and spaces to save time. Thus, the interview is now a string s consisting of n lowercase English letters.
There is a filler word ogo in Oleg's speech. All words that can be obtained from ogo by adding go several times to the end of it are also considered to be fillers. For example, the words ogo, ogogo, ogogogo are fillers, but the words go, og, ogog, ogogog and oggo are not fillers.
The fillers have maximal size, for example, for ogogoo speech we can't consider ogo a filler and goo as a normal phrase. We should consider ogogo as a filler here.
To print the interview, Polycarp has to replace each of the fillers with three asterisks. Note that a filler word is replaced with exactly three asterisks regardless of its length.
Polycarp has dealt with this problem in no time. Can you do the same? The clock is ticking!
Input
The first line contains a positive integer n (1 ≤ n ≤ 100) — the length of the interview.
The second line contains the string s of length n, consisting of lowercase English letters.
Output
Print the interview text after the replacement of each of the fillers with "***". It is allowed for the substring "***" to have several consecutive occurences.
Examples
Input
7
aogogob
Output
a***b
Input
13
ogogmgogogogo
Output
***gmg***
Input
9
ogoogoogo
Output
*********
Note
The first sample contains one filler word ogogo, so the interview for printing is "a***b".
The second sample contains two fillers ogo and ogogogo. Thus, the interview is transformed to "***gmg***".
|
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class TC2A {
public static void main(String[] args) {
FastScanner in = new FastScanner();
in.nextInt();
String line = in.nextToken();
while (line.contains("ogo")) {
int l = line.indexOf("ogo");
if (l < 0) break;
int r = l+3;
for (int i = r; i < line.length(); i = i+2) {
if (i+2 > line.length()) break;
if (line.substring(i, i+2).equals("go")) {
r += 2;
continue;
}
break;
}
line = line.substring(0, l) + "***" + line.substring(r, line.length());
}
System.out.println(line);
}
public static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner(String s) {
try {
br = new BufferedReader(new FileReader(s));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public FastScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String nextToken() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(nextToken());
}
long nextLong() {
return Long.parseLong(nextToken());
}
double nextDouble() {
return Double.parseDouble(nextToken());
}
}
}
|
Long time ago Alex created an interesting problem about parallelogram. The input data for this problem contained four integer points on the Cartesian plane, that defined the set of vertices of some non-degenerate (positive area) parallelogram. Points not necessary were given in the order of clockwise or counterclockwise traversal.
Alex had very nice test for this problem, but is somehow happened that the last line of the input was lost and now he has only three out of four points of the original parallelogram. He remembers that test was so good that he asks you to restore it given only these three points.
Input
The input consists of three lines, each containing a pair of integer coordinates xi and yi ( - 1000 ≤ xi, yi ≤ 1000). It's guaranteed that these three points do not lie on the same line and no two of them coincide.
Output
First print integer k — the number of ways to add one new integer point such that the obtained set defines some parallelogram of positive area. There is no requirement for the points to be arranged in any special order (like traversal), they just define the set of vertices.
Then print k lines, each containing a pair of integer — possible coordinates of the fourth point.
Example
Input
0 0
1 0
0 1
Output
3
1 -1
-1 1
1 1
Note
If you need clarification of what parallelogram is, please check Wikipedia page:
https://en.wikipedia.org/wiki/Parallelogram
|
import java.util.*;
import java.io.*;
public class B {
public static void main(String[] args) throws Exception {
BufferedReader bi = new BufferedReader(new InputStreamReader(System.in));
String input;
StringTokenizer tok;
int x1, x2, x3, y1, y2, y3;
input = bi.readLine();
tok = new StringTokenizer(input);
x1 = Integer.parseInt(tok.nextToken());
y1 = Integer.parseInt(tok.nextToken());
input = bi.readLine();
tok = new StringTokenizer(input);
x2 = Integer.parseInt(tok.nextToken());
y2 = Integer.parseInt(tok.nextToken());
input = bi.readLine();
tok = new StringTokenizer(input);
x3 = Integer.parseInt(tok.nextToken());
y3 = Integer.parseInt(tok.nextToken());
solve(x1, y1, x2, y2, x3, y3);
}
static void solve(int x1, int y1, int x2, int y2, int x3, int y3) {
System.out.println(3); // Always ??
// Consider 1 as centre.
// Sides 1-2 and 1-3.
// Next point is 2 + (1-3) or equivalently 3 + (1-2)
int x4 = x2 + x3 - x1;
int y4 = y2 + y3 - y1;
System.out.println(x4 + " " + y4);
// Consider 2 as centre.
// Sides 2-3 and 1-3.
// Next point is 3 + (2-1) or equivalently 1 + (2-3)
int x5 = x3 + x1 - x2;
int y5 = y3 + y1 - y2;
System.out.println(x5 + " " + y5);
// Similarly with 3 as centre.
int x6 = x2 + x1 - x3;
int y6 = y2 + y1 - y3;
System.out.println(x6 + " " + y6);
}
}
|
You have n devices that you want to use simultaneously.
The i-th device uses ai units of power per second. This usage is continuous. That is, in λ seconds, the device will use λ·ai units of power. The i-th device currently has bi units of power stored. All devices can store an arbitrary amount of power.
You have a single charger that can plug to any single device. The charger will add p units of power per second to a device. This charging is continuous. That is, if you plug in a device for λ seconds, it will gain λ·p units of power. You can switch which device is charging at any arbitrary unit of time (including real numbers), and the time it takes to switch is negligible.
You are wondering, what is the maximum amount of time you can use the devices until one of them hits 0 units of power.
If you can use the devices indefinitely, print -1. Otherwise, print the maximum amount of time before any one device hits 0 power.
Input
The first line contains two integers, n and p (1 ≤ n ≤ 100 000, 1 ≤ p ≤ 109) — the number of devices and the power of the charger.
This is followed by n lines which contain two integers each. Line i contains the integers ai and bi (1 ≤ ai, bi ≤ 100 000) — the power of the device and the amount of power stored in the device in the beginning.
Output
If you can use the devices indefinitely, print -1. Otherwise, print the maximum amount of time before any one device hits 0 power.
Your answer will be considered correct if its absolute or relative error does not exceed 10 - 4.
Namely, let's assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
2 1
2 2
2 1000
Output
2.0000000000
Input
1 100
1 1
Output
-1
Input
3 5
4 3
5 2
6 1
Output
0.5000000000
Note
In sample test 1, you can charge the first device for the entire time until it hits zero power. The second device has enough power to last this time without being charged.
In sample test 2, you can use the device indefinitely.
In sample test 3, we can charge the third device for 2 / 5 of a second, then switch to charge the second device for a 1 / 10 of a second.
|
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;
/*
*
* Comments Here
*
*/
public class C69_fixed
{
static BufferedReader br;
static BufferedWriter bw;
static StringTokenizer st;
public static void main(String[] args) throws java.lang.Exception
{
br = new BufferedReader(new InputStreamReader(System.in));
bw = new BufferedWriter(new OutputStreamWriter(System.out));
//Uncomment to read from file
/*/
File file = new File("src/in.txt");
try {
in = new Scanner(file);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
/**/
st = new StringTokenizer(br.readLine());
int n = Integer.parseInt(st.nextToken());
long p = Long.parseLong(st.nextToken());
long[] as = new long[n];
long[] bs = new long[n];
long aSum = 0;
long bSum = 0;
double tmin = Long.MAX_VALUE;
double tmax = 10e10+10;
for(int i = 0; i < n; ++i) {
st = new StringTokenizer(br.readLine());
as[i] = Long.parseLong(st.nextToken());
bs[i] = Long.parseLong(st.nextToken());
aSum += as[i];
bSum += bs[i];
tmin = Math.min(tmin, (bs[i]*1.0)/as[i]);
}
if(aSum <= p) {
System.out.println("-1");
return;
}
tmin = 0;
tmax = 1L << 34;
while((tmax-tmin)/Math.max(1.0, tmin) > 10e-9) {
double tmid = (tmax+tmin)/2;
long aSumPart = 0;
long bSumPart = 0;
for(int i = 0; i < bs.length; ++i) {
if(as[i]*tmid - bs[i] > 0) {
aSumPart += as[i];
bSumPart += bs[i];
}
}
if(tmid*(aSumPart-p) >= bSumPart) {
tmax = tmid;
} else {
tmin = tmid;
}
}
System.out.println((tmax+tmin)/2);
br.close();
bw.close();
}
}
|
Given a positive integer n, find k integers (not necessary distinct) such that all these integers are strictly greater than 1, and their product is equal to n.
Input
The first line contains two integers n and k (2 ≤ n ≤ 100000, 1 ≤ k ≤ 20).
Output
If it's impossible to find the representation of n as a product of k numbers, print -1.
Otherwise, print k integers in any order. Their product must be equal to n. If there are multiple answers, print any of them.
Examples
Input
100000 2
Output
2 50000
Input
100000 20
Output
-1
Input
1024 5
Output
2 64 2 2 2
|
#!/usr/bin/env python
from math import sqrt
dic = {}
def kfact(n, k):
if (n, k) in dic:
return dic[(n, k)]
if k == 1:
return [n]
for i in range(2, int(sqrt(n)) + 1):
if n % i == 0:
if kfact(n // i, k - 1):
result = [i] + kfact(n // i, k - 1)
dic[(n, k)] = result
return result
return None
def wrapper(n, k):
r = kfact(n, k)
if r:
print(' '.join(map(str, r)))
else:
print(-1)
if __name__ == "__main__":
n, k = map(int, input().split())
wrapper(n, k)
|
Ivan likes to learn different things about numbers, but he is especially interested in really big numbers. Ivan thinks that a positive integer number x is really big if the difference between x and the sum of its digits (in decimal representation) is not less than s. To prove that these numbers may have different special properties, he wants to know how rare (or not rare) they are — in fact, he needs to calculate the quantity of really big numbers that are not greater than n.
Ivan tried to do the calculations himself, but soon realized that it's too difficult for him. So he asked you to help him in calculations.
Input
The first (and the only) line contains two integers n and s (1 ≤ n, s ≤ 1018).
Output
Print one integer — the quantity of really big numbers that are not greater than n.
Examples
Input
12 1
Output
3
Input
25 20
Output
0
Input
10 9
Output
1
Note
In the first example numbers 10, 11 and 12 are really big.
In the second example there are no really big numbers that are not greater than 25 (in fact, the first really big number is 30: 30 - 3 ≥ 20).
In the third example 10 is the only really big number (10 - 1 ≥ 9).
|
#include <bits/stdc++.h>
using namespace std;
priority_queue<long long int, vector<long long int>, greater<long long int> > t;
vector<long long int> p[200005], s(5000005, 0), d(5000005, 0);
map<pair<long long int, long long int>, long long int> mp;
set<pair<long long int, long long int> > q;
long long int mxn = 200005;
long long int n, m, k;
map<long long int, long long int> v;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int bpow(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return res % 1000000007;
}
long long int fact(long long int n) {
if (n == 0) return 1;
return n * fact(n - 1);
}
long long int isprime(long long int n) {
for (long long int i = 2; i <= sqrt(n); i++)
if (n % i == 0) return 0;
return 1;
}
void prime() {
for (long long int i = 2; i <= 5000000; i++) {
if (s[i] == 0) {
for (long long int j = 2; i * j <= 5000000; j++) {
s[i * j] = 1;
}
}
}
}
bool pal(long long int i) {
long long int j = i, c = 0, d = 0;
while (j > 0) {
c++;
j /= 10;
}
for (long long int j = 1; j <= c / 2; j++) {
d *= 10;
d += i % 10;
i /= 10;
}
if (c & 1) i /= 10;
return (i == d);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, s;
cin >> n >> s;
long long int i = 0, j = 0, sum = 0, c = 0;
for (i = s; i <= n; i++) {
j = i;
sum = 0;
while (j > 0) {
sum += j % 10;
j /= 10;
}
if ((i - sum) >= s) break;
}
cout << (n - i + 1) * ((n - i + 1) > 0) << "\n";
}
|
Ilya is very fond of graphs, especially trees. During his last trip to the forest Ilya found a very interesting tree rooted at vertex 1. There is an integer number written on each vertex of the tree; the number written on vertex i is equal to ai.
Ilya believes that the beauty of the vertex x is the greatest common divisor of all numbers written on the vertices on the path from the root to x, including this vertex itself. In addition, Ilya can change the number in one arbitrary vertex to 0 or leave all vertices unchanged. Now for each vertex Ilya wants to know the maximum possible beauty it can have.
For each vertex the answer must be considered independently.
The beauty of the root equals to number written on it.
Input
First line contains one integer number n — the number of vertices in tree (1 ≤ n ≤ 2·105).
Next line contains n integer numbers ai (1 ≤ i ≤ n, 1 ≤ ai ≤ 2·105).
Each of next n - 1 lines contains two integer numbers x and y (1 ≤ x, y ≤ n, x ≠ y), which means that there is an edge (x, y) in the tree.
Output
Output n numbers separated by spaces, where i-th number equals to maximum possible beauty of vertex i.
Examples
Input
2
6 2
1 2
Output
6 6
Input
3
6 2 3
1 2
1 3
Output
6 6 6
Input
1
10
Output
10
|
import java.util.*;
import java.io.*;
public class c implements Runnable {
static PrintWriter out;
static int[] arr;
static int n;
static ArrayList<Integer>[] adjs;
static int[] ans;
static int count = 100;
public void main() throws Throwable {
FastScanner in = new FastScanner(System.in);
out = new PrintWriter(System.out);
n = in.nextInt();
arr = in.nextIntArr(n);
adjs = new ArrayList[n];
ans = new int[n];
for (int i = 0; i < n; i++) {
adjs[i] = new ArrayList<>();
}
for (int i = 0; i < n - 1; i++) {
int a = in.nextInt() - 1;
int b = in.nextInt() - 1;
adjs[a].add(b);
adjs[b].add(a);
}
TreeSet<Integer> ts = new TreeSet<>();
go(0, -1, 0, ts);
out.print(arr[0]);
for (int i = 1; i < n; i++)
out.print(" " + ans[i]);
out.println();
out.close();
}
void go(int cur, int par, int g, TreeSet<Integer> ts) {
TreeSet<Integer> ts2 = new TreeSet<>();
for (int a : ts) {
ts2.add(gcd(a, arr[cur]));
}
int gg = gcd(g, arr[cur]);
ts2.add(g);
ans[cur] = Math.max(gg, ts2.last());
for (int next : adjs[cur]) {
if (next == par) continue;
go(next, cur, gg, ts2);
}
}
public int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
public static void main(String[] args) throws Exception {
new Thread(null, new c(), "c", 1L << 29).start();
}
public void run() {
try {
main();
} catch (Throwable t) {
t.printStackTrace();
System.exit(-1);
}
}
static void sort(int[] arr) {
Random rand = new Random();
int n = arr.length;
for (int i = 0; i < n; i++) {
int j = rand.nextInt(n);
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
Arrays.sort(arr);
}
static void sort(long[] arr) {
Random rand = new Random();
int n = arr.length;
for (int i = 0; i < n; i++) {
int j = rand.nextInt(n);
long tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
Arrays.sort(arr);
}
static void sort(double[] arr) {
Random rand = new Random();
int n = arr.length;
for (int i = 0; i < n; i++) {
int j = rand.nextInt(n);
double tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
Arrays.sort(arr);
}
static class FastScanner {
BufferedReader br; StringTokenizer st;
public FastScanner(InputStream i) {
br = new BufferedReader(new InputStreamReader(i));
st = new StringTokenizer("");
}
public String next() throws Exception {
while (!st.hasMoreTokens()) {
st = new StringTokenizer(br.readLine());
}
return st.nextToken();
}
public int nextInt() throws Exception {
return Integer.parseInt(next());
}
public double nextDouble() throws Exception {
return Double.parseDouble(next());
}
public long nextLong() throws Exception {
return Long.parseLong(next());
}
public int[] nextIntArr(int n) throws Exception {
int[] arr = new int[n];
for (int i = 0; i < n; i++) arr[i] = nextInt();
return arr;
}
public double[] nextDoubleArr(int n) throws Exception {
double[] arr = new double[n];
for (int i = 0; i < n; i++) arr[i] = nextDouble();
return arr;
}
public long[] nextLongArr(int n) throws Exception {
long[] arr = new long[n];
for (int i = 0; i < n; i++) arr[i] = nextLong();
return arr;
}
public int[] nextOffsetIntArr(int n) throws Exception {
int[] arr = new int[n];
for (int i = 0; i < n; i++) arr[i] = nextInt() - 1;
return arr;
}
public int[][] nextIntArr(int n, int m) throws Exception {
int[][] arr = new int[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
arr[i][j] = nextInt();
return arr;
}
public double[][] nextDoubleArr(int n, int m) throws Exception {
double[][] arr = new double[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
arr[i][j] = nextDouble();
return arr;
}
public long[][] nextLongArr(int n, int m) throws Exception {
long[][] arr = new long[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
arr[i][j] = nextLong();
return arr;
}
}
}
|
Ilya is working for the company that constructs robots. Ilya writes programs for entertainment robots, and his current project is "Bob", a new-generation game robot. Ilya's boss wants to know his progress so far. Especially he is interested if Bob is better at playing different games than the previous model, "Alice".
So now Ilya wants to compare his robots' performance in a simple game called "1-2-3". This game is similar to the "Rock-Paper-Scissors" game: both robots secretly choose a number from the set {1, 2, 3} and say it at the same moment. If both robots choose the same number, then it's a draw and noone gets any points. But if chosen numbers are different, then one of the robots gets a point: 3 beats 2, 2 beats 1 and 1 beats 3.
Both robots' programs make them choose their numbers in such a way that their choice in (i + 1)-th game depends only on the numbers chosen by them in i-th game.
Ilya knows that the robots will play k games, Alice will choose number a in the first game, and Bob will choose b in the first game. He also knows both robots' programs and can tell what each robot will choose depending on their choices in previous game. Ilya doesn't want to wait until robots play all k games, so he asks you to predict the number of points they will have after the final game.
Input
The first line contains three numbers k, a, b (1 ≤ k ≤ 1018, 1 ≤ a, b ≤ 3).
Then 3 lines follow, i-th of them containing 3 numbers Ai, 1, Ai, 2, Ai, 3, where Ai, j represents Alice's choice in the game if Alice chose i in previous game and Bob chose j (1 ≤ Ai, j ≤ 3).
Then 3 lines follow, i-th of them containing 3 numbers Bi, 1, Bi, 2, Bi, 3, where Bi, j represents Bob's choice in the game if Alice chose i in previous game and Bob chose j (1 ≤ Bi, j ≤ 3).
Output
Print two numbers. First of them has to be equal to the number of points Alice will have, and second of them must be Bob's score after k games.
Examples
Input
10 2 1
1 1 1
1 1 1
1 1 1
2 2 2
2 2 2
2 2 2
Output
1 9
Input
8 1 1
2 2 1
3 3 1
3 1 3
1 1 1
2 1 1
1 2 3
Output
5 2
Input
5 1 1
1 2 2
2 2 2
2 2 2
1 2 2
2 2 2
2 2 2
Output
0 0
Note
In the second example game goes like this:
<image>
The fourth and the seventh game are won by Bob, the first game is draw and the rest are won by Alice.
|
import java.awt.*;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.*;
public class OneTwoThree
{
public static void main(String[] args)
{
new OneTwoThree(System.in, System.out);
}
private static class Solver implements Runnable
{
long k;
int a, b, startLevel, aliceWinsInCycle, bobWinsInCycle;
int[][] choiceA, choiceB, wins;
boolean[][] vis;
boolean foundStart, endsBeforeCycle;
// BufferedReader in;
InputReader in;
PrintWriter out;
void solve() throws IOException
{
k = in.nextLong();
a = in.nextInt() - 1;
b = in.nextInt() - 1;
choiceA = new int[3][3];
choiceB = new int[3][3];
wins = new int[11][2]; // max. cycle size possible is 9, storing wins for both Alice and Bob at each
// level.
vis = new boolean[3][3];
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
choiceA[i][j] = in.nextInt() - 1;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
choiceB[i][j] = in.nextInt() - 1;
Point point = new Point(-1, -1);
int cycleSize = getCycleSize(a, b, point, 1, k);
/* System.out.println("wins :");
for (int i = 1; i < 10; i++)
System.out.println(Arrays.toString(wins[i]));*/
if (endsBeforeCycle)
out.println(wins[(int) k][0] + " " + wins[(int) k][1]);
else
{
long aliceWins = wins[startLevel - 1][0];
long bobWins = wins[startLevel - 1][1];
aliceWinsInCycle -= wins[startLevel][0];
bobWinsInCycle -= wins[startLevel][1];
k -= (startLevel - 1);
long times = k / cycleSize;
int remaining = (int) (k % cycleSize);
aliceWins += times * aliceWinsInCycle;
bobWins += times * bobWinsInCycle;
if (remaining > 0)
{
aliceWins += (wins[startLevel + remaining - 1][0] - wins[startLevel - 1][0]);
bobWins += (wins[startLevel + remaining - 1][1] - wins[startLevel - 1][1]);
}
out.println(aliceWins + " " + bobWins);
}
}
boolean doesAliceWin(int a, int b)
{
return (a == 2 && b == 1) || (a == 1 && b == 0) || (a == 0 && b == 2);
}
int getCycleSize(int x, int y, Point point, int level, long gamesRemaining)
{
// System.out.println("x : " + x + ", y : " + y + ", level : " + level + ", gamesRemaining : " + gamesRemaining);
wins[level][0] = wins[level - 1][0];
wins[level][1] = wins[level - 1][1];
if (x != y && doesAliceWin(x, y))
wins[level][0]++;
else if (x != y)
wins[level][1]++;
if (vis[x][y])
{
point.x = x;
point.y = y;
aliceWinsInCycle = wins[level][0];
bobWinsInCycle = wins[level][1];
return 1;
}
vis[x][y] = true;
if (gamesRemaining == 1)
{
endsBeforeCycle = true;
return 0;
}
int xx = getCycleSize(choiceA[x][y], choiceB[x][y], point, level + 1, gamesRemaining - 1);
if (point.x == x && point.y == y)
{
startLevel = level;
foundStart = true;
}
if (foundStart)
return xx;
return xx + 1;
}
// uncomment below line to change to BufferedReader
// public Solver(BufferedReader in, PrintWriter out)
Solver(InputReader in, PrintWriter out)
{
this.in = in;
this.out = out;
}
@Override
public void run()
{
try
{
solve();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
private static class InputReader
{
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
int read()
{
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars)
{
curChar = 0;
try
{
numChars = stream.read(buf);
}
catch (IOException e)
{
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
int nextInt()
{
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = read();
}
int res = 0;
do
{
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c & 15;
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
long nextLong()
{
int c = read();
while (isSpaceChar(c))
c = read();
int sign = 1;
if (c == '-')
{
sign = -1;
c = read();
}
long result = 0;
do
{
if (c < '0' || c > '9')
throw new InputMismatchException();
result *= 10;
result += c & 15;
c = read();
} while (!isSpaceChar(c));
return result * sign;
}
boolean isSpaceChar(int c)
{
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
void close()
{
try
{
stream.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
InputReader(InputStream stream)
{
this.stream = stream;
}
}
private OneTwoThree(InputStream inputStream, OutputStream outputStream)
{
// uncomment below line to change to BufferedReader
// BufferedReader in = new BufferedReader(new
// InputStreamReader(inputStream));
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
Thread thread = new Thread(null, new Solver(in, out), "Solver", 1 << 29);
thread.start();
try
{
thread.join();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
in.close();
out.flush();
out.close();
}
}
|
You are given a complete undirected graph with n vertices. A number ai is assigned to each vertex, and the weight of an edge between vertices i and j is equal to ai xor aj.
Calculate the weight of the minimum spanning tree in this graph.
Input
The first line contains n (1 ≤ n ≤ 200000) — the number of vertices in the graph.
The second line contains n integers a1, a2, ..., an (0 ≤ ai < 230) — the numbers assigned to the vertices.
Output
Print one number — the weight of the minimum spanning tree in the graph.
Examples
Input
5
1 2 3 4 5
Output
8
Input
4
1 2 3 4
Output
8
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int MOD = 1e9 + 7;
const double eps = 1e-8;
const double Pi = acos(-1.0);
const double E = exp(1.0);
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return x * f;
}
template <typename T>
inline T _gcd(T a, T b) {
return (b == 0) ? a : _gcd(b, a % b);
}
template <typename T>
inline T _lcm(T a, T b) {
return a / _gcd(a, b) * b;
}
long long int qmod(long long int a, long long int b, long long int c) {
long long int ret = 1ll;
while (b) {
if (b & 1) ret = ret * a % c;
b >>= 1, a = a * a % c;
}
return ret;
}
int trie[N * 40][3], sum[N * 40], val[N * 40], to[N * 40], cnt, weishu = 30 - 1;
long long int ans, tot, ta, tt;
inline void insert(int x) {
int now = 0;
for (int i = weishu, bt; i >= 0; i--) {
bt = 1 - (0 == (x & (1 << i)));
if (!trie[now][bt]) trie[now][bt] = ++cnt;
now = trie[now][bt];
sum[now]++;
}
val[now] = x;
}
inline int query(int x, int pre) {
int now = 0;
for (int i = weishu, bt; i >= 0; i--) {
bt = 1 - (0 == (x & (1 << i)));
if (!trie[now][bt]) bt = 1 - bt;
if (now == pre) bt = 1 - bt;
now = trie[now][bt];
}
return now;
}
void dfs2(int x, int &pre) {
if (trie[x][0]) dfs2(trie[x][0], pre);
if (trie[x][1]) dfs2(trie[x][1], pre);
if (!trie[x][0] && !trie[x][1]) {
int now = query(val[x], pre);
if (ta == (val[now] ^ val[x])) {
tt = (tt + 1ll * sum[now] * sum[x] % MOD) % MOD;
}
if (ta > (val[now] ^ val[x])) {
ta = (val[now] ^ val[x]);
tt = (1ll * sum[now] * sum[x]) % MOD;
}
}
}
void dfs(int x) {
if (trie[x][0]) dfs(trie[x][0]);
if (trie[x][1]) dfs(trie[x][1]);
if (trie[x][0] && trie[x][1]) {
ta = (~(1 << 31)), tt = 0;
if (to[trie[x][1]] < to[trie[x][0]])
dfs2(trie[x][1], x);
else
dfs2(trie[x][0], x);
ans += ta;
tot = tot * tt % MOD;
} else if (!trie[x][0] && !trie[x][1] && sum[x] > 1)
tot = tot * qmod(1ll * sum[x], 1ll * sum[x] - 2, 1ll * MOD) % MOD;
}
int dfs1(int x) {
if (!trie[x][0] && !trie[x][1]) return to[x] = 1;
if (trie[x][0]) to[x] += dfs1(trie[x][0]);
if (trie[x][1]) to[x] += dfs1(trie[x][1]);
return to[x];
}
int main() {
int n;
scanf("%d", &n);
cnt = 0;
ans = 0ll, tot = 1ll;
for (int i = 1, x; i <= n; i++) {
x = read();
insert(x);
}
dfs1(0);
dfs(0);
printf("%lld\n", ans);
return 0;
}
|
Let's suppose you have an array a, a stack s (initially empty) and an array b (also initially empty).
You may perform the following operations until both a and s are empty:
* Take the first element of a, push it into s and remove it from a (if a is not empty);
* Take the top element from s, append it to the end of array b and remove it from s (if s is not empty).
You can perform these operations in arbitrary order.
If there exists a way to perform the operations such that array b is sorted in non-descending order in the end, then array a is called stack-sortable.
For example, [3, 1, 2] is stack-sortable, because b will be sorted if we perform the following operations:
1. Remove 3 from a and push it into s;
2. Remove 1 from a and push it into s;
3. Remove 1 from s and append it to the end of b;
4. Remove 2 from a and push it into s;
5. Remove 2 from s and append it to the end of b;
6. Remove 3 from s and append it to the end of b.
After all these operations b = [1, 2, 3], so [3, 1, 2] is stack-sortable. [2, 3, 1] is not stack-sortable.
You are given k first elements of some permutation p of size n (recall that a permutation of size n is an array of size n where each integer from 1 to n occurs exactly once). You have to restore the remaining n - k elements of this permutation so it is stack-sortable. If there are multiple answers, choose the answer such that p is lexicographically maximal (an array q is lexicographically greater than an array p iff there exists some integer k such that for every i < k qi = pi, and qk > pk). You may not swap or change any of first k elements of the permutation.
Print the lexicographically maximal permutation p you can obtain.
If there exists no answer then output -1.
Input
The first line contains two integers n and k (2 ≤ n ≤ 200000, 1 ≤ k < n) — the size of a desired permutation, and the number of elements you are given, respectively.
The second line contains k integers p1, p2, ..., pk (1 ≤ pi ≤ n) — the first k elements of p. These integers are pairwise distinct.
Output
If it is possible to restore a stack-sortable permutation p of size n such that the first k elements of p are equal to elements given in the input, print lexicographically maximal such permutation.
Otherwise print -1.
Examples
Input
5 3
3 2 1
Output
3 2 1 5 4
Input
5 3
2 3 1
Output
-1
Input
5 1
3
Output
3 2 1 5 4
Input
5 2
3 4
Output
-1
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Vector;
import java.util.Collection;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.TreeSet;
import java.util.Stack;
import java.util.ArrayList;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author Pradyumn
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
FastReader in = new FastReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskE solver = new TaskE();
solver.solve(1, in, out);
out.close();
}
static class TaskE {
public void solve(int testNumber, FastReader in, PrintWriter out) {
int n = in.nextInt();
int k = in.nextInt();
int[] start = in.nextIntArray(k);
MiscUtils.decreaseByOne(start);
TreeSet<Integer> remaining = new TreeSet<>();
Stack<Integer> stack = new Stack<>();
ArrayList<Integer> input = new ArrayList<>();
int resElement = 0;
for (int i = 0; i < n; ++i) remaining.add(i);
for (int ss : start) {
remaining.remove(ss);
input.add(ss);
}
for (int ss : start) {
stack.push(ss);
while (!stack.isEmpty() && stack.peek() == resElement) {
++resElement;
stack.pop();
}
}
while (!remaining.isEmpty()) {
while (!stack.isEmpty() && stack.peek() == resElement) {
++resElement;
stack.pop();
}
if (stack.isEmpty()) {
stack.add(remaining.pollLast());
input.add(stack.peek());
} else {
Integer lower = remaining.lower(stack.peek());
if (lower == null) {
out.println(-1);
return;
}
stack.push(lower);
input.add(lower);
remaining.remove(lower);
}
while (!stack.isEmpty() && stack.peek() == resElement) {
++resElement;
stack.pop();
}
}
if (!stack.isEmpty()) {
out.println(-1);
return;
}
int[] aa = CollectionUtils.toArray(input);
MiscUtils.increaseByOne(aa);
ArrayUtils.printArray(out, aa);
}
}
static class MiscUtils {
public static void decreaseByOne(int[]... arrays) {
for (int[] array : arrays) {
for (int i = 0; i < array.length; i++) {
array[i]--;
}
}
}
public static void increaseByOne(int[]... arrays) {
for (int[] array : arrays) {
for (int i = 0; i < array.length; i++) {
array[i]++;
}
}
}
}
static class ArrayUtils {
public static void printArray(PrintWriter out, int[] array) {
if (array.length == 0) return;
for (int i = 0; i < array.length; i++) {
if (i != 0) out.print(" ");
out.print(array[i]);
}
out.println();
}
}
static class CollectionUtils {
public static int[] toArray(Collection<Integer> collection) {
int[] array = new int[collection.size()];
int index = 0;
for (int element : collection) {
array[index++] = element;
}
return array;
}
}
static class FastReader {
private InputStream stream;
private byte[] buf = new byte[8192];
private int curChar;
private int pnumChars;
public FastReader(InputStream stream) {
this.stream = stream;
}
private int pread() {
if (pnumChars == -1) {
throw new InputMismatchException();
}
if (curChar >= pnumChars) {
curChar = 0;
try {
pnumChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (pnumChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public int nextInt() {
int c = pread();
while (isSpaceChar(c))
c = pread();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = pread();
}
int res = 0;
do {
if (c == ',') {
c = pread();
}
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = pread();
} while (!isSpaceChar(c));
return res * sgn;
}
public int[] nextIntArray(int n) {
int[] array = new int[n];
for (int i = 0; i < n; i++) {
array[i] = nextInt();
}
return array;
}
private boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
}
|
Firecrackers scare Nian the monster, but they're wayyyyy too noisy! Maybe fireworks make a nice complement.
Little Tommy is watching a firework show. As circular shapes spread across the sky, a splendid view unfolds on the night of Lunar New Year's eve.
A wonder strikes Tommy. How many regions are formed by the circles on the sky? We consider the sky as a flat plane. A region is a connected part of the plane with positive area, whose bound consists of parts of bounds of the circles and is a curve or several curves without self-intersections, and that does not contain any curve other than its boundaries. Note that exactly one of the regions extends infinitely.
Input
The first line of input contains one integer n (1 ≤ n ≤ 3), denoting the number of circles.
The following n lines each contains three space-separated integers x, y and r ( - 10 ≤ x, y ≤ 10, 1 ≤ r ≤ 10), describing a circle whose center is (x, y) and the radius is r. No two circles have the same x, y and r at the same time.
Output
Print a single integer — the number of regions on the plane.
Examples
Input
3
0 0 1
2 0 1
4 0 1
Output
4
Input
3
0 0 2
3 0 2
6 0 2
Output
6
Input
3
0 0 2
2 0 2
1 1 2
Output
8
Note
For the first example,
<image>
For the second example,
<image>
For the third example,
<image>
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3;
const long double eps = 1e-12;
int n, ted;
bool bad;
long double x[maxn], y[maxn], r[maxn], dis, tmp, a, b, A, B, C;
vector<pair<long double, long double> > t[maxn], fin[maxn], v;
long double gdis(long double x1, long double y1, long double x2,
long double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
bool eq(long double x1, long double y1, long double x2, long double y2) {
if (abs(x1 - x2) < eps && abs(y1 - y2) < eps) return 1;
return 0;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i] >> r[i];
for (int j = 0; j < i; j++) {
dis = gdis(x[i], y[i], x[j], y[j]);
if (abs(dis - r[i] - r[j]) < eps ||
abs(max(r[i], r[j]) - min(r[i], r[j]) - dis) < eps) {
if (abs(y[i] - y[j]) < eps) {
a = ((r[j] * r[j] - r[i] * r[i]) - (x[j] * x[j] - x[i] * x[i])) /
((x[i] - x[j]) * 2);
t[i].push_back({a, y[i]});
t[j].push_back({a, y[i]});
continue;
}
a = (x[j] - x[i]) / (y[i] - y[j]);
b = ((x[i] * x[i] - x[j] * x[j]) + (y[i] * y[i] - y[j] * y[j]) -
(r[i] * r[i] - r[j] * r[j])) /
((y[i] - y[j]) * 2);
A = a * a + 1;
B = a * b * 2 - x[i] * 2 - a * y[i] * 2;
C = x[i] * x[i] + b * b + y[i] * y[i] - b * y[i] * 2 - r[i] * r[i];
t[i].push_back({-B / (A * 2), a * (-B / (A * 2)) + b});
t[j].push_back({-B / (A * 2), a * (-B / (A * 2)) + b});
} else if (r[i] + r[j] > dis && dis > max(r[i], r[j]) - min(r[i], r[j])) {
if (abs(y[i] - y[j]) < eps) {
a = ((r[j] * r[j] - r[i] * r[i]) - (x[j] * x[j] - x[i] * x[i])) /
((x[i] - x[j]) * 2);
b = sqrt((r[i] * r[i]) - (a - x[i]) * (a - x[i]));
t[i].push_back({a, y[i] - b});
t[j].push_back({a, y[i] - b});
t[i].push_back({a, y[i] + b});
t[j].push_back({a, y[i] + b});
continue;
}
a = (x[j] - x[i]) / (y[i] - y[j]);
b = ((x[i] * x[i] - x[j] * x[j]) + (y[i] * y[i] - y[j] * y[j]) -
(r[i] * r[i] - r[j] * r[j])) /
((y[i] - y[j]) * 2);
A = a * a + 1;
B = a * b * 2 - x[i] * 2 - a * y[i] * 2;
C = x[i] * x[i] + b * b + y[i] * y[i] - b * y[i] * 2 - r[i] * r[i];
t[i].push_back({(-B - sqrt(B * B - A * C * 4)) / (A * 2),
a * ((-B - sqrt(B * B - A * C * 4)) / (A * 2)) + b});
t[j].push_back({(-B - sqrt(B * B - A * C * 4)) / (A * 2),
a * ((-B - sqrt(B * B - A * C * 4)) / (A * 2)) + b});
t[i].push_back({(-B + sqrt(B * B - A * C * 4)) / (A * 2),
a * ((-B + sqrt(B * B - A * C * 4)) / (A * 2)) + b});
t[j].push_back({(-B + sqrt(B * B - A * C * 4)) / (A * 2),
a * ((-B + sqrt(B * B - A * C * 4)) / (A * 2)) + b});
} else
continue;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < ((int(t[i].size()))); j++) {
bad = 0;
for (int k = 0; k < ((int(fin[i].size()))); k++) {
if (eq(t[i][j].first, t[i][j].second, fin[i][k].first,
fin[i][k].second)) {
bad = 1;
break;
}
}
if (!bad) fin[i].push_back(t[i][j]);
bad = 0;
for (int k = 0; k < ((int(v.size()))); k++) {
if (eq(t[i][j].first, t[i][j].second, v[k].first, v[k].second)) {
bad = 1;
break;
}
}
if (!bad) v.push_back(t[i][j]);
}
}
bad = 0;
for (int i = 0; i < n; i++) {
if (((int(fin[i].size()))) > 0) {
bad = 1;
break;
}
}
if (!bad) {
cout << n + 1;
return 0;
}
bad = 0;
for (int i = 0; i < n; i++) {
if (((int(fin[i].size()))) == 0) {
bad = 1;
break;
}
}
for (int i = 0; i < n; i++) ted += ((int(fin[i].size())));
if (bad) {
cout << ted - ((int(v.size()))) + 3;
return 0;
}
cout << ted - ((int(v.size()))) + 2;
return 0;
}
|
Petya loves lucky numbers. Everybody knows that positive integers are lucky if their decimal representation doesn't contain digits other than 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
One night Petya was sleeping. He was dreaming of being the president of some island country. The country is represented by islands connected by two-way roads. Between some islands there is no road way, even through other islands, that's why the country is divided into several regions. More formally, each island belongs to exactly one region, there is a path between any two islands located in the same region; there is no path between any two islands from different regions. A region is lucky if the amount of islands in it is a lucky number.
As a real president, Petya first decided to build a presidential palace. Being a lucky numbers' fan, Petya wants to position his palace in one of the lucky regions. However, it is possible that initially the country has no such regions. In this case Petya can build additional roads between different regions, thus joining them. Find the minimum number of roads needed to build to create a lucky region.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105). They are the number of islands and the number of roads correspondingly. Next m lines contain road descriptions. Each road is defined by the numbers of islands that it connects: that is, by two integers u and v (1 ≤ u, v ≤ n). Some roads can connect an island with itself; there can be more than one road between a pair of islands. Numbers in each line are separated by exactly one space character.
Output
If there's no solution, output the only number "-1" (without the quotes). Otherwise, output the minimum number of roads r that need to be built to get a lucky region.
Examples
Input
4 3
1 2
2 3
1 3
Output
1
Input
5 4
1 2
3 4
4 5
3 5
Output
-1
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void sc(T &x) {
register int c = getchar();
x = 0;
int neg = 0;
for (; ((c<48 | c> 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
const int N = 1e5 + 55;
vector<int> L;
map<int, int> qq;
int dp[N];
vector<pair<int, int> > coin;
bool vis[N];
vector<int> G[N];
int us[N];
void dfs(int u) {
if (u > N) return;
if (u > 0) L.push_back((u));
dfs(10 * u + 4);
dfs(10 * u + 7);
}
int dfs(int u, int p) {
vis[u] = 1;
int ret = 0;
for (auto a : G[u])
if (a != p && vis[a] == 0) {
ret += dfs(a, u);
}
return 1 + ret;
}
int main() {
dfs(0);
int n, m;
sc(n);
sc(m);
for (int i = 0; i < m; i++) {
int a, b;
sc(a);
sc(b);
G[a].push_back((b));
G[b].push_back((a));
}
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
int t = dfs(i, -1);
qq[t]++;
}
}
for (auto a : qq) {
int x = a.first;
int y = a.second;
for (int i = 1; i <= y; y -= i, i *= 2) {
coin.push_back((make_pair(x * i, i)));
}
if (y > 0) coin.push_back((make_pair(x * y, y)));
}
for (int i = 0; i < N; i++) dp[i] = 1 << 30;
dp[0] = 0;
int tot = 0;
for (auto a : coin) {
tot += a.first;
for (int j = tot; j >= a.first; j--) {
dp[j] =
((dp[j]) > (dp[j - a.first] + a.second) ? (dp[j - a.first] + a.second)
: (dp[j]));
}
}
int iM = 1 << 30;
for (auto a : L) iM = ((iM) > (dp[a]) ? (dp[a]) : (iM));
printf("%d\n", iM == 1 << 30 ? -1 : iM - 1);
}
|
It is the middle of 2018 and Maria Stepanovna, who lives outside Krasnokamensk (a town in Zabaikalsky region), wants to rent three displays to highlight an important problem.
There are n displays placed along a road, and the i-th of them can display a text with font size s_i only. Maria Stepanovna wants to rent such three displays with indices i < j < k that the font size increases if you move along the road in a particular direction. Namely, the condition s_i < s_j < s_k should be held.
The rent cost is for the i-th display is c_i. Please determine the smallest cost Maria Stepanovna should pay.
Input
The first line contains a single integer n (3 ≤ n ≤ 3 000) — the number of displays.
The second line contains n integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 10^9) — the font sizes on the displays in the order they stand along the road.
The third line contains n integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^8) — the rent costs for each display.
Output
If there are no three displays that satisfy the criteria, print -1. Otherwise print a single integer — the minimum total rent cost of three displays with indices i < j < k such that s_i < s_j < s_k.
Examples
Input
5
2 4 5 4 10
40 30 20 10 40
Output
90
Input
3
100 101 100
2 4 5
Output
-1
Input
10
1 2 3 4 5 6 7 8 9 10
10 13 11 14 15 12 13 13 18 13
Output
33
Note
In the first example you can, for example, choose displays 1, 4 and 5, because s_1 < s_4 < s_5 (2 < 4 < 10), and the rent cost is 40 + 10 + 40 = 90.
In the second example you can't select a valid triple of indices, so the answer is -1.
|
mod = 1000000007
MOD = 998244353
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
it = lambda : tuple(map(int, input().split()))
ls = lambda : list(input())
n=ii()
l=il()
c=il()
mn=10**20
for i in range(1,n-1):
lmn1=[c[j] for j in range(i) if l[j]<l[i]]
lmn2=[c[j] for j in range(i+1,n) if l[j]>l[i]]
if len(lmn1) and len(lmn2):
mn=min(mn,min(lmn1)+min(lmn2)+c[i])
print(mn if mn!=10**20 else -1)
|
Once Algorithm guru gave a simple problem to his students.He gave a list of n integers say, A={a1,a2,a3...an} and another integer, x representing the expected sum.
He said students to select numbers from array list(0 or more numbers) such that the sum of these numbers is as close as possible but not exceeding to the sum x.
Note:Each element of A can be selected multiple times.If no element is selected then the sum is 0.
Input Format:
The first line contains T the number of test cases.
Each test case is followed by two lines. First line contains two integers n,x, representing the length of list A and expected sum.
Second line consists of n space separated integers, a1,a2,…,an, representing the elements of list A.
Output Format:
Output T lines, the maximum sum for each test case which is as near as possible, but not exceeding, to the expected sum x.
Constraints:
1≤T≤10
1≤n≤3000
1≤x≤3000
1≤ai≤3000,(1 ≤ i ≤ n)
SAMPLE INPUT
2
3 12
1 6 9
5 9
3 4 4 4 8
SAMPLE OUTPUT
12
9
Explanation
In the first test case, one can pick {6, 6}.
In the second, we can pick {3,3,3}
Register for IndiaHacks
|
t=input()
while t:
t-=1
n,k=map(int,raw_input().split())
a=map(int,raw_input().split())
pos=[False]*(k+1)
current=[False]*(k+1)
for x in a:
y=x
while y<=k:
current[y]=True
y+=x
pos=list(current)
pos[0]=True
i=0
while i<=k:
if (current[i]):
j=i
while j<=k:
if (current[i] and current[j] and i+j<=k):
pos[i+j]=True
j+=1
i+=1
i=k
while i>=0:
if (pos[i]==True):
print i
break
i-=1
|
In Byteland,conversion of numbers between different bases has always been a herculian task.They always make errors in these conversions.
People in Byteland always write one of the digits wrong when they convert a number to a new base and write it down. For example, when they convert
the number 56 into binary (base 2), the correct result should be
"110", but they might instead write down "010" or "111". They never
accidentally delete or add digits, so they might write down a number with
a leading digit of "0" if this is the digit they get wrong.
You are given Bytelandians' output when converting a number N into base 2 and base 3,
Find out the correct original value of N (in base 10). You can
assume that there is a unique solution for N.
Input
There are 2 lines:
Line 1: The base-2 representation of N, with one digit written
incorrectly.
Line 2: The base-3 representation of N, with one digit written
incorrectly.
Output
The correct value of N
Constraints
N ≤ 1 billion
SAMPLE INPUT
1010
212
SAMPLE OUTPUT
14
|
def base3Modifier(base3List,iteration):
localBase3=list(base3List)
bitLoc=int(iteration/2)
bitRemainder=iteration%2
if(bitRemainder==0):
if(localBase3[bitLoc]=='2'):
localBase3[bitLoc]='1'
elif(localBase3[bitLoc]=='1'):
localBase3[bitLoc]='0'
else:
localBase3[bitLoc]='2'
else:
if(localBase3[bitLoc]=='2'):
localBase3[bitLoc]='0'
elif(localBase3[bitLoc]=='1'):
localBase3[bitLoc]='2'
else:
localBase3[bitLoc]='1'
result=int(''.join(localBase3),3)
return result
ip1=raw_input()
ip2=raw_input()
base2=int(ip1,2)
base2Range=len(ip1)
base3Range=2*len(ip2)
for i in range(base2Range):
modBase2=base2^int('1',2)<<i
for j in range(base3Range):
modBase3=base3Modifier(ip2,j)
if(modBase2==modBase3):
print(modBase2)
break
|
Captain Jack Sparrow and Davy Jones are having a furious sword fight to gain the key to the chest containing Davy Jones' heart. Jack wants to kill Davy Jones and live forever as the captain of The Flying Dutchman. On the other hand, Davy Jones wants to save himself from death.
A string is hanging between them. With each strike of a sword, they can strike down any one character from the string. If at any point of time before striking down a character, either of them is able to make a palindrome from the characters of the string (any anagram of the string) , he can strike down the entire string in one shot and defeat his opponent. It is known that Jack gets the first chance to strike and strikes are made alternatively by both of them.
Given the string that is hanging between them, determine who wins the fight provided that both fight to achieve their target i.e. fight optimally.
Input
The first line of each file contains T, the number of test cases.
Each of the next T line contains a string S consisting of only lower case characters (a-z).
Output
For each test case, print in a new line the winner of the sword fight - "JACK" or
"DAVY JONES" (quotes for clarity only).
Constraints
1 ≤ T ≤ 100
1 ≤ length of string S ≤ 100000
NOTE
There is partial marking for this question.
SAMPLE INPUT
2
aba
abca
SAMPLE OUTPUT
JACK
DAVY JONES
Explanation
For 2nd test case if Jack wants to win then by playing optimally he removes 'a' from the string. Else 'aca' or 'aba' will be formed by removing 'b' or 'c' respectively, which can be cut in one go as they are palindromes by Davy Jones where he would win. So Davy Jones will be left with 'bca'. Now all are distinct characters, in which he removes any one of the three. In next turn Jack removes another character and finally Davy Jones gets only single character where he wins.
|
def py_2():
t = input()
for tt in xrange(t):
freq = [0]*26
s = raw_input()
slen = len(s)
for i in xrange(slen):
#print ord(s[i])-97
freq[ord(s[i])-97] += 1
c = 0
for i in xrange(26):
if freq[i]%2:
c += 1
if c==0:
print 'JACK'
elif c%2:
print 'JACK'
else:
print 'DAVY JONES'
py_2()
|
You're playing a video game, in which you will get an achievement if you complete all of the levels consecutively without dying. You can play the levels in any order, and each time you play a level you'll either complete it or die. Each level has some probability that you'll complete it, and takes some amount of time. In what order should you play the levels so that the expected time it takes you to get the achievement is minimized? Assume that it takes equally long to beat a level or to die in it, and that you will start again from the first level in your ordering as soon as you die.
Note: If you fail to complete a level, you do not personally die—only your character in the game dies. If that were not the case, only a few people would try to earn this achievement.
Input
The first line of the input gives the number of test cases, T. T test cases follow, each of which consists of three lines. The first line of each test case contains a single integer N, the number of levels. The second line contains N space-separated integers Li. Li is the number of seconds level i lasts, which is independent of whether you complete the level or die. The third line contains N space-separated integers Pi. Pi is the percent chance that you will die in any given attempt to complete level i.
Output
For each test case, output one line containing "Case #x: ", where x is the case number (starting from 1), followed by N space-separated integers. The jth integer in the list should be the index of the jth level you should attempt to beat in order to minimize the amount of time you expect to spend earning the achievement.
Indices go from 0 to N-1. If there are multiple orderings that would give the same expected time, output the lexicographically least ordering. Out of two orderings, the lexicographically smaller one is the one with the smaller index at the first location where they differ; out of many orderings, the lexicographically least one is the one that is lexicographically smaller than every other ordering.
Constraints
1 ≤ T ≤ 100.
0 ≤ Pi < 100.
SAMPLE INPUT
1
4
1 1 1 1
50 0 20 20
SAMPLE OUTPUT
Case #1: 0 2 3 1
|
flag=1
for i in range(input()):
n=input()
a=map(int,raw_input().split())
b=map(int,raw_input().split())
pd=[x1*(x2**2) for (x1,x2) in zip(a,b)]
i=0
dic={}
for j in pd:
dic[i]=j
i+=1
print "Case #"+str(flag)+":" ,
for w in sorted(dic,key=dic.get,reverse=True):
print w,
print""
flag+=1
|
Link to Russian translation of the problem.
Kevin has an array A of N integers, but he doesn't like it - he only likes an array if all its neighboring elements are different (e.g. he likes the array [2,4,2,5,3,2,4], but not [1,2,3,3,4]).
Kevin can reverse any contiguous subarray of his array any number of times. For example, if he has the array [2,4,2,5,3,2,4] and reverses the subarray from 2^nd to 5^th element, he will obtain the array [2,3,5,2,4,2,4].
Now, Kevin wants to know the minimum number of reversals necessary to transform his array into an array he likes - if it's possible.
Input format:
The first line of the input will contain an integer N. The second line will contain N space-separated integers - the elements of A.
Output format:
If it's impossible to transform Kevin's array into an array he likes, print "-1" (without the quotes). Otherwise, print one number - the minimum number of reversals necessary.
Constraints:
1 ≤ N ≤ 10^5
1 ≤ Ai ≤ 10^5
N ≤ 5 in test data worth 15% of all points
N ≤ 10^3 in test data worth 40% of all points
SAMPLE INPUT
7
1 3 2 2 4 4 4
SAMPLE OUTPUT
2
Explanation
First, Kevin reverses the subarray from the 3^rd to the 6^th element and gets the array [1,3,4,4,2,2,4]. Next, he reverses the elements from 4^th to 5^th and gets the array [1,3,4,2,4,2,4], which he likes. There's no way to create an array which Kevin likes using only one reversal.
|
n=int(raw_input())
arr=map(int,raw_input().split())
look=[0]*(max(arr)+1)
look_count=[0]*(max(arr)+1)
for i in xrange(len(arr)):
look_count[arr[i]]+=1
for i in xrange(len(arr)-1):
if arr[i]==arr[i+1]:
look[arr[i]]+=1
mx=max(look)
if max(look_count)>(n+1)/2:
print -1
else:
print max(mx,(sum(look)+1)/2)
|
A modified KP number is a positive whole number n with d digits, such that when we split its square into two pieces - a right hand piece r with d digits and a left hand piece l that contains the remaining d or d−1 digits, the sum of the pieces is equal to the original number (i.e. l + r = n).
Note: r may have leading zeros.
Here's an explanation about the ORIGINAL KP Number. A KP number for a given base is a non-negative integer, the representation of whose square in that base can be split into two parts that add up to the original number again. For instance, 45 is a KP number, because 45² = 2025 and 20+25 = 45.
You are given the two positive integers p and q, where p is lower than q. Write a program to determine how many KP numbers are there in the range between p and q (both inclusive) and display them all.
INPUT
There will be two lines of input: p, lowest value q, highest value.
OUTPUT
Output each KP number in the given range, space-separated on a single line. If no KP numbers exist in the given range, print INVALID RANGE.
CONSTRAINTS
0<p<q<100000
SAMPLE INPUT
1
100
SAMPLE OUTPUT
1 9 45 55 99
|
def kaprekar(i):
if i == 1:
return True
s = i**2
s = str(s)
length = len(s)
if len(s) <= 1:
return False
temp = int(s[0:length/2]) + int(s[length/2:])
if temp == i:
return True
else:
return False
a = input()
b = input()
l = []
for i in range(a,b+1):
if kaprekar(i):
l.append(i)
if not l:
print "INVALID RANGE"
else:
print " ".join(map(str,l))
|
Panda is fond of numbers. Given a number, he subtracts it with squares of any one particular digit of that number to get new numbers. This operation can be applied any number of times (possibly zero) till he obtains a pandatic number. If he is able to reach to a pandatic number then he wins. A pandatic number is a number which can be expressed in the form A^A, where A is a positive integer.
Input Format:
The first line will contain T, the number of test cases.
Then T lines follow, each containing an integer N.
Output Format:
For each test case, output whether it's possible for panda to reach a pandatic number by doing the operations as described. If it's possible print "Yes" (without quotes), otherwise print "No" (without quotes).
Constraints:
Subtask 1: (10 points)
1 ≤ T ≤ 10^3
1 ≤ N ≤ 10^3
Subtask 2: (90 points)
1 ≤ T ≤ 10^5
1 ≤ N ≤ 10^6
SAMPLE INPUT
3
1
3
13
SAMPLE OUTPUT
Yes
No
Yes
Explanation
Case 1: 1 is a pandatic number, hence the answer is "Yes".
Case 2: 3 is not a pandatic number, the answer for this is "No". 3 - 3^3 = -6 is also not a "pandatic number". Hence the final answer is "No".
Case 3: 13 is not a pandatic number.
13 - 1^2 = 12 is not a pandatic number.
13 - 3^2 = 4 is a pandatic number.
.
.
.
Hence the final answer is "Yes".
|
tc = int(raw_input())
while(tc):
n = int(raw_input())
if n == 90 or n == 91:
print "No"
elif n<13:
if n==1 or n==4:
print "Yes"
else:
print "No"
else:
print "Yes"
tc = tc -1
|
Rose loves to play games. This problem is about a game he recently played. In the game there are N locations, numbered 0 through N-1. Each location has one entrance and one exit. You are given an array aka A with N elements.For each i, A[i] describes the exit from location i. If A[i] is a number between 0 and N-1, inclusive, it means that the exit from location i leads to the entrance of location A[i]. Otherwise, A[i] will be -1 and it means that if the player reaches this exit, they win the game.
Rose started the game by entering location 0. Print "Win" (quotes for clarity) if he can win the game. Otherwise, print "Lose". Note that the return value is case-sensitive.
Input - First line contains the no. of testcases and each testcase consist of 2 lines first containing the no. of elements in array and next line contiaing those elements.
Output - Print "Win" if Russy wins otherwise "Lose".
SAMPLE INPUT
3
2
1 -1
3
1 0 -1
3
0 1 2
SAMPLE OUTPUT
Win
Lose
Lose
Explanation
Testcase 1 - Rose will start in location 0. The exit from this location will bring him to location 1, and when he reaches the exit from location 1 he wins the game.
Testcase 2 - Rose will go back and forth between locations 0 and 1. He is unable to reach the exit from location 2.
Testcase 3 - The exit from location 0 leads back to location 0. Russy is unable to reach the other locations.
|
t=input()
while t>0:
n=input()
s=map(int,raw_input().strip().split())
d={}
#print s
i=0
while i!=-1 and (i not in d):
d[i]=1
i=s[i]
#print i
if i==-1:
print "Win"
else:
print "Lose"
t=t-1
|
Jack is a great mathematician. He loves to solve series. Now Stuart gave a
series to Jack and said you have to solve the problem by making a computer program. But Jack doesn't know, how to code.
The series is:
1 + (a1).(x)^1 + (a2).(x)^2 + (a3).(x)^3 +........+(an).(x)^n
And the problem is find the sum of the
a1 + a2 + a3 +.....+ an
Help Jack to find the solution of the problem given by Stuart.
HINT: Here x is the variable and the a1, a2,... are the constants. Try to find the general solution of the problem.
INPUT:
First line contains the number of test cases T, followed by T lines, each line contains the integer value of n.
OUTPUT:
Display T lines denoting the desired result for each test case.
Constraints:
1 ≤ T ≤ 10
1 ≤ n ≤ 50
SAMPLE INPUT
1
1
SAMPLE OUTPUT
1
|
for t in range(int(raw_input())):
n = int(raw_input())
print 2**n - 1
|
The end sem exams at are over. Sneh is the class teacher of class X/C. She now has the hectic task of preparing the report card of her class.
Since Sneh is a computer teacher she tried to infuse some fun into his task. Sneh knew that there are n students in class and they had k subjects. Subjects are numbered from 1 to k and students have unique id from 1 to n.
She now wanted to know which student performed the worst in a group of subjects. She ordered those group priority wise that is if the group contained subjects 1 ,3 and 5 then while determining the worst performer initially subject 1 will be taken in consideration and only those students who have performed worst in subject 1(there might be a tie) will be considered for the next subject that is subject 3 and the rest will be eliminated and ultimately after all the subjects are considered the
worst performer will be determined. If after considering all the subjects there is a tie among few students then the student with the smallest id will be the worst performer.
Help Sneh in determining the worst performer of his class.
Input Format:
First line contains n that is the number of students and k that is the toal number of subjects.
The next n line contains k integers denoting the marks obtained by the students in k subjects.
The next line contains q denoting the number of query you need to answer.
Each query contains a value x which indicates the number of subjects to be considered and then contains x distinct integers indicating the subjects to be considered arranged priority wise.
Output Format:
For each query output the unique id of the worst performer of the class.
Constraints:
1 ≤ n ≤ 1000
1 ≤ k ≤ 20
0 ≤ marks ≤ 100
1 ≤ q ≤ 1000
SAMPLE INPUT
3 3
50 60 70
40 60 80
50 60 61
3
3 1 2 3
1 2
2 3 1
SAMPLE OUTPUT
2
1
3
Explanation
In query 1 we have to consider 3 subjects .First subject to consider priority wise is 1 and the worst performer in this subject is 2 and since there is no tie this is the final answer.
In query 2 we have to consider only 1 subject that is 2.Since there is a tie among all the students in this so student with the smallest id is selected.
In query 3 we have to consider 2 subjects .First one is 3 and the worst performer is 3.
|
(N,K) = map(int,str(raw_input()).split())
marks = []
for i in range(N):
marks.append(map (int, str(raw_input()).split()))
def worst(subjects):
candidates = range(N)
for subject in subjects:
if len(candidates) == 1:
return candidates[0] + 1
min = 100
new_candidates = []
for candidate in candidates:
if marks[candidate][subject-1] == min:
new_candidates.append(candidate)
elif marks[candidate][subject-1] < min:
new_candidates = [candidate]
min = marks[candidate][subject-1]
candidates = new_candidates
return candidates[0] + 1
Q = int(raw_input())
for i in range(Q):
print worst(map (int, str(raw_input()).split())[1:])
|
Limak can repeatedly remove one of the first two characters of a string, for example abcxyx \rightarrow acxyx \rightarrow cxyx \rightarrow cyx.
You are given N different strings S_1, S_2, \ldots, S_N. Among N \cdot (N-1) / 2 pairs (S_i, S_j), in how many pairs could Limak obtain one string from the other?
Constraints
* 2 \leq N \leq 200\,000
* S_i consists of lowercase English letters `a`-`z`.
* S_i \neq S_j
* 1 \leq |S_i|
* |S_1| + |S_2| + \ldots + |S_N| \leq 10^6
Input
Input is given from Standard Input in the following format.
N
S_1
S_2
\vdots
S_N
Output
Print the number of unordered pairs (S_i, S_j) where i \neq j and Limak can obtain one string from the other.
Examples
Input
3
abcxyx
cyx
abc
Output
1
Input
6
b
a
abc
c
d
ab
Output
5
|
#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
using namespace std;
#define N
typedef long long ll;
ll ans=0;
int ch[1000005][27],cnt,len,tot=1,ed[1000005],siz[1000005],fa[1000005],f[1000005][27],id[1000005];
char s[1000005];
void add(char s[])
{
int len=strlen(s);
int x=1;
for(int i=len-1;i>=0;i--)
{
int f=s[i]-'a';
if(!ch[x][f])ch[x][f]=++tot,fa[tot]=x,id[tot]=f;
x=ch[x][f];
}
ed[x]++;
}
void dfs(int x)
{
if(x==0)return;//cout<<x<<endl;
siz[x]=ed[x];
for(int i=0;i<26;i++)
{
int v=ch[x][i];
dfs(v);siz[x]+=siz[v];
f[x][i]+=siz[v];
for(int j=0;j<26;j++)
{
if(j!=i)
f[x][j]+=f[v][j];
}
}
//if(x!=1) f[x][id[x]]=siz[x];
/*
for(int i=0;i<26;i++)
{
cout<<x<<' '<<i<<' '<<f[x][i]<<endl;
}
*/
}
int main()
{
int n;
cin>>n;
for(int i=1;i<=n;i++)
{
scanf("%s",s);
add(s);
}
dfs(1);
for(int i=2;i<=tot;i++)
if(ed[i])
{
ans+=f[fa[i]][id[i]]*ed[i];
//cout<<i<<' '<<f[fa[i]][id[i]]<<" "<<ed[i]<<' '<<ans<<endl;
}
cout<<ans-n<<endl;
return 0;
}
/*
5
a
aa
aaa
aaaa
aaaaa
*/
|
A positive integer X is said to be a lunlun number if and only if the following condition is satisfied:
* In the base ten representation of X (without leading zeros), for every pair of two adjacent digits, the absolute difference of those digits is at most 1.
For example, 1234, 1, and 334 are lunlun numbers, while none of 31415, 119, or 13579 is.
You are given a positive integer K. Find the K-th smallest lunlun number.
Constraints
* 1 \leq K \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
K
Output
Print the answer.
Examples
Input
15
Output
23
Input
1
Output
1
Input
13
Output
21
Input
100000
Output
3234566667
|
k=int(input())
q=["1","2","3","4","5","6","7","8","9"]
x=9
for i in q:
if x>100000:
break
x+=1
a=i[-1]
for j in ([-1,0,1]):
bb=int(a)+j
if bb<10 and bb>=0:
q.append(i+str(bb))
print(q[k-1])
|
Given is a tree G with N vertices. The vertices are numbered 1 through N, and the i-th edge connects Vertex a_i and Vertex b_i.
Consider painting the edges in G with some number of colors. We want to paint them so that, for each vertex, the colors of the edges incident to that vertex are all different.
Among the colorings satisfying the condition above, construct one that uses the minimum number of colors.
Constraints
* 2 \le N \le 10^5
* 1 \le a_i \lt b_i \le N
* All values in input are integers.
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
\vdots
a_{N-1} b_{N-1}
Output
Print N lines.
The first line should contain K, the number of colors used.
The (i+1)-th line (1 \le i \le N-1) should contain c_i, the integer representing the color of the i-th edge, where 1 \le c_i \le K must hold.
If there are multiple colorings with the minimum number of colors that satisfy the condition, printing any of them will be accepted.
Examples
Input
3
1 2
2 3
Output
2
1
2
Input
8
1 2
2 3
2 4
2 5
4 7
5 6
6 8
Output
4
1
2
3
4
1
1
2
Input
6
1 2
1 3
1 4
1 5
1 6
Output
5
1
2
3
4
5
|
#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define int long long
const int N = 1e5 + 5;
int n, k;
int deg[N], ans[N];
vector<pair<int, int> > g[N];
void dfs(int u, int par, int c)
{
for(auto &it:g[u])
{
if(it.first == par)
continue;
c = (c + 1) % k;
ans[it.second] = c;
dfs(it.first, u, c);
}
}
int32_t main()
{
IOS;
cin >> n;
for(int i = 1; i <= n - 1; i++)
{
int u, v;
cin >> u >> v;
deg[u]++, deg[v]++;
g[u].push_back({v, i});
g[v].push_back({u, i});
}
for(int i = 1; i <= n; i++)
k = max(k, deg[i]);
dfs(1, 1, 0);
cout << k << endl;
for(int i = 1; i <= n - 1; i++)
cout << ans[i] + 1 << endl;
return 0;
}
|
You are given a 4-character string S consisting of uppercase English letters. Determine if S consists of exactly two kinds of characters which both appear twice in S.
Constraints
* The length of S is 4.
* S consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
S
Output
If S consists of exactly two kinds of characters which both appear twice in S, print `Yes`; otherwise, print `No`.
Examples
Input
ASSA
Output
Yes
Input
STOP
Output
No
Input
FFEE
Output
Yes
Input
FREE
Output
No
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[4];
for(int i=0;i<4;++i) cin >> s[i];
sort(s,s+4);
if(s[0]==s[1]&&s[2]==s[3]&&s[1]!=s[2]) cout << "Yes" << endl;
else cout << "No" << endl;
}
|
Find the largest integer that can be formed with exactly N matchsticks, under the following conditions:
* Every digit in the integer must be one of the digits A_1, A_2, ..., A_M (1 \leq A_i \leq 9).
* The number of matchsticks used to form digits 1, 2, 3, 4, 5, 6, 7, 8, 9 should be 2, 5, 5, 4, 5, 6, 3, 7, 6, respectively.
Constraints
* All values in input are integers.
* 2 \leq N \leq 10^4
* 1 \leq M \leq 9
* 1 \leq A_i \leq 9
* A_i are all different.
* There exists an integer that can be formed by exactly N matchsticks under the conditions.
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_M
Output
Print the largest integer that can be formed with exactly N matchsticks under the conditions in the problem statement.
Examples
Input
20 4
3 7 8 4
Output
777773
Input
101 9
9 8 7 6 5 4 3 2 1
Output
71111111111111111111111111111111111111111111111111
Input
15 3
5 4 6
Output
654
|
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
FastScanner sc = new FastScanner();
int N = sc.nextInt();
int M = sc.nextInt();
int[] A = new int[M];
for (int i = 0; i < M; i++)
A[i] = sc.nextInt();
int[] costs = {0,2,5,5,4,5,6,3,7,6};
BigInteger[] dp = new BigInteger[N+1];
for (int i = 0; i <= N; i++) {
dp[i] = BigInteger.ZERO;
}
int[] digits = new int[N+1];
BigInteger[] bdigits = new BigInteger[11];
for (int i = 0; i < 10; i++) {
bdigits[i] = new BigInteger(Integer.toString(i));
}
for (int i = 1; i <= N; i++) {
BigInteger num = BigInteger.ZERO;
for (int j = 0; j < M; j++) {
if (costs[A[j]] <= i) {
if (i > costs[A[j]] && dp[i-costs[A[j]]].equals(BigInteger.ZERO))
continue;
BigInteger power = BigInteger.TEN.pow(digits[i-costs[A[j]]]);
BigInteger numGuess = (power.multiply(bdigits[A[j]])).add(dp[i-costs[A[j]]]);
num = num.max(numGuess);
}
}
dp[i] = num;
BigInteger prevPow = BigInteger.TEN.pow(digits[i-1]);
if (dp[i].compareTo(prevPow) >= 0) {
digits[i] = digits[i-1]+1;
} else {
digits[i] = digits[i-1];
}
}
char[] s = dp[N].toString().toCharArray();
Integer[] d = new Integer[s.length];
for (int i = 0; i < s.length; i++)
d[i] = s[i]-'0';
d = sort(d);
StringBuilder ans = new StringBuilder();
for (int i = 0; i < d.length; i++) {
if (d[i] != 0)
ans.append(d[i]);
}
System.out.println(ans);
}
public static Integer[] sort(Integer[] array) {
//Sort an array (immune to quicksort TLE)
Random rgen = new Random();
for (int i = 0; i< array.length; i++) {
int randomPosition = rgen.nextInt(array.length);
int temp = array[i];
array[i] = array[randomPosition];
array[randomPosition] = temp;
}
Arrays.sort(array, new Comparator<Integer>() {
@Override
public int compare(Integer a1, Integer a2) {
return a2-a1;
}
});
return array;
}
static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
|
You are given a permutation of 1,2,...,N: p_1,p_2,...,p_N. Determine if the state where p_i=i for every i can be reached by performing the following operation any number of times:
* Choose three elements p_{i-1},p_{i},p_{i+1} (2\leq i\leq N-1) such that p_{i-1}>p_{i}>p_{i+1} and reverse the order of these three.
Constraints
* 3 \leq N \leq 3 × 10^5
* p_1,p_2,...,p_N is a permutation of 1,2,...,N.
Input
Input is given from Standard Input in the following format:
N
p_1
:
p_N
Output
If the state where p_i=i for every i can be reached by performing the operation, print `Yes`; otherwise, print `No`.
Examples
Input
5
5
2
1
4
3
Output
Yes
Input
4
3
2
4
1
Output
No
Input
7
3
2
1
6
5
4
7
Output
Yes
Input
6
5
3
4
1
2
6
Output
No
|
#include<cstdio>
#include<algorithm>
using namespace std;
int n,a[300005];
int main(){
scanf("%d",&n);
for(int i=1;i<=n;++i)scanf("%d",&a[i]);
for(int i=1,j=1;i<=n;i=j=j+1){
while(1){
if(j+1>n||a[j+1]!=j+1)break;
if(j+2>n||a[j+2]==j+2)break;
j+=2;
}
for(int k=i;k<=j;++k)
if(a[k]<i||a[k]>j)
return puts("No"),0;
for(int k=i,x=0,y=0;k<=j;++k){
if(a[k]<k){
if(a[k]<x)return puts("No"),0;
x=a[k];
}
if(a[k]>k){
if(a[k]<y)return puts("No"),0;
y=a[k];
}
}
}
return puts("Yes"),0;
}
|
There are N holes in a two-dimensional plane. The coordinates of the i-th hole are (x_i,y_i).
Let R=10^{10^{10^{10}}}. Ringo performs the following operation:
* Randomly choose a point from the interior of a circle of radius R centered at the origin, and put Snuke there. Snuke will move to the hole with the smallest Euclidean distance from the point, and fall into that hole. If there are multiple such holes, the hole with the smallest index will be chosen.
For every i (1 \leq i \leq N), find the probability that Snuke falls into the i-th hole.
Here, the operation of randomly choosing a point from the interior of a circle of radius R is defined as follows:
* Pick two real numbers x and y independently according to uniform distribution on [-R,R].
* If x^2+y^2\leq R^2, the point (x,y) is chosen. Otherwise, repeat picking the real numbers x,y until the condition is met.
Constraints
* 2 \leq N \leq 100
* |x_i|,|y_i| \leq 10^6(1\leq i\leq N)
* All given points are pairwise distinct.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
:
x_N y_N
Output
Print N real numbers. The i-th real number must represent the probability that Snuke falls into the i-th hole.
The output will be judged correct when, for all output values, the absolute or relative error is at most 10^{-5}.
Examples
Input
2
0 0
1 1
Output
0.5
0.5
Input
5
0 0
2 8
4 5
2 6
3 10
Output
0.43160120892732328768
0.03480224363653196956
0.13880483535586193855
0.00000000000000000000
0.39479171208028279727
|
"""
@ 凸包をつくる
> 凸包内部の点に属する領域は、半径Rの円からするともはやないものとして考えて良い
> というかこの多角形自体点として考えていい！
@ 凸包の頂点vについて
> vの両隣との傾きだけあればよい
> その間の角度 / 360が答え
"""
from math import gcd, atan, pi, degrees
def cross3(a, b, c):
return (b[0]-a[0])*(c[1]-a[1]) - (b[1]-a[1])*(c[0]-a[0])
def convex_hull(ps):
qs = []
N = len(ps)
for p in ps:
# 一直線上で高々2点にする場合は ">=" にする
while len(qs) > 1 and cross3(qs[-1], qs[-2], p) > 0:
qs.pop()
qs.append(p)
t = len(qs)
for i in range(N-2, -1, -1):
p = ps[i]
while len(qs) > t and cross3(qs[-1], qs[-2], p) > 0:
qs.pop()
qs.append(p)
return qs
def tup_to_key(tup):
x, y = tup
x += 10 ** 7
y += 10 ** 7
x *= 10 ** 8
return x + y
def key_to_tup(key):
x, y = divmod(key, 10 ** 8)
x -= 10 ** 7
y -= 10 ** 7
return x, y
def angle(x1, y1, x2, y2):
if y1 == y2:
return pi / 2
return atan(-(x1 - x2) / (y1 - y2))
def on_line(ps):
st = set()
for p, q in zip(ps, ps[1:]):
px, py = p
qx, qy = q
dx, dy = qx - px, qy - py
g = gcd(dx, dy)
dx //= g
dy //= g
st.add(tup_to_key((dx, dy)))
return len(st) == 1
if __name__ == "__main__":
N = int(input())
if N == 2:
print(0.5)
print(0.5)
exit(0)
res = dict()
points = [list(map(int,input().split())) for _ in range(N)]
# ps = sorted(points)
# for a, b in zip(ps, ps[1:]):
# x1, y1 = a
# x2, y2 = b
# x, y = x2 - x1, y2 - y1
# print(x, y)
if on_line(sorted(points)):
mn = min(points)
mx = max(points)
res[tup_to_key(mn)] = 0.5
res[tup_to_key(mx)] = 0.5
else:
ps = convex_hull(sorted(points))[:-1]
sz = len(ps)
for i, (x, y) in enumerate(ps):
key = tup_to_key((x, y))
lx, ly = ps[i - 1]
rx, ry = ps[(i + 1) % sz]
la = angle(x, y, lx, ly)
ra = angle(x, y, rx, ry)
a = ra - la
# a = min(a, 2 * pi - a)
# print(x, y)
# print(degrees(la), degrees(ra))
if a < 0:
a += pi
# print(la, ra)
res[key] = a / (2 * pi)
for tup in points:
key = tup_to_key(tup)
if key in res:
print(res[key])
else:
print(0)
|
Process the Q queries below.
* You are given two integers A_i and M_i. Determine whether there exists a positive integer K_i not exceeding 2 × 10^{18} such that A_i^{K_i} ≡ K_i (mod M_i), and find one if it exists.
Constraints
* 1 \leq Q \leq 100
* 0 \leq A_i \leq 10^9(1 \leq i \leq Q)
* 1 \leq M_i \leq 10^9(1 \leq i \leq Q)
Examples
Input
4
2 4
3 8
9 6
10 7
Output
4
11
9
2
Input
3
177 168
2028 88772
123456789 987654321
Output
7953
234831584
471523108231963269
|
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>
#define SF scanf
#define PF printf
using namespace std;
long long power(long long x,long long num,long long mod){
long long res=1;
while(num){
if(num&1){res=res*x;res%=mod;}
x*=x;
x%=mod;
num>>=1;
}
return res;
}
long long phi(long long n){
long long res=n,t=n;
for(long long i=2;i*i<=t;i++)
if(t%i==0){
res-=res/i;
while(t%i==0)
t/=i;
}
if(t>1)
res-=res/t;
return res;
}
long long gcd(long long x,long long y){
if(y==0)
return x;
return gcd(y,x%y);
}
long long exgcd(long long a,long long b,long long &x,long long &y){
if(b==0){
x=1;
y=0;
return a;
}
long long g;
g=exgcd(b,a%b,y,x);
y-=a/b*x;
return g;
}
long long solve(long long a,long long mod){
if(mod==1)
return 1;
long long x,y;
long long pm=phi(mod);
long long d=gcd(mod,pm);
long long t=solve(a,d);
long long at=power(a,t,mod);
exgcd(mod/d,pm/d,x,y);
x=x*(((t-at)%pm+pm)%pm)/d;
x=((x%(pm/d))+pm/d)%(pm/d)+pm/d;
return x*mod+at;
}
long long a,mod;
int main(){
int q;
SF("%d",&q);
while(q--){
SF("%lld%lld",&a,&mod);
PF("%lld\n",solve(a,mod));
}
}
|
You are in charge of controlling a dam. The dam can store at most L liters of water. Initially, the dam is empty. Some amount of water flows into the dam every morning, and any amount of water may be discharged every night, but this amount needs to be set so that no water overflows the dam the next morning.
It is known that v_i liters of water at t_i degrees Celsius will flow into the dam on the morning of the i-th day. You are wondering about the maximum possible temperature of water in the dam at noon of each day, under the condition that there needs to be exactly L liters of water in the dam at that time. For each i, find the maximum possible temperature of water in the dam at noon of the i-th day. Here, consider each maximization separately, that is, the amount of water discharged for the maximization of the temperature on the i-th day, may be different from the amount of water discharged for the maximization of the temperature on the j-th day (j≠i).
Also, assume that the temperature of water is not affected by anything but new water that flows into the dam. That is, when V_1 liters of water at T_1 degrees Celsius and V_2 liters of water at T_2 degrees Celsius are mixed together, they will become V_1+V_2 liters of water at \frac{T_1*V_1+T_2*V_2}{V_1+V_2} degrees Celsius, and the volume and temperature of water are not affected by any other factors.
Constraints
* 1≤ N ≤ 5*10^5
* 1≤ L ≤ 10^9
* 0≤ t_i ≤ 10^9(1≤i≤N)
* 1≤ v_i ≤ L(1≤i≤N)
* v_1 = L
* L, each t_i and v_i are integers.
Input
Input is given from Standard Input in the following format:
N L
t_1 v_1
t_2 v_2
:
t_N v_N
Output
Print N lines. The i-th line should contain the maximum temperature such that it is possible to store L liters of water at that temperature in the dam at noon of the i-th day.
Each of these values is accepted if the absolute or relative error is at most 10^{-6}.
Examples
Input
3 10
10 10
20 5
4 3
Output
10.0000000
15.0000000
13.2000000
Input
4 15
0 15
2 5
3 6
4 4
Output
0.0000000
0.6666667
1.8666667
2.9333333
Input
4 15
1000000000 15
9 5
8 6
7 4
Output
1000000000.0000000
666666669.6666666
400000005.0000000
293333338.8666667
|
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
public class Main {
static InputStream is;
static PrintWriter out;
static String INPUT = "";
static void solve()
{
int n = ni(), L = ni();
int[] ts = new int[n];
int[] vs = new int[n];
for(int i = 0;i < n;i++){
ts[i] = ni();
vs[i] = ni();
}
int tail = 0, head = 0;
double[] qtv = new double[n];
double[] qv = new double[n];
double V = 0;
double S = 0;
for(int i = 0;i < n;i++){
V += vs[i];
S += (double)ts[i] * vs[i];
while(V > L && tail < head){
int ind = tail++;
if(V - qv[ind] <= L){
S -= qtv[ind] * (double)(V - L);
qv[ind] = L - (V-qv[ind]);
--tail;
V = L;
}else{
V -= qv[ind];
S -= (double)qtv[ind] * qv[ind];
}
}
out.printf("%.14f\n", S/L);
qtv[head] = ts[i];
qv[head] = vs[i];
head++;
while(head - tail >= 2){
int l1 = head-1, l2 = head-2;
if(qtv[l2] < qtv[l1]){
break;
}else{
qtv[l2] = (qtv[l1]*qv[l1]+qtv[l2]*qv[l2])/(qv[l1]+qv[l2]);
qv[l2] += qv[l1];
head--;
}
}
// assert Math.abs(V-L) < 1e-9;
}
}
public static void main(String[] args) throws Exception
{
long S = System.currentTimeMillis();
is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
out = new PrintWriter(System.out);
solve();
out.flush();
long G = System.currentTimeMillis();
tr(G-S+"ms");
}
private static boolean eof()
{
if(lenbuf == -1)return true;
int lptr = ptrbuf;
while(lptr < lenbuf)if(!isSpaceChar(inbuf[lptr++]))return false;
try {
is.mark(1000);
while(true){
int b = is.read();
if(b == -1){
is.reset();
return true;
}else if(!isSpaceChar(b)){
is.reset();
return false;
}
}
} catch (IOException e) {
return true;
}
}
private static byte[] inbuf = new byte[1024];
static int lenbuf = 0, ptrbuf = 0;
private static int readByte()
{
if(lenbuf == -1)throw new InputMismatchException();
if(ptrbuf >= lenbuf){
ptrbuf = 0;
try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
if(lenbuf <= 0)return -1;
}
return inbuf[ptrbuf++];
}
private static boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
// private static boolean isSpaceChar(int c) { return !(c >= 32 && c <= 126); }
private static int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
private static double nd() { return Double.parseDouble(ns()); }
private static char nc() { return (char)skip(); }
private static String ns()
{
int b = skip();
StringBuilder sb = new StringBuilder();
while(!(isSpaceChar(b))){
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
private static char[] ns(int n)
{
char[] buf = new char[n];
int b = skip(), p = 0;
while(p < n && !(isSpaceChar(b))){
buf[p++] = (char)b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
private static char[][] nm(int n, int m)
{
char[][] map = new char[n][];
for(int i = 0;i < n;i++)map[i] = ns(m);
return map;
}
private static int[] na(int n)
{
int[] a = new int[n];
for(int i = 0;i < n;i++)a[i] = ni();
return a;
}
private static int ni()
{
int num = 0, b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private static long nl()
{
long num = 0;
int b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private static void tr(Object... o) { if(INPUT.length() != 0)System.out.println(Arrays.deepToString(o)); }
}
|
You are given a string S consisting of digits between `1` and `9`, inclusive. You will insert at most K commas (`,`) into this string to separate it into multiple numbers.
Your task is to minimize the maximum number among those produced by inserting commas. Find minimum possible such value.
Constraints
* 0 ≦ K < |S| ≦ 100,000
* S consists of digits between `1` and `9`, inclusive.
Input
The input is given from Standard Input in the following format:
K
S
Output
Print the minimum possible value.
Examples
Input
2
15267315
Output
315
Input
0
12456174517653111
Output
12456174517653111
Input
8
127356176351764127645176543176531763517635176531278461856198765816581726586715987216581
Output
5317635176
|
#include<iostream>
using namespace std;
string s;
int K,L,N;
int dp[1<<17][101];
int main()
{
cin>>K>>s;
N=s.size();
L=N/(K+1);
if(N%(K+1)==0)
{
string ans=s.substr(0,L);
for(int i=L;i<N;i+=L)ans=max(ans,s.substr(i,L));
cout<<ans<<endl;
}
else if(K<100)
{
int A=N%(K+1);
for(int i=0;i<=N;i++)for(int j=0;j<=A;j++)dp[i][j]=-1;
dp[0][A]=-2;
for(int i=0;i<N;i++)
{
for(int j=0;j<=A;j++)
{
if(dp[i][j]==-1)continue;
if(i+L<=N)
{
if(j==A)dp[i+L][j]=-2;
else if(dp[i+L][j]==-1)dp[i+L][j]=dp[i][j];
else
{
if(s.substr(dp[i+L][j],L+1)>s.substr(dp[i][j],L+1))dp[i+L][j]=dp[i][j];
}
}
if(j>0&&i+L+1<=N)
{
int now;
if(j==A)now=i;
else
{
if(s.substr(i,L+1)<s.substr(dp[i][j],L+1))now=dp[i][j];
else now=i;
}
if(dp[i+L+1][j-1]==-1)dp[i+L+1][j-1]=now;
else
{
if(s.substr(dp[i+L+1][j-1],L+1)>s.substr(now,L+1))dp[i+L+1][j-1]=now;
}
}
}
}
cout<<s.substr(dp[N][0],L+1)<<endl;
}
else
{
string ans(L+1,'9');
for(int i=0;i<=L;i++)
{
int l=0,r=9;
while(r-l>1)
{
int m=l+r>>1;
ans[i]=m+'0';
bool flag=true;
int id=0;
for(int j=0;j<=K;j++)
{
if(s.substr(id,L+1)<=ans)
{
id+=L+1;
}
else id+=L;
if(id>=N)break;
}
if(id>=N)r=m;
else l=m;
}
ans[i]=r+'0';
}
cout<<ans<<endl;
}
}
|
Write a program which prints the central coordinate $(p_x, p_y)$ and the radius $r$ of a circumscribed circle of a triangle which is constructed by three points $(x_1, y_1)$, $(x_2, y_2)$ and $(x_3, y_3)$ on the plane surface.
Constraints
* $-100 \leq x_1, y_1, x_2, y_2, x_3, y_3 \leq 100$
* $ n \leq 20$
Input
Input consists of several datasets. In the first line, the number of datasets $n$ is given. Each dataset consists of:
$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$
in a line. All the input are real numbers.
Output
For each dataset, print $p_x$, $p_y$ and $r$ separated by a space in a line. Print the solution to three places of decimals. Round off the solution to three decimal places.
Example
Input
1
0.0 0.0 2.0 0.0 2.0 2.0
Output
1.000 1.000 1.414
|
#include <stdio.h>
#include <math.h>
using namespace std;
int main(){
int n;
double x1,x2,x3,y1,y2,y3,ox,oy,r;
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%lf %lf %lf %lf %lf %lf",&x1,&y1,&x2,&y2,&x3,&y3);
ox=((y2-y1)*((y3*y3-y1*y1)+(x3*x3-x1*x1))-(y3-y1)*((y2*y2-y1*y1)+(x2*x2-x1*x1)))/
(2*((x3-x1)*(y2-y1)-(x2-x1)*(y3-y1)));
if(y2 != y1){
oy=(2*(x1-x2)*ox+(y2*y2-y1*y1)+(x2*x2-x1*x1))/(2*(y2-y1));
}else{
oy=(2*(x1-x3)*ox+(y3*y3-y1*y1)+(x3*x3-x1*x1))/(2*(y3-y1));
}
r = sqrt((ox-x1)*(ox-x1)+(oy-y1)*(oy-y1));
printf("%.3lf %.3lf %.3lf\n",ox,oy,r);
}
return 0;
}
|
A prime number n (11, 19, 23, etc.) that divides by 4 and has 3 has an interesting property. The results of calculating the remainder of the square of a natural number (1, 2, ..., n -1) of 1 or more and less than n divided by n are the same, so they are different from each other. The number is (n -1) / 2.
The set of numbers thus obtained has special properties. From the resulting set of numbers, choose two different a and b and calculate the difference. If the difference is negative, add n to the difference. If the result is greater than (n -1) / 2, subtract the difference from n.
For example, when n = 11, the difference between 1 and 9 is 1 − 9 = −8 → −8 + n = −8 + 11 = 3. The difference between 9 and 1 is also 9 −1 = 8 → n − 8 = 11 − 8 = 3, which is the same value 3. This difference can be easily understood by writing 0, 1, ···, n -1 on the circumference and considering the shorter arc between the two numbers. (See the figure below)
<image>
The "difference" in the numbers thus obtained is either 1, 2, ..., (n -1) / 2, and appears the same number of times.
[Example] When n = 11, it will be as follows.
1. Calculate the remainder of the square of the numbers from 1 to n-1 divided by n.
12 = 1 → 1
22 = 4 → 4
32 = 9 → 9
42 = 16 → 5
52 = 25 → 3
62 = 36 → 3
72 = 49 → 5
82 = 64 → 9
92 = 81 → 4
102 = 100 → 1
2. Calculation of "difference" between a and b
1. Calculate the difference between different numbers for 1, 3, 4, 5, 9 obtained in 1.
2. If the calculation result is negative, add n = 11.
3. In addition, if the result of the calculation is greater than (n-1) / 2 = 5, subtract from n = 11.
3. Find the number of appearances
Count the number of occurrences of the calculation results 1, 2, 3, 4, and 5, respectively.
From these calculation results, we can see that 1, 2, 3, 4, and 5 appear four times. This property is peculiar to a prime number that is 3 when divided by 4, and this is not the case with a prime number that is 1 when divided by 4. To confirm this, a program that takes an odd number n of 10000 or less as an input, executes the calculation as shown in the example (finds the frequency of the difference of the square that is too much divided by n), and outputs the number of occurrences. Please create.
Input
Given multiple datasets. One integer n (n ≤ 10000) is given on one row for each dataset. The input ends with a line containing one 0.
Output
For each data set, output the frequency of occurrence in the following format.
Number of occurrences (integer) of (a, b) where the difference between the squares of the remainder is 1
The number of occurrences (integer) of (a, b) where the difference between the squares of the remainder is 2
::
::
The number of occurrences (integer) of (a, b) where the difference between the squares of the remainder is (n-1) / 2
Example
Input
11
15
0
Output
4
4
4
4
4
2
2
4
2
4
4
2
|
#include <bits/stdc++.h>
#define reps(v, f, l) for (int v = (f), v##_ = (l); v < v##_; ++v)
#define rep(v, n) reps(v, 0, n)
#define lep(v, n) reps(v, 1, n + 1)
using namespace std;
typedef long long int lint;
static inline int in(){ int x; scanf("%d", &x); return x; }
static inline lint inl(){ lint x; scanf("%lld", &x); return x; }
template<typename T> void show(T& a, char del='\n', char last='\n'){ rep(i, a.size() - 1) cout << a[i] << del; cout << a[a.size() - 1] << last; }
int main()
{
int n;
while (n = in()){
vector<int> v;
vector<int> counter(n + 1, 0);
lep(i, n - 1) v.push_back(i * i % n);
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
rep(i, v.size()){
rep(j, v.size()){
if (i == j) continue;
int x = v[i] - v[j];
if (x < 0) x += n;
if (x > (n - 1) / 2) x = n - x;
counter[x]++;
}
}
lep(i, (n - 1) / 2){
printf("%d\n", counter[i]);
}
}
return 0;
}
|
One of the games that uses the Hyakunin Isshu tag is "Buddhist turning". It is a simple game that uses only picture cards, so it is widely enjoyed. There are various derivative types of rules, but the shaved turn considered here is performed by N participants according to the following rules.
* Use a total of 100 cards, including 64 "men", 15 "boys", and 21 "princesses".
* Turn the bill over so that you can't see the picture and mix well to make a "bill pile".
* Draw one card from the first participant in order. After the Nth person, repeat from the first person.
* If the drawn card is a man, the person who draws will get the card.
* If the drawn card is a shaven, the person who draws puts all the cards he has, including that card, into the "field".
* If the drawn card is a princess, the person who draws gets all the cards in play, including that card.
* When there are no more cards in the bill pile, the game ends, and the person with the most cards wins.
Given the number of participants and the order of the cards piled up in the bill pile, the number of cards each participant has at the end of the game is arranged in ascending order, and the number of cards remaining in the field is shown. Create a program to output.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
c1c2 ... c100
Each dataset has two rows, and the first row is given the integer N (2 ≤ N ≤ 10) representing the number of participants. The next line is given a character string that represents the arrangement of the bills piled up in the bill pile. The letter ci represents the i-th drawn tag, where M is a man, S is a shaven, and L is a princess. There is no space between each character.
The number of datasets does not exceed 100.
output
For each data set, the sequence of the number of cards at the end of the game is output on one line. As the number of cards, the number of cards that each participant has is arranged in ascending order, and then the number of cards remaining in the field is output. Separate each number of bills with one blank. Do not print blanks at the end of the line.
Example
Input
2
SSSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
2
SSSSSSSSSSSSSSLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMSL
5
MMMMMMSLSLLMMMSMMSLMMMLMMMMLSLLLLMLSMMLMMLLMSSSLMMMMLMLSMLMSMMMMMMMSMMMMMMLMMMMMSMMMLMMLMMMMMMMMMSSM
0
Output
42 58 0
0 100 0
0 0 3 10 59 28
|
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(true) {
int n = sc.nextInt();
if (n == 0) {
break;
}
int[] hand = new int[n];
int pool = 0;
String card = sc.next();
for(int i=0;i<100;i++) {
int turn = i % n;
switch (card.charAt(i)) {
case 'M':
hand[turn]++;
break;
case 'S':
pool += hand[turn] + 1;
hand[turn] = 0;
break;
case 'L':
hand[turn] += pool + 1;
pool = 0;
break;
}
}
Arrays.sort(hand);
StringBuilder sb = new StringBuilder();
for(int i=0;i<n;i++) {
if (i > 0) {
sb.append(" ");
}
sb.append(hand[i]);
}
sb.append(" " + pool);
System.out.println(sb.toString());
}
}
}
|
problem
You are playing with J using the Midakuji. The Amida lottery consists of n vertical bars and m horizontal bars. The vertical bars are numbered from 1 to n in order from the left, and the vertical bar i The positive integer si is written at the bottom of.
<image>
Figure 3-1 Example of Amidakuji (n = 4, m = 5, s1 = 20, s2 = 80, s3 = 100, s4 = 50)
The integer written at the bottom of the vertical bar i, which is reached by following the path from the top of the vertical bar i, is the score when the vertical bar i is selected. For example, in Fig. 3-1 the vertical bar 1 is selected. And the score is 80 points, and if the vertical bar 2 is selected, the score is 100 points.
<image>
Figure 3-2 Example of how to follow the road
Mr. J decides to choose a series of k books from vertical bar 1 to vertical bar k. The total score when selecting those k vertical bars is J's score. However, you are in the Amidakuji You can select one horizontal bar and delete that horizontal bar from the Amidakuji. (You do not have to delete it.) If you delete one horizontal bar, the vertical bar in the deleted Amidakuji will be displayed vertically. J's score is the total of the points when selecting k consecutive vertical bars from bar 1 to vertical bar k.
Given the shape of the Amida lottery and the number of vertical bars k that J chooses as input, create a program that finds the minimum value of J's score.
input
The input consists of multiple datasets. Each dataset is given in the following format.
On the first line, four integers n, m, h, k are written separated by blanks. N (2 ≤ n ≤ 1000) is the number of vertical bars, and m (1 ≤ m ≤ 100000) is the horizontal bar. H (2 ≤ h ≤ 1000) represents the length of the vertical bar, and k (1 ≤ k ≤ n) represents the number of vertical bars you choose.
The following n lines contain the score written at the bottom of the vertical bar. The first line (1 ≤ i ≤ n) contains the positive integer si. Also, s1 + s2 + ... + sn ≤ 2000000000 = 2 × 109.
The following m lines indicate the position of the horizontal bar. The horizontal bars are numbered from 1 to m. The first line (1 ≤ i ≤ m) is the horizontal bar i. The two integers ai, bi (1 ≤ ai ≤ n --1, 1 ≤ bi ≤ h --1) representing the position are separated by blanks, and the horizontal bar i connects the vertical bar ai and the vertical bar ai + 1. , Indicates that the distance from the top edge of the horizontal bar i is bi. However, no two horizontal bars share an endpoint.
Of the scoring data, 20% of the points will have the lowest score for Mr. J if the horizontal bar is not deleted. Also, 30% of the points will satisfy n ≤ 20, m ≤ 30, h ≤ 10. 60% of the points are m ≤ 1000.
The end of the input is indicated by a line containing four zeros. The number of datasets does not exceed 10.
output
For each dataset, output the minimum score of Mr. J on one line.
Examples
Input
4 5 7 2
20
80
100
50
1 1
2 6
2 3
1 5
3 1
2 2 5 1
10
20
1 1
1 3
0 0 0 0
Output
100
10
Input
None
Output
None
|
#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
using namespace std;
#define FOR(i,k,n) for(int i=(k); i<(int)n; ++i)
#define REP(i,n) FOR(i,0,n)
#define FORIT(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
typedef pair<int,int> P;
int main(){
int n,m,h,k;
while(cin>>n>>m>>h>>k,n){
vector<int> s(n);
vector<P> stc(m);
REP(i,n)cin>>s[i];
REP(i,m){
int a,b;
cin>>a>>b;
stc[i] = P(b,a-1);
}
sort(stc.begin(),stc.end());
int memo[100000][2];
int now[100000];
int point[1000];
REP(i,n)now[i] = i;
REP(i,m){
memo[i][0] = now[stc[i].second];
memo[i][1] = now[stc[i].second+1];
swap(now[stc[i].second], now[stc[i].second+1]);
}
int fstans = 0;
int subans = 0;
REP(i,n)point[now[i]] = s[i];
REP(i,k)fstans+=point[i];
REP(i,m){
if(memo[i][0]<k&&memo[i][1]>=k){
subans = min(subans, -point[memo[i][0]]+point[memo[i][1]]);
}
if(memo[i][1]<k&&memo[i][0]>=k){
subans = min(subans, -point[memo[i][1]]+point[memo[i][0]]);
}
}
cout<<fstans+subans<<endl;
}
return 0;
}
|
Jon is the leader of killifish. Jon have a problem in these days. Jon has a plan to built new town in a pond. Of course new towns should have a school for children. But there are some natural enemies in a pond. Jon thinks that the place of a school should be the safest place in a pond for children.
Jon has asked by some construction companies to make construction plans and Jon has q construction plans now. The plan is selected by voting. But for each plan, the safest place for the school should be decided before voting.
A pond is expressed by a 2D grid whose size is r*c. The grid has r rows and c columns. The coordinate of the top-left cell is (0,0). The coordinate of the bottom-right cell is expressed as (r-1,c-1). Each cell has an integer which implies a dangerousness. The lower value implies safer than the higher value. q plans are given by four integer r1 ,c1 ,r2 and c2 which represent the subgrid. The top-left corner is (r1,c1) and the bottom-right corner is (r2,c2).
You have the r*c grid and q plans. Your task is to find the safest point for each plan. You should find the lowest value in the subgrid.
Input
Input consists of multiple datasets.
Each dataset is given in the following format.
r c q
grid0,0 grid0,1 ... grid0,c-1
...
gridr-1,0 ... gridr-1,c-1
r1 c1 r2 c2
...
r1 c1 r2 c2
The first line consists of 3 integers, r ,c , and q . Next r lines have c integers. gridi,j means a dangerousness of the grid. And you can assume 0 ≤ gridi,j ≤ 231-1. After that, q queries, r1, c1, r2 and c2, are given.
The dataset satisfies following constraints.
r*c ≤ 106
q ≤ 104
For each query, you can assume that r1≤ r2 and c1 ≤ c2 . If r * c ≤ 250000, q ≤ 100 is assured. If r * c > 250000, Input consists of only that case.
Output
For each query you should print the lowest value in the subgrid in a line.
Example
Input
3 3 4
1 2 3
4 2 2
2 1 1
0 0 2 2
0 0 1 1
1 0 1 0
0 1 1 2
1 10 4
1 2 3 4 5 6 7 8 9 10
0 0 0 9
0 0 0 4
0 5 0 9
0 4 0 5
0 0 0
Output
1
1
4
2
1
1
6
5
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Reader;
public class Main {
static FastScanner sc = new FastScanner();
public static void main(String[] args) throws Exception {
PrintWriter writer = new PrintWriter(System.out);
while (true) {
int R = sc.nextInt();
if (R == 0) break;
int C = sc.nextInt();
int Q = sc.nextInt();
int[][] G = new int[R][C];
int[][] tr = new int[C][R];
for (int i = 0; i < R; ++i) {
for (int j = 0; j < C; ++j) {
tr[j][i] = G[i][j] = sc.nextInt();
}
}
int ru = 1;
while (ru < C * 2) {
ru *= 2;
}
int[][] row = new int[R][ru];
for (int i = 0; i < R; ++i) {
build(G[i], row[i]);
}
int cu = 1;
while (cu < R * 2) {
cu *= 2;
}
int[][] col = new int[C][cu];
for (int i = 0; i < C; ++i) {
build(tr[i], col[i]);
}
for (int i = 0; i < Q; ++i) {
int R1 = sc.nextInt();
int C1 = sc.nextInt();
int R2 = sc.nextInt();
int C2 = sc.nextInt();
int ans = Integer.MAX_VALUE;
if (R2 - R1 < C2 - C1) {
for (int j = R1; j <= R2; ++j) {
ans = Math.min(ans, get(row[j], 0, C1, C2 + 1, 0, ru / 2));
}
} else {
for (int j = C1; j <= C2; ++j) {
ans = Math.min(ans, get(col[j], 0, R1, R2 + 1, 0, cu / 2));
}
}
writer.println(ans);
}
}
writer.flush();
}
static void build(int[] in, int[] out) {
for (int i = 0; i < in.length; ++i) {
out[out.length / 2 - 1 + i] = in[i];
}
for (int i = in.length; i < out.length / 2; ++i) {
out[out.length / 2 - 1 + i] = Integer.MAX_VALUE;
}
for (int i = out.length / 2 - 2; i >= 0; --i) {
out[i] = Math.min(out[i * 2 + 1], out[i * 2 + 2]);
}
}
static int get(int[] tree, int cur, int f, int e, int left, int right) {
if (right <= f || e <= left) return Integer.MAX_VALUE;
if (f <= left && right <= e) return tree[cur];
int mid = (left + right + 1) / 2;
return Math.min(get(tree, cur * 2 + 1, f, e, left, mid), get(tree, cur * 2 + 2, f, e, mid, right));
}
static class FastScanner {
Reader input;
FastScanner() {
this(System.in);
}
FastScanner(InputStream stream) {
this.input = new BufferedReader(new InputStreamReader(stream));
}
int nextInt() throws IOException {
int sign = 1;
int b = input.read();
while ((b < '0' || '9' < b) && b != '-' && b != '+') {
b = input.read();
}
if (b == '-') {
sign = -1;
b = input.read();
} else if (b == '+') {
b = input.read();
}
int ret = b - '0';
while (true) {
b = input.read();
if (b < '0' || '9' < b) return ret * sign;
ret *= 10;
ret += b - '0';
}
}
}
}
|
Mr. Schwarz was a famous powerful pro wrestler. He starts a part time job as a warehouseman. His task is to move a cargo to a goal by repeatedly pushing the cargo in the warehouse, of course, without breaking the walls and the pillars of the warehouse.
There may be some pillars in the warehouse. Except for the locations of the pillars, the floor of the warehouse is paved with square tiles whose size fits with the cargo. Each pillar occupies the same area as a tile.
<image>
Initially, the cargo is on the center of a tile. With one push, he can move the cargo onto the center of an adjacent tile if he is in proper position. The tile onto which he will move the cargo must be one of (at most) four tiles (i.e., east, west, north or south) adjacent to the tile where the cargo is present.
To push, he must also be on the tile adjacent to the present tile. He can only push the cargo in the same direction as he faces to it and he cannot pull it. So, when the cargo is on the tile next to a wall (or a pillar), he can only move it along the wall (or the pillar). Furthermore, once he places it on a corner tile, he cannot move it anymore.
He can change his position, if there is a path to the position without obstacles (such as the cargo and pillars) in the way. The goal is not an obstacle. In addition, he can move only in the four directions (i.e., east, west, north or south) and change his direction only at the center of a tile.
As he is not so young, he wants to save his energy by keeping the number of required pushes as small as possible. But he does not mind the count of his pedometer, because walking is very light exercise for him.
Your job is to write a program that outputs the minimum number of pushes required to move the cargo to the goal, if ever possible.
Input
The input consists of multiple maps, each representing the size and the arrangement of the warehouse. A map is given in the following format.
w h
d11 d12 d13 ... d1w
d21 d22 d23 ... d2w
...
dh1 dh2 dh3 ... dhw
The integers w and h are the lengths of the two sides of the floor of the warehouse in terms of widths of floor tiles. w and h are less than or equal to 7. The integer dij represents what is initially on the corresponding floor area in the following way.
0: nothing (simply a floor tile)
1: a pillar
2: the cargo
3: the goal
4: the warehouseman (Mr. Schwarz)
Each of the integers 2, 3 and 4 appears exactly once as dij in the map. Integer numbers in an input line are separated by at least one space character. The end of the input is indicated by a line containing two zeros.
Output
For each map, your program should output a line containing the minimum number of pushes. If the cargo cannot be moved to the goal, -1 should be output instead.
Example
Input
5 5
0 0 0 0 0
4 2 0 1 1
0 1 0 0 0
1 0 0 0 3
1 0 0 0 0
5 3
4 0 0 0 0
2 0 0 0 0
0 0 0 0 3
7 5
1 1 4 1 0 0 0
1 1 2 1 0 0 0
3 0 0 0 0 0 0
0 1 0 1 0 0 0
0 0 0 1 0 0 0
6 6
0 0 0 0 0 3
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 2 0 0 0 0
4 0 0 0 0 0
0 0
Output
5
-1
11
8
|
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.PriorityQueue;
import java.util.Scanner;
public class Main {
public static final int MAX = 7;
public static boolean is_ok(int x, int y, int w, int h){
if(x < 0 || x >= w || y < 0 || y >= h){
return false;
}else{
return true;
}
}
public static final int[][] move_dir = new int[][]{{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
public static void main(String[] args) {
final Scanner sc = new Scanner(System.in);
boolean[][] can_enter = new boolean[MAX][MAX];
boolean[][][][] is_visited = new boolean[MAX][MAX][MAX][MAX];
while (true) {
final int w = sc.nextInt();
final int h = sc.nextInt();
if(w == 0 && h == 0){
break;
}
int s_x = -1, s_y = -1, g_x = -1, g_y = -1;
int c_s_x = -1, c_s_y = -1;
for(int i = 0; i < h; i++){
for(int j = 0; j < w; j++){
final int in = sc.nextInt();
can_enter[i][j] = in != 1;
if(in == 2){
c_s_x = j;
c_s_y = i;
}
if(in == 3){
g_x = j;
g_y = i;
}
if(in == 4){
s_x = j;
s_y = i;
}
}
}
for(int i = 0; i < h; i++){
for(int j = 0; j < w; j++){
for(int k = 0; k < h; k++){
for(int l = 0; l < w; l++){
is_visited[i][j][k][l] = false;
}
}
}
}
LinkedList<Integer> p_x_queue = new LinkedList<Integer>();
LinkedList<Integer> p_y_queue = new LinkedList<Integer>();
LinkedList<Integer> c_x_queue = new LinkedList<Integer>();
LinkedList<Integer> c_y_queue = new LinkedList<Integer>();
LinkedList<Integer> time_queue = new LinkedList<Integer>();
p_x_queue.add(s_x);
p_y_queue.add(s_y);
c_x_queue.add(c_s_x);
c_y_queue.add(c_s_y);
time_queue.add(0);
is_visited[s_y][s_x][c_s_y][c_s_x] = true;
boolean flag = false;
while(!time_queue.isEmpty()){
final int p_x = p_x_queue.poll();
final int p_y = p_y_queue.poll();
final int c_x = c_x_queue.poll();
final int c_y = c_y_queue.poll();
final int time = time_queue.poll();
//System.out.println(p_x + " " + p_y + " " + c_x + " " + c_y + " " + time);
if(c_x == g_x && c_y == g_y){
flag = true;
System.out.println(time);
break;
}
for(int[] move : move_dir){
final int n_p_x = p_x + move[0];
final int n_p_y = p_y + move[1];
final int n_c_x = c_x + ((c_x == n_p_x && c_y == n_p_y) ? move[0] : 0);
final int n_c_y = c_y + ((c_x == n_p_x && c_y == n_p_y) ? move[1] : 0);
boolean moved = n_c_x != c_x || n_c_y != c_y;
if(!is_ok(n_p_x, n_p_y, w, h) || !is_ok(n_c_x, n_c_y, w, h)){
continue;
}else if(!can_enter[n_p_y][n_p_x] || !can_enter[n_c_y][n_c_x]){
continue;
}else if(is_visited[n_p_y][n_p_x][n_c_y][n_c_x]){
continue;
}
is_visited[n_p_y][n_p_x][n_c_y][n_c_x] = true;
if(moved){
p_x_queue.add(n_p_x);
p_y_queue.add(n_p_y);
c_x_queue.add(n_c_x);
c_y_queue.add(n_c_y);
time_queue.add(time + 1);
}else{
p_x_queue.addFirst(n_p_x);
p_y_queue.addFirst(n_p_y);
c_x_queue.addFirst(n_c_x);
c_y_queue.addFirst(n_c_y);
time_queue.addFirst(time);
}
}
}
if(!flag){
System.out.println(-1);
}
}
}
}
|
Example
Input
4 4
1 2 3
1 3 3
2 3 3
2 4 3
Output
1 3
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
//const ll mod = 1000000007;
struct UnionFind {
vector<int> par;
vector<int> rank;
vector<ll> Size;
UnionFind(int n = 1) {
init(n);
}
void init(int n = 1) {
par.resize(n + 1); rank.resize(n + 1); Size.resize(n + 1);
for (int i = 0; i <= n; ++i) par[i] = i, rank[i] = 0, Size[i] = 1;
}
int root(int x) {
if (par[x] == x) {
return x;
}
else {
int r = root(par[x]);
return par[x] = r;
}
}
bool issame(int x, int y) {
return root(x) == root(y);
}
bool merge(int x, int y) {
x = root(x); y = root(y);
if (x == y) return false;
if (rank[x] < rank[y]) swap(x, y);
if (rank[x] == rank[y]) ++rank[x];
par[y] = x;
Size[x] += Size[y];
return true;
}
ll size(int x){
return Size[root(x)];
}
};
int N, M;
typedef pair<int, i_i> iii;
map<i_i, int> mp;
int S[50000], D[50000], C[50000];
vector<iii> paths[500];
vector<iii> que;
vector<iii> rest;
bool ans[50000];
bool dfs(int now, int from, int destination, int cost) {
if(now == destination) return true;
for(auto tmp : paths[now]) {
int to = tmp.first;
int nowcost = tmp.second.first;
int e = tmp.second.second;
if(to == from) continue;
if(dfs(to, now, destination, cost)) {
if(nowcost == cost) {
ans[e] = false;
}
return true;
}
}
return false;
}
int main() {
//cout.precision(10);
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> M;
for(int i = 0; i < M; i++) {
cin >> S[i] >> D[i] >> C[i];
S[i]--;
D[i]--;
mp[{S[i], D[i]}] = i;
que.push_back({C[i], {S[i], D[i]}});
}
UnionFind uni(N);
sort(que.begin(), que.end());
for(auto tmp : que) {
int s = tmp.second.first;
int t = tmp.second.second;
if(uni.merge(tmp.second.first, tmp.second.second)) {
paths[s].push_back({t, {tmp.first, mp[{s, t}]}});
paths[t].push_back({s, {tmp.first, mp[{s, t}]}});
ans[mp[{s, t}]] = true;
} else {
rest.push_back(tmp);
}
}
/*
for(int i = 0; i < M; i++) {
if(ans[i]) cerr << i << " ";
}
cerr << endl;
*/
for(auto tmp : rest) {
dfs(tmp.second.first, -1, tmp.second.second, tmp.first);
}
int ansnum = 0;
int anscost = 0;
for(int i = 0; i < M; i++) {
if(ans[i]) {
ansnum++;
anscost += C[i];
}
}
cout << ansnum << " " << anscost << endl;
return 0;
}
|
P "Today is the recording of a program of a liver test project."
O-type Chieri "Ki, Kimo no good ..."
Kanako Shimura "Is Chieri-chan okay?"
Akane Tsukino "As expected, Mr. P! It's a wonderful commentary that clearly shows the situation in one line! Come on! Let's run toward the fireball!"
P "The rules are simple, we just work together to visit all the shrines in this area."
Akane "It's orthodox! Let's run toward the shrine immediately!"
Kanako "But there were many shrines that had to be visited at one of the highest density of shrines in Japan ..."
Kanako "But it's encouraging to have Akane!"
P "By the way, everyone starts from a different shrine, and merging is also prohibited. Then Chieri and Kanako should follow the initial position."
Chieri "Uh ..."
Kanako "Oh, it's okay if you bring some sweets!"
Chieri "I'll do my best ..."
Akane "Producer! What should I do!"
P "You are lively"
Akane "Eh"
P "Sit down"
madder""
Constraints
* 2 ≤ n ≤ 105
* 1 ≤ ai, bi, u, v ≤ n
* u ≠ v
* ai <bi
* (ai, bi) ≠ (aj, bj) (i ≠ j)
Input
The input is given in the following format.
n u v
a1 b1
a2 b2
...
an−1 bn−1
The first line is given three integers n, u, v separated by blanks.
From the 2nd line to the nth line, two integers ai and bi are given, separated by blanks.
Output
Output "Yes" if the rule can be satisfied, and "No" if it cannot be satisfied on one line.
Examples
Input
4 1 4
1 2
2 3
3 4
Output
Yes
Input
8 3 6
1 2
2 4
3 4
4 5
5 6
6 7
7 8
Output
No
Input
4 2 3
1 2
2 3
3 4
Output
Yes
Input
6 1 5
1 2
1 4
2 3
4 5
3 6
Output
No
|
#include <iostream>
#include <vector>
using namespace std;
typedef pair<int, int> i_i;
int N;
i_i pp;
void dfs(int u, int p, vector<vector<int> >& G, vector<int>& num) {
num[u] = 1;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == p) continue;
dfs(v, u, G, num);
num[u] += num[v];
if (num[v] == N / 2)
pp = i_i(u, v);
}
}
struct union_find {
vector<int> v;
union_find(int n) : v(n, -1) {}
int find(int x) { return (v[x] < 0) ? x : (v[x] = find(v[x])); }
void unite(int x, int y) {
x = find(x); y = find(y);
if (x != y) {
if (-v[x] < -v[y]) swap(x, y);
v[x] += v[y]; v[y] = x;
}
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return -v[find(x)]; }
};
int main() {
int x, y; cin >> N >> x >> y;
x--; y--;
if (N == 2) {
cout << "Yes" << endl;
return 0;
}
if (N % 2 == 1) {
cout << "No" << endl;
return 0;
}
vector<vector<int> > G(N);
vector<int> d(N), A, B;
for (int i = 0; i < N - 1; i++) {
int a, b; scanf("%d%d", &a, &b);
a--; b--;
G[a].push_back(b);
G[b].push_back(a);
d[a]++; d[b]++;
A.push_back(a);
B.push_back(b);
}
vector<int> num(N);
dfs(0, -1, G, num);
union_find uf(N);
for (int i = 0; i < N - 1; i++) {
int a = A[i], b = B[i];
if (i_i(a, b) == pp || i_i(b, a) == pp) {
d[a]--; d[b]--;
}
else uf.unite(a, b);
}
for (int u = 0; u < N; u++)
if (d[u] >= 3) {
cout << "No" << endl;
return 0;
}
if (uf.same(x, y)) {
cout << "No" << endl;
return 0;
}
if (d[x] == 1 && d[y] == 1) {
cout << "Yes" << endl;
return 0;
}
cout << "No" << endl;
}
|
In a forest, there lived a spider named Tim. Tim was so smart that he created a huge, well-structured web. Surprisingly, his web forms a set of equilateral and concentric N-sided polygons whose edge lengths form an arithmetic sequence.
<image>
Figure 1: An example web of Tim
Corresponding vertices of the N-sided polygons lie on a straight line, each apart from neighboring ver- tices by distance 1. Neighboring vertices are connected by a thread (shown in the figure as solid lines), on which Tim can walk (you may regard Tim as a point). Radial axes are numbered from 1 to N in a rotational order, so you can denote by (r, i) the vertex on axis i and apart from the center of the web by distance r. You may consider the web as infinitely large, i.e. consisting of infinite number of N-sided polygons, since the web is so gigantic.
Tim’s web is thus marvelous, but currently has one problem: due to rainstorms, some of the threads are damaged and Tim can’t walk on those parts.
Now, a bug has been caught on the web. Thanks to the web having so organized a structure, Tim accu- rately figures out where the bug is, and heads out for that position. You, as a biologist, are interested in whether Tim is smart enough to move through the shortest possible route. To judge that, however, you need to know the length of the shortest route yourself, and thereby decided to write a program which calculates that length.
Input
The input consists of multiple test cases. Each test case begins with a line containing two integers N (3 ≤ N ≤ 100) and X (0 ≤ X ≤ 100), where N is as described above and X denotes the number of damaged threads. Next line contains four integers rS, iS, rT, and iT, meaning that Tim is starting at (rS, iS) and the bug is at (rT, iT). This line is followed by X lines, each containing four integers rA, iA, rB, and iB, meaning that a thread connecting (rA, iA) and (rB, iB) is damaged. Here (rA, iA) and (rB, iB) will be always neighboring to each other. Also, for all vertices (r, i) given above, you may assume 1 ≤ r ≤ 107 and 1 ≤ i ≤ N.
There will be at most 200 test cases. You may also assume that Tim is always able to reach where the bug is.
The input is terminated by a line containing two zeros.
Output
For each test case, print the length of the shortest route in a line. You may print any number of digits after the decimal point, but the error must not be greater than 0.01.
Example
Input
5 1
2 1 3 2
2 1 2 2
0 0
Output
4.18
|
#include <cstdio>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
const double PI = acos(-1.0);
const double EPS = 1.0e-10;
const double INF = DBL_MAX / 1000;
int main()
{
int _tmp = 0;
for(;;){
int n, x;
cin >> n >> x;
if(n == 0)
return 0;
int rStart, iStart, rGoal, iGoal;
cin >> rStart >> iStart >> rGoal >> iGoal;
vector<int> r1(x), i1(x), r2(x), i2(x);
for(int j=0; j<x; ++j)
cin >> r1[j] >> i1[j] >> r2[j] >> i2[j];
// スタート、ゴール、失われた辺が位置する多角形と、その前後の多角形のみに注目
// また、一番中央にある多角形にも注目する
map<int, int> rIndex;
rIndex[1];
for(int j=0; j<3; ++j){
rIndex[rStart - 1 + j];
rIndex[rGoal - 1 + j];
}
for(int j=0; j<x; ++j){
for(int k=0; k<3; ++k){
rIndex[r1[j] - 1 + k];
rIndex[r2[j] - 1 + k];
}
}
if(rIndex.begin()->first == 0)
rIndex.erase(rIndex.begin());
int m = 0; // 注目する多角形の数
vector<int> rPos; // 注目する多角形の位置
for(map<int, int>::iterator it=rIndex.begin(); it!=rIndex.end(); ++it){
it->second = m;
++ m;
rPos.push_back(it->first);
}
set<pair<pair<int, int>, pair<int, int> > > damage;
for(int j=0; j<x; ++j){
damage.insert(make_pair(make_pair(rIndex[r1[j]], i1[j]), make_pair(rIndex[r2[j]], i2[j])));
damage.insert(make_pair(make_pair(rIndex[r2[j]], i2[j]), make_pair(rIndex[r1[j]], i1[j])));
}
vector<vector<double> > minDist(m, vector<double>(n+1, INF));
minDist[rIndex[rStart]][iStart] = 0.0;
multimap<double, pair<int, int> > mm;
mm.insert(make_pair(0.0, make_pair(rIndex[rStart], iStart)));
for(;;){
double dist0 = mm.begin()->first;
int r0 = mm.begin()->second.first;
int i0 = mm.begin()->second.second;
mm.erase(mm.begin());
if(dist0 > minDist[r0][i0] + EPS)
continue;
if(r0 == rIndex[rGoal] && i0 == iGoal){
printf("%.10f\n", dist0);
break;
}
for(int j=0; j<4; ++j){
double dist = dist0;
int r = r0;
int i = i0;
if(j % 2 == 0){
r = r - 1 + j;
if(r == -1 || r == m)
continue;
dist += abs(rPos[r] - rPos[r0]);
}else{
i = (i - 3 + j + n) % n + 1;
dist += rPos[r] * sin(PI / n) * 2.0;
}
if(damage.find(make_pair(make_pair(r0, i0), make_pair(r, i))) != damage.end())
continue;
if(dist < minDist[r][i] - EPS){
minDist[r][i] = dist;
mm.insert(make_pair(dist, make_pair(r, i)));
}
}
}
}
}
|
JAVA (Japan Aerospace Voyage Agency) launched a spacecraft in 2003 as part of its space development project. One of the purposes of launching this spacecraft is to approach the asteroid Ishikawa and collect samples of its surface material. Despite various accidents, the spacecraft reached Ishikawa and finally returned to Earth in 2010 to successfully recover the capsule containing Ishikawa's sample.
Masa Kita, who graduated from the University of Tokyo and got a job at JAVA, is in charge of research on this sample. I'd like to analyze the sample as soon as possible, but Mr. Kitamasa, who is very careful, thought that it would be difficult if there were ferocious aliens in the capsule. Therefore, before opening the capsule, I decided to use X-rays to examine the shape of the substance inside and confirm that it did not contain aliens. When the capsule is exposed to X-rays, a photograph is obtained in which the substance is white where it is present and black where it is not present. By irradiating X-rays from various angles and obtaining photographs, the shape of the substance inside can be identified.
However, there was another problem here. The X-ray device broke down when I got three pictures from the front, from the right side, and from the top. Furthermore, it is possible that the development of the three photographs also failed, and the part that should have been black has turned white. Since the shape of the substance cannot be accurately specified as it is, it cannot be confirmed that there are no aliens inside, and the capsule cannot be opened.
The only way to continue research is to replace the X-ray equipment, but JAVA does not have the money to replace the X-ray equipment immediately due to the budget cuts due to business sorting. So Kitamasa asked him to increase his budget next year and thought about buying a new X-ray device with that money. Of course, the budget will not increase easily, so it is necessary to maximize the results of the spacecraft. The larger the substance contained in the capsule, the stronger the appeal of the result, so we decided to calculate the maximum volume that the substance can take.
Find the shape of the substance inside that is consistent with the three X-ray photographs and have the largest volume, and output that volume.
Notes on Test Cases
Multiple datasets are given in the above input format. Create a program that outputs each data set in the above output format.
When nx, ny, nz are all 0, it indicates the end of input.
<!-
Input
The white and black border of each radiograph consists of a single polygon. Polygons are not always convex and do not self-intersect. The inside of the polygon is white and the outside is black.
The input format is as follows.
nx
y1 z1
y2 z2
...
ynx znx
ny
z1 x1
z2 x2
...
zny xny
nz
x1 y1
x2 y2
...
xnz ynz
nx, ny, and nz are the number of vertices of the polygon corresponding to the X-ray photograph from the front, right side, and top, respectively. The number of each vertex is 3 or more and 20 or less. The following n lines are given the coordinates of the vertices of the polygon counterclockwise. The coordinates of the vertices are integers between 0 and 300.
The coordinate axes are the x-axis in the front direction from the center of the capsule, the y-axis in the right side direction, and the z-axis in the top surface direction.
<image>
Output
Output the maximum volume of the substance in one line that is consistent with the three X-ray photographs. The output value may contain an error of 10-3 or less. The value may be displayed in any number of digits after the decimal point.
Examples
Input
4
0 0
100 0
100 100
0 100
4
0 0
100 0
100 100
0 100
4
0 0
100 0
100 100
0 100
3
0 0
100 0
0 100
3
0 0
100 0
0 100
3
0 0
100 0
0 100
5
0 0
200 0
200 200
100 100
0 200
5
0 0
200 0
100 100
200 200
0 200
4
0 0
200 0
200 200
0 200
0
0
0
Output
1000000.0000
250000.0000
5333333.3333
Input
4
0 0
100 0
100 100
0 100
4
0 0
100 0
100 100
0 100
4
0 0
100 0
100 100
0 100
Output
1000000.0000
Input
3
0 0
100 0
0 100
3
0 0
100 0
0 100
3
0 0
100 0
0 100
Output
250000.0000
Input
5
0 0
200 0
200 200
100 100
0 200
5
0 0
200 0
100 100
200 200
0 200
4
0 0
200 0
200 200
0 200
Output
5333333.3333
|
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
#include <queue>
#include <utility>
#define EPS 1e-10
using namespace std;
typedef long long ll;
struct Point{
double x,y;
Point(double x = 0.0,double y = 0.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);
}
Point operator * (double lambda){
return Point(x * lambda,y * lambda);
}
Point operator / (double lambda){
return Point(x / lambda,y / lambda);
}
double norm(){
return x * x + y * y;
}
double abs_(){
return sqrt(norm());
}
double pol(){
return atan2(y,x);
}
bool operator == (const Point &p)const
{
return abs(x - p.x) < EPS && abs(y - p.y) < EPS;
}
bool operator < (const Point &p)const
{
if(abs(x - p.x) < EPS) return y < p.y;
return x < p.x;
}
};
typedef Point Vector;
double dot(Vector a,Vector b){
return a.x * b.x + a.y * b.y;
}
double det(Vector a,Vector b){
return a.x * b.y - a.y * b.x;
}
typedef vector<Point> Polygon;
struct Segment{
Point p1,p2;
Segment(Point p1 = Point(),Point p2 = Point()): p1(p1),p2(p2) {}
};
typedef Segment Line;
Point crossPoint(Line a,Line b){
double r = det(b.p2 - b.p1,a.p1 - b.p1) / det(a.p2 - a.p1,b.p2 - b.p1);
return a.p1 + (a.p2 - a.p1) * r;
}
bool on_left(Point p,Line l){ return det(l.p2 - l.p1,p - l.p1) > EPS; }
bool para(Line a,Line b){ return abs(det(a.p2 - a.p1,b.p2 - b.p1)) < EPS; }
Line L[15],que[15];
int he,ta,n;
bool cmp(Line &a,Line &b){
return (a.p2 - a.p1).pol() < (b.p2 - b.p1).pol();
}
double area(Polygon P){
double ans = 0.0;
int num = P.size();
for(int i = 0;i < num;i++){
ans += det(P[i],P[(i + 1) % num]);
}
return ans / 2.0;
}
double hp_intersect(){
sort(L + 1,L + n + 1,cmp);
he = ta = 0;
for(int i=1;i<=n;i++){
while(ta - he > 1 && !on_left(crossPoint(que[ta - 1],que[ta - 2]),L[i])) ta--;
while(ta - he > 1 && !on_left(crossPoint(que[he],que[he + 1]),L[i])) he++;
que[ta++] = L[i];
while(ta - he > 1 && para(que[ta - 1],que[ta - 2])){
ta--;
if(on_left(L[i].p1,que[ta - 1])) que[ta - 1] = L[i];
}
}
while(ta - he > 1 && !on_left(crossPoint(que[ta - 1],que[ta - 2]),que[he])) ta--;
if(ta - he <= 2) return 0.0;
int cnt = ta - he;
Polygon po(cnt);
for(int i=0;i<cnt;i++){
po[i] = crossPoint(que[he + i],que[he + (i + 1) % cnt]);
}
return area(po);
}
void cut(Polygon P,double x0,vector <double> &lis){
lis.clear();
int num = P.size();
Line l = Line(Point(x0,-1.0),Point(x0,301.0));
for(int i = 0;i < num;i++){
if(P[i].x == P[(i + 1) % num].x) continue; // 取x0时应回避这个x
if((P[i].x - x0) * (P[(i + 1) % num].x - x0) < 0){
lis.push_back(crossPoint(Line(P[i],P[(i + 1) % num]),l).y);
}
}
sort(lis.begin(),lis.end());
}
Polygon X,Y,Z;
int nx,ny,nz;
vector <double> ylis,zlis; // ylis's segments parallel to z-axis.
double calc(double x0){
cut(Y,x0,ylis);
cut(Z,x0,zlis);
double ans = 0;
for(int i = 0;i < (int)ylis.size();i += 2){
for(int j = 0;j < (int)zlis.size();j += 2){
for(int k = 0;k < nx;k++){
n = 0;
L[++n] = Line(Point(zlis[j],ylis[i]),Point(zlis[j + 1],ylis[i]));
L[++n] = Line(Point(zlis[j + 1],ylis[i]),Point(zlis[j + 1],ylis[i + 1]));
L[++n] = Line(Point(zlis[j + 1],ylis[i + 1]),Point(zlis[j],ylis[i + 1]));
L[++n] = Line(Point(zlis[j],ylis[i + 1]),Point(zlis[j],ylis[i]));
if(det(X[k] + Point(1,1),X[(k + 1) % nx] + Point(1,1)) > 0){
L[++n] = Line(Point(-1,-1),X[k]);
L[++n] = Line(X[k],X[(k + 1) % nx]);
L[++n] = Line(X[(k + 1) % nx],Point(-1,-1));
ans += hp_intersect();
}else{
L[++n] = Line(Point(-1,-1),X[(k + 1) % nx]);
L[++n] = Line(X[(k + 1) % nx],X[k]);
L[++n] = Line(X[k],Point(-1,-1));
ans -= hp_intersect();
}
}
}
}
return ans;
}
double work(double l,double r,double y_l,double y_mid,double y_r,double eps){
double mid = (l + r) / 2;
double y_lmid = calc((l + mid) / 2), y_rmid = calc((mid + r) / 2);
double s = (r - l) * (y_l + 4 * y_mid + y_r) / 6;
double s1 = (mid - l) * (y_l + 4 * y_lmid + y_mid) / 6;
double s2 = (r - mid) * (y_mid + 4 * y_rmid + y_r) / 6;
if(abs(s1 + s2 - s) < 15 * eps) return s1 + s2 + (s1 + s2 - s) / 15;
return work(l,mid,y_l,y_lmid,y_mid,eps / 2) + work(mid,r,y_mid,y_rmid,y_r,eps / 2);
}
vector <double> xs;
int t;
void solve(){
sort(xs.begin(),xs.end());
if(t == 20){
printf("%.6f\n",work(xs.front() + EPS,xs.back() - EPS,calc(xs.front() + EPS),calc((xs.front() + xs.back()) / 2),calc(xs.back() - EPS),1e-7));
return;
}
double ans = 0;
for(int i = 0;i < (int)xs.size() - 1;i++){
if(xs[i] + 1e-11 < xs[i + 1] - 1e-11)
ans += work(xs[i] + 1e-11,xs[i + 1] - 1e-11,calc(xs[i] + 1e-11),calc((xs[i] + xs[i + 1]) / 2),calc(xs[i + 1] - 1e-11),1e-9);
}
printf("%.6f\n",ans);
}
int main(){
while(~scanf("%d",&nx) && nx){
t++;
X.resize(nx);
for(int i = 0;i < nx;i++) scanf("%lf%lf",&X[i].x,&X[i].y);
scanf("%d",&ny);
Y.resize(ny);
for(int i = 0;i < ny;i++){
scanf("%lf%lf",&Y[i].y,&Y[i].x);
xs.push_back(Y[i].x);
}
reverse(Y.begin(),Y.end());
scanf("%d",&nz);
Z.resize(nz);
for(int i = 0;i < nz;i++){
scanf("%lf%lf",&Z[i].x,&Z[i].y);
xs.push_back(Z[i].x);
}
solve();
}
return 0;
}
|
Honestly, a rabbit does not matter.
There is a rabbit playing a stage system action game. In this game, every stage has a difficulty level. The rabbit, which always needs challenges, basically wants to play more difficult stages than he has ever played. However, he sometimes needs rest too. So, to compromise, he admitted to play T or less levels easier stages than the preceding one.
How many ways are there to play all the stages at once, while honoring the convention above? Maybe the answer will be a large number. So, let me know the answer modulo 1,000,000,007.
Input
The first line of input contains two integers N and T (1 ≤ N ≤ 100,000, 1 ≤ T ≤ 10,000). N is the number of stages, and T is the compromise level.
The following N lines describe the difficulty levels of each stage. The i-th line contains one integer Di (1 ≤ Di ≤ 100,000), which is the difficulty level of the i-th stage.
Output
Calculate how many ways to play all the stages at once there are. Print the answer modulo 1,000,000,007 in a line.
Examples
Input
3 1
1
2
3
Output
4
Input
5 3
9
2
6
8
8
Output
24
Input
5 7
9
9
9
1
5
Output
48
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> VI;
typedef vector<VI> VVI;
const double PI = 3.14159265358979323846;
const double EPS = 1e-12;
const int INF = numeric_limits<int>::max() / 2;
const int NEG_INF = numeric_limits<int>::min() / 2;
const ll MOD = 1000000007;
int binsearch_lower_bound(vector<int>& vec, int val) {
int low = 0; // テァツッツ?・ツ崢イテ」ツ?ョテ、ツクツ凝ゥツ卍?
int high = vec.size(); // テァツッツ?・ツ崢イテ」ツ?ョテ、ツクツ甘ゥツ卍静」ツ?づィツァツ」テ」ツ?ッテ」ツ?づ」ツつ古」ツ?ー [low, high] テ」ツ?ョテ、ツクツュテ」ツ?ォテ・ツュツ佚・ツ慊ィテ」ツ?凖」ツつ?
while (low < high) {
int mid = (low + high) / 2; // テ、ツクツュテ・ツソツεァツつケテッツシツ暗」ツ?禿」ツ?ョテ・ツョツ淌ィツ」ツ?」ツ?ァテ」ツ?ッテ」ツつェテ」ツδシテ」ツδ静」ツδシテ」ツδ陛」ツδュテ」ツδシテ」ツ?療」ツ??」ツつ凝」ツ??
// テ」ツ??・ツ篠ウテ・ツッツ?」ツ?ォテ」ツ?ッ mid=low+(high-low)/2 テ」ツ?ィテ」ツ?凖」ツ?ケテ」ツ?催ッツシツ?
int midval = vec[mid]; // テ、ツクツュテ・ツソツε」ツ?ァテ」ツ?ョテ・ツ?、
// ティツァツ」テ」ツ?ョテァツッツ?・ツ崢イテ」ツつ津ァツ仰ュテ」ツつ?」ツつ?
if (midval < val) low = mid + 1;
else high = mid;
}
return low;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n,t;
cin >> n >> t;
std::vector<int> v;
for(int i=0;i<n;i++){
int d;
cin >> d;
v.push_back(d);
}
sort(v.begin(),v.end());
ll res=1;
for(int i=1;i<n;i++){
if(v[i-1]>=v[i]-t){
int idx=binsearch_lower_bound(v,v[i]-t);
res = (res*(i-idx+1))%MOD;
}
}
cout << res << endl;
}
|
D - Medical Inspection
Problem Statement
The government has declared a state of emergency due to the MOFU syndrome epidemic in your country. Persons in the country suffer from MOFU syndrome and cannot get out of bed in the morning. You are a programmer working for the Department of Health. You have to take prompt measures.
The country consists of n islands numbered from 1 to n and there are ocean liners between some pair of islands. The Department of Health decided to establish the quarantine stations in some islands and restrict an infected person's moves to prevent the expansion of the epidemic. To carry out this plan, there must not be any liner such that there is no quarantine station in both the source and the destination of the liner. The problem is the department can build at most K quarantine stations due to the lack of budget.
Your task is to calculate whether this objective is possible or not. And if it is possible, you must calculate the minimum required number of quarantine stations.
Input
The test case starts with a line containing three integers N (2 \leq N \leq 3{,}000), M (1 \leq M \leq 30{,}000) and K (1 \leq K \leq 32). Each line in the next M lines contains two integers a_i (1 \leq a_i \leq N) and b_i (1 \leq b_i \leq N). This represents i-th ocean liner connects island a_i and b_i. You may assume a_i \neq b_i for all i, and there are at most one ocean liner between all the pairs of islands.
Output
If there is no way to build quarantine stations that satisfies the objective, print "Impossible" (without quotes). Otherwise, print the minimum required number of quarantine stations.
Sample Input 1
3 3 2
1 2
2 3
3 1
Output for the Sample Input 1
2
Sample Input 2
3 3 1
1 2
2 3
3 1
Output for the Sample Input 2
Impossible
Sample Input 3
7 6 5
1 3
2 4
3 5
4 6
5 7
6 2
Output for the Sample Input 3
4
Sample Input 4
10 10 10
1 2
1 3
1 4
1 5
2 3
2 4
2 5
3 4
3 5
4 5
Output for the Sample Input 4
4
Example
Input
3 3 2
1 2
2 3
3 1
Output
2
|
#include<iostream>
#include<bitset>
#include<vector>
#include<numeric>
#include<algorithm>
using namespace std;
typedef bitset<300000/10> BS;
BS absbs;
BS is[3000];
vector<int> idx;
int a[32345],b[32345];
int rec(const BS &bs,int nth,int r){
if(r<0)return r;
if(bs==absbs)return r;
while((is[idx[nth]]&~bs).none()){
nth++;
}
BS n=is[idx[nth]]&~bs;
if(n.count()==1){
for(int i=0;;i++){
if(n[i]){
return rec(bs|is[a[i]^b[i]^idx[nth]],nth+1,r-1);
}
}
}else{
int rv=rec(bs|is[idx[nth]],nth+1,r-1);
BS o=bs;
int c=0;
for(int i=0;n.any();i++){
if(n[i]){
o|=bs|is[a[i]^b[i]^idx[nth]];
c++;
n[i]=false;
}
}
return max(rv,rec(o,nth+1,r-c));
}
}
int main(){
int N,M,K;
cin>>N>>M>>K;
int pop[32345]={};
for(int i=0;i<M;i++){
absbs[i]=true;
cin>>a[i]>>b[i];
a[i]--;
b[i]--;
pop[a[i]]++;
pop[b[i]]++;
is[a[i]][i]=true;
is[b[i]][i]=true;
}
idx.resize(N);
iota(begin(idx),end(idx),0);
sort(begin(idx),end(idx),[pop](int a,int b){
return pop[a]>pop[b];
});
int r=rec(BS(),0,K);
if(r<0){
cout<<"Impossible"<<endl;
}else{
cout<<K-r<<endl;
}
}
|
A pitch-black room
When I woke up, Mr. A was in a pitch-black room. Apparently, Mr. A got lost in a dungeon consisting of N rooms. You couldn't know which room A got lost in, but fortunately he got a map of the dungeon. Let's show A the way to go and lead to a bright room.
It is known that M of the N rooms are pitch black, and the D_1, D_2, ..., and D_Mth rooms are pitch black, respectively. Also, there are exactly K one-way streets from all the rooms in order, and the roads from the i-th room are v_ {i, 1}, v_ {i, 2}, ..., v_ {i, respectively. , K} Connected to the third room. You can follow the a_1, a_2, ..., a_lth roads in order from the room you are in for Mr. A. However, when Mr. A reaches the bright room, he ignores the subsequent instructions. You cannot know the information of the room where Mr. A is currently before and after the instruction, so you must give the instruction sequence so that you can reach the bright room no matter which room you are in. Answer the length of the shortest of such instructions.
Constraints
* 2 ≤ N ≤ 100
* 1 ≤ M ≤ min (16, N − 1)
* 1 ≤ K ≤ N
* 1 ≤ D_i ≤ N
* D_i are all different
* 1 ≤ v_ {i, j} ≤ N
* All dark rooms can reach at least one bright room
Input Format
Input is given from standard input in the following format.
NMK
D_1 D_2 ... D_M
v_ {1,1} v_ {1,2} ... v_ {1,K}
v_ {2,1} v_ {2,2} ... v_ {2, K}
...
v_ {N, 1} v_ {N, 2} ... v_ {N, K}
Output Format
Print the answer in one line.
Sample Input 1
4 2 2
1 2
twenty four
3 1
4 2
13
Sample Output 1
2
<image>
If you give the instruction 1, 1
* If A's initial position is room 1, the second move will reach room 3.
* If A's initial position is room 2, the first move will reach room 3.
Sample Input 2
3 2 2
1 2
twenty three
1 2
twenty one
Sample Output 2
3
<image>
If you give instructions 2, 1, 2
* If A's initial position is room 1, the first move will reach room 3.
* If A's initial position is room 2, the third move will reach room 3.
Sample Input 3
6 3 3
one two Three
4 1 1
2 5 2
3 3 6
4 4 4
5 5 5
6 6 6
Sample Output 3
3
<image>
Beware of unconnected cases and cases with self-edges and multiple edges.
Example
Input
4 2 2
1 2
2 4
3 1
4 2
1 3
Output
2
|
#include <iostream>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <queue>
using RoomInfo = std::pair<long long, long long>; //どの部屋に残っているか
using Node = std::pair<RoomInfo, int>; // first, second:cost
namespace std {
template <>
class hash<std::pair<long long, long long>> {
public:
size_t operator()(const std::pair<long long, long long>& x) const {
return hash<long long>()(x.first) ^ hash<long long>()(x.second);
}
};
template <>
class hash<std::pair<RoomInfo, int>> {
public:
size_t operator()(const std::pair<RoomInfo, int>& x) const {
return hash<RoomInfo>()(x.first) ^ hash<int>()(x.second);
}
};
}
int main() {
int n, m, k;
std::vector<int> d; // is darkroom
int e[100][100];
std::queue<Node> q;
std::unordered_map<RoomInfo, std::vector<RoomInfo>> g; //from, to
std::unordered_set<RoomInfo> visited;
std::cin >> n >> m >> k;
if (m == 0) {
std::cout << 0 << std::endl; // すべて明るい
return 0;
}
d.resize(n, 0);
for (int i = 0; i < m; i++) {
int a;
std::cin >> a;
d[a-1] = 1;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
int a;
std::cin >> a;
e[i][j] = a-1; // i番目の部屋からj番目の道でaに行く
}
}
// グラフを作成
RoomInfo node;
for (int i = 0; i < n; i++) {
if (d[i]) {
if (i < 64) {
node.first |= 1ull << i;
}
else {
node.second |= 1ull << (i - 64);
}
}
}
q.push(std::make_pair(node, 0));
visited.insert(node);
while (!q.empty()) {
auto node = q.front(); q.pop();
node.second++;
// i番目の道を使用
for (int i = 0; i < k; i++) {
RoomInfo next = std::make_pair(0, 0);
// j番目の部屋から移動
for (int j = 0; j < n; j++) {
// 居なければcontinue;
if (j < 64) {
if (!(node.first.first & 1ull << j)) continue;
}
else {
if (!(node.first.second & 1ull<< (j - 64))) continue;
}
int to = e[j][i];
// 移動先も暗い部屋
if (d[to]) {
if (to < 64) next.first |= 1ull << to;
else next.second |= 1ull << (to - 64);
}
}
if (!next.first && !next.second) {
std::cout << node.second << std::endl;
return 0;
}
if (!visited.count(next)) {
q.push(std::make_pair(next, node.second));
visited.insert(next);
}
}
}
return 0;
}
|
Intersections of Crossing Path City are aligned to a grid. There are $N$ east-west streets which are numbered from 1 to $N$, from north to south. There are also $N$ north-south streets which are numbered from 1 to $N$, from west to east. Every pair of east-west and north-south streets has an intersection; therefore there are $N^2$ intersections which are numbered from 1 to $N^2$.
Surprisingly, all of the residents in the city are Ninja. To prevent outsiders from knowing their locations, the numbering of intersections is shuffled.
You know the connections between the intersections and try to deduce their positions from the information. If there are more than one possible set of positions, you can output any of them.
Input
The input consists of a single test case formatted as follows.
$N$
$a_1$ $b_1$
...
$a_{2N^2−2N}$ $\;$ $b_{2N^2−2N}$
The first line consists of an integer $N$ ($2 \leq N \leq 100$). The following $2N^2 - 2N$ lines represent connections between intersections. The ($i+1$)-th line consists of two integers $a_i$ and $b_i$ ($1 \leq a_i, b_i \leq N^2, a_i \ne b_i$), which represent that the $a_i$-th and $b_i$-th intersections are adjacent. More precisely, let's denote by ($r, c$) the intersection of the $r$-th east-west street and the $c$-th north-south street. If the intersection number of ($r,c$) is $a_i$ for some $r$ and $c$, then the intersection number of either ($r-1, c$), ($r+1, c$), ($r, c-1$) or ($r, c+1$) must be $b_i$. All inputs of adjacencies are different, i.e., ($a_i, b_i$) $\ne$ ($a_j, b_j$) and ($a_i, b_i$) $\ne$ ($b_j, a_j$) for all $1 \leq i < j \leq 2N^2-2N$. This means that you are given information of all adjacencies on the grid.
The input is guaranteed to describe a valid map.
Output
Print a possible set of positions of the intersections. More precisely, the output consists of $N$ lines each of which has space-separated $N$ integers. The $c$-th integer of the $r$-th line should be the intersection number of ($r, c$).
If there are more than one possible set of positions, you can output any of them.
Examples
Input
3
1 2
4 7
8 6
2 3
8 9
5 3
4 6
5 6
7 8
1 4
2 6
5 9
Output
7 4 1
8 6 2
9 5 3
Input
4
12 1
3 8
10 7
13 14
8 2
9 12
6 14
11 3
3 13
1 10
11 15
4 15
4 9
14 10
5 7
2 5
6 1
14 5
16 11
15 6
15 13
9 6
16 4
13 2
Output
8 2 5 7
3 13 14 10
11 15 6 1
16 4 9 12
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) FOR(i,0,n)
#define pb emplace_back
typedef long long ll;
typedef pair<int,int> pint;
int ans[101][101];
vector<int> g[10001];
bool used[10001];
const int dx[]={1,0,-1,0},dy[]={0,1,0,-1};
int main(){
int n,ai,bi;
cin>>n;
int m=2*n*n-2*n;
rep(i,m){
cin>>ai>>bi;
--ai,--bi;
g[ai].pb(bi);
g[bi].pb(ai);
}
int cur=0;
rep(i,m){
if(g[i].size()==2){
cur=i;break;
}
}
int tx=0,ty=0,id=0;
while(1){
ans[ty][tx]=cur+1;
used[cur]=true;
ty=ty+dy[id],tx=tx+dx[id];
rep(i,g[cur].size()){
if(g[g[cur][i]].size()==2&&!used[g[cur][i]]){
cur=g[cur][i];
++id;
break;
}
else if(g[g[cur][i]].size()==3&&!used[g[cur][i]]){
cur=g[cur][i];break;
}
}
if(tx==0&&ty==0) break;
}
FOR(i,1,n-1)FOR(j,1,n-1){
int t1=ans[i-1][j]-1,t2=ans[i][j-1]-1;
map<int,int> mp;
rep(k,g[t1].size()) ++mp[g[t1][k]];
rep(k,g[t2].size()) ++mp[g[t2][k]];
for(auto it:mp)if(it.second==2&&!used[it.first]){
ans[i][j]=it.first+1;used[it.first]=true;
break;
}
}
rep(i,n){
rep(j,n) cout<<ans[i][j]<<" ";
cout<<endl;
}
return 0;
}
|
I: Add
Problem Statement
Mr. T has had an integer sequence of N elements a_1, a_2, ... , a_N and an integer K. Mr. T has created N integer sequences B_1, B_2, ... , B_N such that B_i has i elements.
* B_{N,j} = a_j (1 \leq j \leq N)
* B_{i,j} = K \times B_{i+1,j} + B_{i+1,j+1} (1\leq i \leq N-1, 1 \leq j \leq i)
Mr. T was so careless that he lost almost all elements of these sequences a and B_i. Fortunately, B_{1,1}, B_{2,1}, ... , B_{N,1} and K are not lost. Your task is to write a program that restores the elements of the initial sequence a for him. Output the modulo 65537 of each element instead because the absolute value of these elements can be extremely large. More specifically, for all integers i (1 \leq i \leq N), output r_i that satisfies r_i $\equiv$ a_i $ \bmod \;$ 65537, 0 \leq r_i < 65537. Here, we can prove that the original sequence Mr. T had can be uniquely determined under the given constraints.
Input
T
N_1 K_1
C_{1,1} C_{1,2} ... C_{1,N}
N_2 K_2
C_{2,1} C_{2,2} ... C_{2,N}
:
N_T K_T
C_{T,1} C_{T,2} ... C_{T,N}
The first line contains a single integer T that denotes the number of test cases. Each test case consists of 2 lines. The first line of the i-th test case contains two integers N_i and K_i. The second line of the i-th test case contains N_i integers C_{i,j} (1 \leq j \leq N_i). These values denote that N = N_i , K = K_i , B_{j,1} = C_{i,j} (1 \leq j \leq N_i) in the i-th test case.
Constraints
* 1 \leq T \leq 10
* 1 \leq N \leq 50000
* |K| \leq 10^9
* |B_{i,1}| \leq 10^9
* All input values are integers.
Output
Output T lines. For the i-th line, output the answer for the i-th test case a_1, a_2, ..., a_N in this order. Each number must be separated by a single space.
Sample Input 1
2
3 0
1 2 3
3 1
1 2 3
Output for Sample Input 1
3 2 1
3 65536 0
Example
Input
2
3 0
1 2 3
3 1
1 2 3
Output
3 2 1
3 65536 0
|
#include <bits/stdc++.h>
#define ll long long
#define maxn 150005 /*rem*/
#define mod 65537
#define db double
#define vi vector<int>
#define pb push_back
#define mp make_pair
#define pi pair<int, int>
#define fi first
#define se second
using namespace std;
ll ksm(ll a, ll b) {
if (!b) return 1;
ll ns = ksm(a, b >> 1);
ns = ns * ns % mod;
if (b & 1) ns = ns * a % mod;
return ns;
}
inline int add(int a, int b) {
a += b;
return (a < mod) ? a : (a - mod);
}
inline int sub (int a, int b) {
a -= b;
return (a < 0) ? a + mod : a;
}
inline int mul(int a, int b) {
return (ll)a * b % mod;
}
int power(int a, int b) {
if (!b) return 1;
int u = power(a, b >> 1);
u = mul(u, u);
if (b & 1) u = mul(u, a);
return u;
}
vi rev, roots;
int mx = -1;
void init() {
mx = 16;
roots.resize(1 << mx);
for (int j = 1; j <= mx; j++) {
int mn = power(3, (mod - 1) >> j);
for (int i = 0; i < (1 << (j - 1)); i++) {
int npl = (1 << (j - 1)) | i;
if (i == 0) roots[npl] = 1;
else roots[npl] = mul(mn, roots[npl - 1]);
}
}
}
void calr(int m) {
rev.resize(1 << m);
if (mx == -1) init();
rev[0] = 0;
for (int j = 0; j < m; j++)
for (int k = 0; k < (1 << j); k++)
rev[k | (1 << j)] = rev[k] + (1 << (m - j - 1));
}
void dft(vi& a) {
int n = a.size(), r = 0; // 保证 a 是 2 幂
while ((1 << r) < n) r++;
calr(r);
for (int i = 0; i < n; i++)
if (rev[i] > i)
swap(a[rev[i]], a[i]);
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j += (i << 1)) {
for (int k = 0; k < i; k++) {
int mr = mul(a[i + j + k], roots[i + k]);
a[i + j + k] = sub(a[j + k], mr);
a[j + k] = add(a[j + k], mr);
}
}
}
}
vi mul1(vi a, vi b) {
int l = a.size() + b.size() - 1;
int r = 0;
while ((1 << r) < l) r++;
a.resize(1 << r), b.resize(1 << r);
dft(a);
dft(b);
int bk = power(1 << r, mod - 2);
for (int i = 0; i < (1 << r); i++)
a[i] = mul(mul(a[i], b[i]), bk);
reverse(a.begin() + 1, a.end());
dft(a);
a.resize(l);
return a;
}
vi mult(vi a, vi b) {
int dv = (a.size() / 2);
vi fn(a.size() + b.size() - 1);
vi u[2][2];
vi t[2] = {a, b};
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
if (k == 0) {
u[j][k].resize(dv);
for (int s = 0; s < dv; s++)
u[j][k][s] = t[j][s];
}
else {
u[j][k].resize(t[j].size() - dv);
for (int s = dv; s < t[j].size(); s++)
u[j][k][s - dv] = t[j][s];
}
}
}
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++) {
vi f1 = mul1(u[0][j], u[1][k]);
for (int m = 0; m < f1.size(); m++) {
int id = m + (j + k) * dv;
fn[id] = add(fn[id], f1[m]);
}
}
return fn;
}
void otp(vi a) {
for (int i = 0; i < a.size(); i++)
printf("%d ", a[i]);
printf("\n");
}
ll jc[maxn], bjc[maxn];
int b[maxn];
int a[maxn];
int main() {
int t;
cin >> t;
jc[0] = bjc[0] = 1;
for (int i = 1; i < maxn; i++)
jc[i] = jc[i - 1] * i % mod,
bjc[i] = ksm(jc[i], mod - 2);
for (int i = 0; i < t; i++) {
int n, m;
cin >> n >> m;
for (int j = n - 1; j >= 0; j--) {
scanf("%d", &b[j]);
b[j] %= mod;
if (b[j] < 0) b[j] += mod;
}
m %= mod;
if (!m)
for (int j = 0; j < n; j++) a[j] = b[j];
else {
if (m < 0) m += mod;
m = mod - m;
ll bk = ksm(m, mod - 2);
vi g(n), h(n);
for (int j = 0; j < n; j++)
h[j] = bjc[j],
g[j] = mul(mul(b[j], bjc[j]), ksm(bk, j));
vi fn;
if (n <= 20000) fn = mul1(g, h);
else fn = mult(g, h);
for (int j = 0; j < n; j++)
a[j] = mul(mul(fn[j], ksm(m, j)), jc[j]);
}
for (int j = 0; j < n; j++) {
printf("%d", a[j]);
if (j != n - 1) printf(" ");
else printf("\n");
}
}
return 0;
}
/*
10
3 1 1 2 3
1 1 1
*/
|
The goal of the matrix-chain multiplication problem is to find the most efficient way to multiply given $n$ matrices $M_1, M_2, M_3,...,M_n$.
Write a program which reads dimensions of $M_i$, and finds the minimum number of scalar multiplications to compute the maxrix-chain multiplication $M_1M_2...M_n$.
Constraints
* $1 \leq n \leq 100$
* $1 \leq r, c \leq 100$
Input
In the first line, an integer $n$ is given. In the following $n$ lines, the dimension of matrix $M_i$ ($i = 1...n$) is given by two integers $r$ and $c$ which respectively represents the number of rows and columns of $M_i$.
Output
Print the minimum number of scalar multiplication in a line.
Example
Input
6
30 35
35 15
15 5
5 10
10 20
20 25
Output
15125
|
# -*- coding: utf-8 -*-
N = int(input())
p = [0 for _ in range(N+1)]
p[0], p[1] = map(int, input().split())
for n in range(2, N+1):
p[n] = list(map(int, input().split()))[1]
M = [[0]*(N+1) for _ in range(N+1)]
for n in range(N+1):
M[n][n] = 0
for l in range(2, N+1):
for i in range(1, N-l+2):
j = i + l - 1
M[i][j] = float("inf")
for k in range(i, j):
M[i][j] = min(M[i][j], M[i][k] + M[k+1][j] + p[i-1]*p[k]*p[j])
print(M[1][N])
|
For given two sides of a triangle a and b and the angle C between them, calculate the following properties:
* S: Area of the triangle
* L: The length of the circumference of the triangle
* h: The height of the triangle with side a as a bottom edge
Input
The length of a, the length of b and the angle C are given in integers.
Output
Print S, L and h in a line respectively. The output should not contain an absolute error greater than 10-4.
Example
Input
4 3 90
Output
6.00000000
12.00000000
3.00000000
|
import math
pi=math.pi
a,b,si=map(float,input().split())
S=(1/2)*a*b*math.sin(math.radians(si))
c2=a*a+b*b-2*a*b*math.cos(math.radians(si))
L=a+b+math.sqrt(c2)
h=(2*S)/a
print(S)
print(L)
print(h)
|
A valid parentheses sequence is a non-empty string where each character is either '(' or ')', which satisfies the following constraint:
You can find a way to repeat erasing adjacent pairs of parentheses '()' until it becomes empty.
For example, '(())' and '()((()()))' are valid parentheses sequences, but ')()(' and '(()' are not.
Mike has a valid parentheses sequence. He really likes everything about his sequence, except the fact that it is quite long. So Mike has recently decided that he will replace his parentheses sequence with a new one in the near future. But not every valid parentheses sequence will satisfy him. To help you understand his requirements we'll introduce the pseudocode of function F(S):
FUNCTION F( S - a valid parentheses sequence )
BEGIN
balance = 0
max_balance = 0
FOR index FROM 1 TO LENGTH(S)
BEGIN
if S[index] == '(' then balance = balance + 1
if S[index] == ')' then balance = balance - 1
max_balance = max( max_balance, balance )
END
RETURN max_balance
END
In other words, F(S) is equal to the maximal balance over all prefixes of S.
Let's denote A as Mike's current parentheses sequence, and B as a candidate for a new one. Mike is willing to replace A with B if F(A) is equal to F(B). He would also like to choose B with the minimal possible length amongst ones satisfying the previous condition. If there are several such strings with the minimal possible length, then Mike will choose the least one lexicographically, considering '(' to be less than ')'.
Help Mike!
Input
The first line of the input contains one integer T denoting the number of testcases to process.
The only line of each testcase contains one string A denoting Mike's parentheses sequence. It is guaranteed that A only consists of the characters '(' and ')'. It is also guaranteed that A is a valid parentheses sequence.
Output
The output should contain exactly T lines, one line per each testcase in the order of their appearance. The only line of each testcase should contain one string B denoting the valid parentheses sequence that should be chosen by Mike to replace A.
Constraints
1 ≤ T ≤ 5;
1 ≤ |A| ≤ 100000(10^5).
Example
Input:
1
()((()()))
Output:
((()))
|
def f(s):
balance = 0
max_balance =0
for i in range(len(s)):
if s[i] == '(': balance +=1
if s[i] == ')': balance -=1
max_balance = max(max_balance,balance)
return max_balance
for _ in range(input()):
k = ""
for i in range(f(str(raw_input()))):
k = '('+k+')'
print k
|
After a long time, Chef has finally decided to renovate his house. Chef's house has N rooms in it numbered from 1 to N. Each room is currently painted in one of the red, blue or green colors. Your are given configuration of colors of his house by a string S consisting of N characters. In this string, color red will be denoted by 'R', green by 'G' and blue by 'B'.
Chef does not like current painting configuration that much and would like to repaint the house such that each room has same color.
For painting, Chef has all the 3 color paints available and mixing any 2 color paints will result into 3rd color paint i.e
R + B = G
B + G = R
G + R = B
For example, painting a room having red color before with green color paint will make the color of room blue.
Also, Chef has many buckets of paint of each color. Simply put, you can assume that he will not run out of paint.
Being extraordinary lazy, our little chef does not want to work much and therefore, he has asked you to find the minimum number of rooms he has to repaint (possibly zero) in order to have all the rooms with same color. Can you please help him?
Input
First line of input contains a single integer T denoting the number of test cases. First line of each test case contains an integer N denoting the number of rooms in the chef's house. Next line of each test case contains a string S denoting the current color configuration of rooms.
Output
For each test case, Print the minimum number of rooms need to be painted in order to have all the rooms painted with same color i.e either red, blue or green.
Constraints
1 ≤ T ≤ 10
1 ≤ N ≤ 10^5
Si = {'R','G','B'}
Scoring
Example
Input
3
3
RGR
3
RRR
3
RGB
Output
1
0
2
Explanation:
Test 1: Chef prefers to paint room 2 with blue color such that the resulting color will be red and all the rooms have same color i.e red.
Test 2: Given configuration has all the rooms painted with red color and therefore, chef does not need to do painting work at all.
Test 3: One possible way of renovation is to paint room 1 with green color, room 2 with red color such that all rooms have same color i.e blue.
|
for _ in xrange(input()):
l = []
n = input()
s = raw_input()
l.append(s.count('R'))
l.append(s.count('G'))
l.append(s.count('B'))
l.remove(max(l))
print sum(l)
|
Note: For Turbo C++, select "Text" as your language
Problem description:
ProCon Junior gives you chance to earn points for admission in IIIT Delhi. So, it is not easy to get points. If you solve this problem you are one more step closer to earn points. Solve this problem and earn points.
Problem:
In IIIT Delhi we play lot of games and Balls is one of them. In this game the winner is one who scores maximum points at the end of game. Game has various levels. You will be given name of player who wins the round and his/her score after each round. Rest of the players are given 0 score for that round. After the end of all the rounds points of all players are calculated and the one with the maximum score wins the game.
Now, you need to tell who wins the game. It is guaranteed that there is only 1 winner. Good luck !!!!!
Input
First line contains T denoting number of test cases.
First line of each contains N denoting number of rounds.
Next N line contains space separated string and an integer denoting name of the winner of that round and his score in that round.
Output
For each test case output a single line containing the name of the winner of the game and his/her final score.
Constraints
1 ≤ T ≤ 10
No of unique names = 15
1 ≤ N ≤ 100
1 ≤ score[i] ≤ 100
Example
Input:
3
2
Ashish 2
Ayush 3
3
Ashish 2
Ashish 4
Ayush 5
3
Ayush 2
Aneesh 5
Ashish 3
Output:
Ayush 3
Ashish 6
Aneesh 5
Explanation
Test case 1: Since score of Ayush is more after the end of the game, winner is Ayush.
Test case 2: Since score of Ashish is more after the end of the game so the winner is Ashish.
Test case 3: Since score of Aneesh is more after the end of the game, winner is Aneesh.
|
x=input()
for i in range(x):
y=input()
ln=[]
d=dict()
for j in range(y):
n=raw_input()
st=n.split()
name=st[0]
sc=int(st[1])
if name in ln:
new=d[name]+sc
d[name]=new
else:
d[name]=sc
ln.append(name)
max=0
for i in ln:
if d[i]>max:
max=d[i]
name=i
print name+" "+str(max)
|
Chef has the string s of length n consisted of digits 4 and 7.
The string s is called balanced
if there exits such integer x (1 ≤ x ≤ n) that the number of digits 4 in substring s[1; x) is equal to the number of digits 7 in substring s(x; n],
where s[1; x) is the substring from the 1st digit to (x-1)th digit of s, and s(x; n] is the substring from the (x+1)th digit to nth digit of s.
For example, s = 747474 is a balanced string, because s[1; 4) = 747 has one 4 and s(4; 6] = 74 has one 7.
Note that x can be 1 or n and s[1; 1) and s(n; n] denote an empty string.
In one turn Chef can choose any pair of consecutive digits and swap them.
Find for Chef the total number of different balanced string that can be obtained from string s using any (even 0) number of turns.
Print the result modulo 1000000007.
Input
The first line of the input contains one integer T, the number of test cases.
Then T lines follow, each of which contains string s for the corresponding test.
Output
T lines, each of which contains single integer - the answer for the corresponding test modulo 10^9+7.
Constraints
1 ≤ T ≤ 10
1 ≤ n ≤ 5000
Example
Input:
2
47
4477
Output:
1
4
|
mod = 1000000007
fact = [1]
for i in xrange(1,5003):
fact.append((i*fact[i-1])%mod)
inv = []
for j in xrange(5003):
nv = pow(fact[j] , mod-2 , mod)
inv.append(nv)
for j in xrange(int(raw_input())):
l = raw_input()
four = l.count('4')
seven = l.count('7')
if (four == 0 or seven == 0 ):
print 1
else:
ans = (fact[len(l)]*inv[four]*inv[len(l) - four])%mod
ans = (ans - fact[len(l)-2]*inv[four-1]*inv[len(l)-1-four])%mod
print ans%mod
|
An integer is said to be a palindrome if it is equal to its
reverse. For example, 79197 and 324423 are palindromes. In this task
you will be given an integer N, 1 ≤ N ≤ 1000000. You must find
the smallest integer M ≥ N such that M is a prime number and M is a
palindrome.
For example, if N is 31 then the answer is 101.
Input
A single integer N, (1 ≤ N ≤ 1000000), on a single line.
Output
Your output must consist of a single integer, the smallest prime
palindrome greater than or equal to N.
Example
Input:
31
Output:
101
|
import math
n=input()
if n&1==0:
n+=1
found=0
def checkPrime(x):
if x<=1:
return 0
if x%2==0:
return 0
else:
root=int(math.sqrt(x))+1
for i in range(3,root,2):
if x%i==0:
return 0
else:
return 1
while not found:
if checkPrime(n):
if str(n)==str(n)[::-1]:
print n
found=1
else:
n+=2
else:
n+=2
|
Given the lengths of the edges of a tetrahedron
calculate the radius of a sphere inscribed in that tetrahedron
(i.e. a sphere tangent to all the faces).
Input
An integer t, 1 ≤ t ≤ 30, denoting the number of test cases, followed by t lines, each containing 6 integers describing the lengths of the edges of a tetrahedron
separated by single spaces. The edges are not longer than 1000 and
for the tetrahedron WXYZ, the order of the edges is: WX, WY, WZ, XY, XZ, YZ.
Output
t lines, each consisting of a real number given with four digits decimal precision
equal to the radius of a sphere inscribed in the given tetrahedron.
Example
Input:
2
1 1 1 1 1 1
1000 999 998 5 5 6
Output:
0.2041
1.4189
|
# tetra.py
def area(a,b,c):
s = 0.5*(a+b+c)
answer = ( s * (s-a) * (s-b) * (s-c) )**0.5
return answer
def determinant( x ):
# assumes x is a square matrix
if len(x)==1:
return x[0][0]
if len(x)==2:
return x[0][0]*x[1][1] - x[0][1]*x[1][0]
row = [0]*(len(x)-1)
# expand on row #0
answer = 0
sign = 1
for i in range(len(x)): # for each column in row0
submatrix = []
for j in range(1,len(x)): # for each row after row 0
submatrix.append( x[j][:i] + x[j][i+1:] ) # jth row without col i
answer += sign * x[0][i] * determinant( submatrix )
sign = -sign
return answer
t = int(raw_input())
for iter in range(t):
WX, WY, WZ, XY, XZ, YZ = map(int, raw_input().split())
d12= WX
d13= WY
d14= WZ
d23= XY
d24= XZ
d34= YZ
matrix = [ [ 0, d12*d12, d13*d13, d14*d14, 1] ]
matrix.append( [d12*d12, 0, d23*d23, d24*d24, 1] )
matrix.append( [d13*d13, d23*d23, 0, d34*d34, 1] )
matrix.append( [d14*d14, d24*d24, d34*d34, 0, 1] )
matrix.append( [ 1, 1, 1, 1, 0] )
det = determinant( matrix )
#print "determinant =", det
volume = (det/288.0) ** 0.5
surface = area(WX, XY, WY)
surface += area(WX, XZ, WZ)
surface += area(WY, YZ, WZ)
surface += area(XY, YZ, XZ)
inradius = 6.0*volume / 2.0/ surface
print "%.4f" % inradius
|
There are two strings s and t, consisting only of letters a and b. You can make the following operation several times: choose a prefix of s, a prefix of t and swap them. Prefixes can be empty, also a prefix can coincide with a whole string.
Your task is to find a sequence of operations after which one of the strings consists only of a letters and the other consists only of b letters. The number of operations should be minimized.
Input
The first line contains a string s (1 ≤ |s| ≤ 2·105).
The second line contains a string t (1 ≤ |t| ≤ 2·105).
Here |s| and |t| denote the lengths of s and t, respectively. It is guaranteed that at least one of the strings contains at least one a letter and at least one of the strings contains at least one b letter.
Output
The first line should contain a single integer n (0 ≤ n ≤ 5·105) — the number of operations.
Each of the next n lines should contain two space-separated integers ai, bi — the lengths of prefixes of s and t to swap, respectively.
If there are multiple possible solutions, you can print any of them. It's guaranteed that a solution with given constraints exists.
Examples
Input
bab
bb
Output
2
1 0
1 3
Input
bbbb
aaa
Output
0
Note
In the first example, you can solve the problem in two operations:
1. Swap the prefix of the first string with length 1 and the prefix of the second string with length 0. After this swap, you'll have strings ab and bbb.
2. Swap the prefix of the first string with length 1 and the prefix of the second string with length 3. After this swap, you'll have strings bbbb and a.
In the second example, the strings are already appropriate, so no operations are needed.
|
#include <bits/stdc++.h>
using namespace std;
void compute(deque<pair<char, int> > ds, deque<pair<char, int> > dt,
vector<array<int, 2> > &ans, int flg) {
int swp = 0;
int totlens = 0;
int totlent = 0;
for (auto x : ds) {
totlens += x.second;
}
for (auto x : dt) {
totlent += x.second;
}
auto perform = [&](int blks, int blkt) {
int lens = 0, lent = 0;
vector<pair<char, int> > vs, vt;
for (int i = 0; i < blks; i++) {
vs.push_back(ds.front());
lens += ds[0].second;
ds.pop_front();
}
for (int i = 0; i < blkt; i++) {
vt.push_back(dt.front());
lent += dt[0].second;
dt.pop_front();
}
if (flg) {
if (swp)
ans.push_back({totlent - lent, totlens - lens});
else
ans.push_back({totlens - lens, totlent - lent});
} else {
if (swp)
ans.push_back({lent, lens});
else
ans.push_back({lens, lent});
}
totlent = totlent - lent + lens;
totlens = totlens - lens + lent;
while (!vt.empty()) {
if (ds.empty() || ds.front().first != vt.back().first)
ds.push_front(vt.back());
else
ds.front().second += vt.back().second;
vt.pop_back();
}
while (!vs.empty()) {
if (dt.empty() || dt.front().first != vs.back().first)
dt.push_front(vs.back());
else
dt.front().second += vs.back().second;
vs.pop_back();
}
};
if (ds[0].first == dt[0].first) {
if (ds.size() > dt.size()) {
swap(totlens, totlent);
swap(ds, dt);
swp ^= 1;
}
int r = (int(dt.size()) - int(ds.size())) / 2;
if (r & 1)
perform(0, r);
else
perform(0, r + 1);
}
while (ds.size() > 1 || dt.size() > 1) {
if (ds.size() > dt.size()) {
swap(totlens, totlent);
swap(ds, dt);
swp ^= 1;
}
if (ds.size() == 1) {
if (dt.size() == 2) {
perform(1, 1);
return;
}
if (dt.size() == 3) {
perform(1, 1);
perform(1, 1);
return;
}
perform(1, 3);
} else if (dt.size() <= 3) {
perform(1, 1);
} else if (ds.size() == 2) {
perform(1, 3);
} else {
perform(1, 1);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout << setprecision(32);
string s, t;
cin >> s >> t;
deque<pair<char, int> > ds;
deque<pair<char, int> > dt;
for (auto ch : s) {
if (ds.empty() || ds.back().first != ch)
ds.push_back({ch, 1});
else
ds.back().second++;
}
for (auto ch : t) {
if (dt.empty() || dt.back().first != ch)
dt.push_back({ch, 1});
else
dt.back().second++;
}
vector<array<int, 2> > ans;
if (ds.front().first != dt.front().first) {
compute(ds, dt, ans, false);
} else if (ds.back().first != dt.back().first) {
reverse(ds.begin(), ds.end());
reverse(dt.begin(), dt.end());
compute(ds, dt, ans, true);
for (int i = 1; i < ans.size(); i += 2) {
swap(ans[i][0], ans[i][1]);
}
} else {
compute(ds, dt, ans, false);
}
cout << ans.size() << '\n';
for (auto x : ans) {
cout << x[0] << " " << x[1] << '\n';
}
return 0;
}
|
The [BFS](https://en.wikipedia.org/wiki/Breadth-first_search) algorithm is defined as follows.
1. Consider an undirected graph with vertices numbered from 1 to n. Initialize q as a new [queue](http://gg.gg/queue_en) containing only vertex 1, mark the vertex 1 as used.
2. Extract a vertex v from the head of the queue q.
3. Print the index of vertex v.
4. Iterate in arbitrary order through all such vertices u that u is a neighbor of v and is not marked yet as used. Mark the vertex u as used and insert it into the tail of the queue q.
5. If the queue is not empty, continue from step 2.
6. Otherwise finish.
Since the order of choosing neighbors of each vertex can vary, it turns out that there may be multiple sequences which BFS can print.
In this problem you need to check whether a given sequence corresponds to some valid BFS traversal of the given tree starting from vertex 1. The [tree](http://gg.gg/tree_en) is an undirected graph, such that there is exactly one simple path between any two vertices.
Input
The first line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) which denotes the number of nodes in the tree.
The following n - 1 lines describe the edges of the tree. Each of them contains two integers x and y (1 ≤ x, y ≤ n) — the endpoints of the corresponding edge of the tree. It is guaranteed that the given graph is a tree.
The last line contains n distinct integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n) — the sequence to check.
Output
Print "Yes" (quotes for clarity) if the sequence corresponds to some valid BFS traversal of the given tree and "No" (quotes for clarity) otherwise.
You can print each letter in any case (upper or lower).
Examples
Input
4
1 2
1 3
2 4
1 2 3 4
Output
Yes
Input
4
1 2
1 3
2 4
1 2 4 3
Output
No
Note
Both sample tests have the same tree in them.
In this tree, there are two valid BFS orderings:
* 1, 2, 3, 4,
* 1, 3, 2, 4.
The ordering 1, 2, 4, 3 doesn't correspond to any valid BFS order.
|
import java.util.*;
import java.io.*;
import java.math.*;
public class Main9
{
static class Pair
{
int x;
int y;
Pair(int x,int y)
{
this.x=x;
this.y=y;
}
}
static int mod=1000000007;
public static int[] sort(int[] a)
{
int n=a.length;
ArrayList<Integer> ar=new ArrayList<>();
for(int i=0;i<a.length;i++)
{
ar.add(a[i]);
}
Collections.sort(ar);
for(int i=0;i<n;i++)
{
a[i]=ar.get(i);
}
return a;
}
public static long pow(long a, long b)
{
long result=1;
while(b>0)
{
if (b % 2 != 0)
{
result=(result*a)%mod;
b--;
}
a=(a*a)%mod;
b /= 2;
}
return result;
}
public static long gcd(long a, long b)
{
if (a == 0)
return b;
return gcd(b%a, a);
}
public static long lcm(long a, long b)
{
return a*(b/gcd(a,b));
}
static ArrayList<ArrayList<Integer>> graph;
static public void main(String args[])throws IOException
{
int tt=1;
StringBuilder sb1=new StringBuilder();
for(int ttt=1;ttt<=tt;ttt++)
{
int n=i();
int[] a=new int[n-1];
int[] b=new int[n-1];
graph=new ArrayList<>();
for(int i=0;i<n;i++)
{
graph.add(new ArrayList<>());
}
for(int i=0;i<n-1;i++)
{
a[i]=i()-1;
b[i]=i()-1;
graph.get(a[i]).add(b[i]);
graph.get(b[i]).add(a[i]);
}
int[] x=new int[n];
for(int i=0;i<n;i++)
{
x[i]=i()-1;
}
Queue<Integer> queue=new LinkedList<>();
boolean[] visited=new boolean[n];
visited[0]=true;
queue.add(0);
int flag=0;
if(x[0]!=0)
{
flag=1;
}
int k=1;
while(queue.isEmpty()==false && flag!=1)
{
int num=queue.poll();
ArrayList<Integer> ar=graph.get(num);
ArrayList<Integer> ar2=new ArrayList<>();
for(int i=0;i<ar.size();i++)
{
if(visited[ar.get(i)]==false)
ar2.add(ar.get(i));
}
ArrayList<Integer> ar1=new ArrayList<>();
int size=ar2.size();
for(int j=k;j<Math.min(k+size,n);j++)
{
ar1.add(x[j]);
}
Collections.sort(ar2);
Collections.sort(ar1);
if(ar2.equals(ar1)==false)
{
flag=1;
break;
}
else
{
for(int j=k;j<Math.min(k+size,n);j++)
{
queue.add(x[j]);
visited[x[j]]=true;
}
}
k=k+size;
}
if(flag==1)
pln("NO");
else
pln("YES");
}
System.out.print(sb1.toString());
}
/**/
static InputReader in=new InputReader(System.in);
static OutputWriter out=new OutputWriter(System.out);
public static long l()
{
String s=in.String();
return Long.parseLong(s);
}
public static void pln(String value)
{
System.out.println(value);
}
public static int i()
{
return in.Int();
}
public static String s()
{
return in.String();
}
}
class InputReader
{
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars== -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public int Int() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String String() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public String next() {
return String();
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void print(Object...objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0)
writer.print(' ');
writer.print(objects[i]);
}
}
public void printLine(Object...objects) {
print(objects);
writer.println();
}
public void close() {
writer.close();
}
public void flush() {
writer.flush();
}
}
class IOUtils {
public static int[] readIntArray(InputReader in, int size) {
int[] array = new int[size];
for (int i = 0; i < size; i++)
array[i] = in.Int();
return array;
}
}
|
You are given a straight half-line divided into segments of unit length, which we will call positions. The positions are numbered by positive integers that start with 1 from the end of half-line, i. e. 1, 2, 3 and so on. The distance between the positions is the absolute difference between the respective numbers.
Laharl, Etna and Flonne occupy some positions on the half-line and they want to get to the position with the largest possible number. They are originally placed in different positions.
Each of the characters can perform each of the following actions no more than once:
* Move a certain distance.
* Grab another character and lift him above the head.
* Throw the lifted character a certain distance.
Each character has a movement range parameter. They can only move to free positions, assuming that distance between those positions doesn't exceed the movement range.
One character can lift another character if the distance between the two characters equals 1, and no one already holds that another character. We can assume that the lifted character moves to the same position as the person who has lifted him, and the position in which he stood before becomes free. A lifted character cannot perform any actions and the character that holds him cannot walk.
Also, each character has a throwing range parameter. It is the distance at which this character can throw the one lifted above his head. He can only throw a character to a free position, and only when there is a lifted character.
We accept the situation when one person grabs another one who in his turn has the third character in his hands. This forms a "column" of three characters. For example, Laharl can hold Etna while Etna holds Flonne. In this case, Etna and the Flonne cannot perform any actions, and Laharl can only throw Etna (together with Flonne) at some distance.
Laharl, Etna and Flonne perform actions in any order. They perform actions in turns, that is no two of them can do actions at the same time.
Determine the maximum number of position at least one of the characters can reach. That is, such maximal number x so that one of the characters can reach position x.
Input
The first line contains three integers: Laharl's position, his movement range and throwing range. The second and the third lines describe Etna's and Flonne's parameters correspondingly in the similar form. It is guaranteed that the three characters occupy distinct positions. All numbers in the input are between 1 and 10, inclusive.
Output
Print a single number — the maximum ordinal number of position which either Laharl, Etna or Flonne can reach.
Examples
Input
9 3 3
4 3 1
2 3 3
Output
15
Note
Let us explain how to reach position 15 in the sample.
Initially Laharl occupies position 9, Etna — position 4 and Flonne — position 2.
First Laharl moves to position 6.
Then Flonne moves to position 5 and grabs Etna.
Laharl grabs Flonne and throws to position 9.
Flonne throws Etna to position 12.
Etna moves to position 15.
|
#include <bits/stdc++.h>
using namespace std;
struct person {
int acc, pos;
bool thr, moved;
};
struct property {
int mrange, trange, ipos;
} P[3];
struct state {
person P[3];
int to_int() {
int res(0);
for (int i = 0; i < 3; ++i) {
if (P[i].pos >= 64) throw logic_error("@L21");
res = (res << 1) | P[i].thr;
res = (res << 1) | P[i].moved;
res = (res << 2) | P[i].acc;
res = (res << 6) | P[i].pos;
}
return res;
}
person &operator[](int p) { return P[p]; }
int check(int p) {
int isfree[3];
for (int i = 0; i < 3; ++i) isfree[i] = true;
for (int i = 0; i < 3; ++i)
if (P[i].acc) isfree[P[i].acc - 1] = false;
for (int i = 0; i < 3; ++i)
if (isfree[i] && P[i].pos == p) return false;
return true;
}
};
unordered_set<int> S;
int res;
void dfs(state s) {
int hval = s.to_int();
if (S.find(hval) != S.end()) return;
S.insert(hval);
for (int i = 0; i < 3; ++i) res = max(res, s[i].pos);
bool isfree[3] = {true, true, true};
for (int i = 0; i < 3; ++i)
if (s[i].acc) isfree[s[i].acc - 1] = false;
for (int i = 0; i < 3; ++i) {
if (!isfree[i]) continue;
if (!s[i].moved && !s[i].acc) {
s[i].moved = true;
for (int d = 1; d <= P[i].mrange; ++d) {
if (!s.check(s[i].pos + d)) continue;
s[i].pos += d;
dfs(s);
s[i].pos -= d;
}
for (int d = 1; d <= P[i].mrange; ++d) {
if (s[i].pos - d < 0) break;
if (!s.check(s[i].pos - d)) continue;
s[i].pos -= d;
dfs(s);
s[i].pos += d;
}
s[i].moved = false;
}
if (!s[i].thr && !s[i].acc) {
for (int j = 0, pbak; j < 3; ++j)
if (j != i && isfree[j] && abs(s[j].pos - s[i].pos) == 1) {
s[i].acc = j + 1;
dfs(s);
s[i].acc = 0;
}
}
if (!s[i].thr && s[i].acc) {
int z = s[i].acc - 1;
s[i].acc = 0;
s[i].thr = true;
for (int d = 1, pbak; d <= P[i].trange; ++d) {
if (!s.check(s[i].pos + d)) continue;
pbak = s[z].pos;
s[z].pos = s[i].pos + d;
dfs(s);
s[z].pos = pbak;
}
s[i].acc = z + 1;
s[i].thr = false;
}
}
}
int main() {
for (int i = 0; i < 3; ++i)
scanf("%d%d%d", &P[i].ipos, &P[i].mrange, &P[i].trange);
sort(P, P + 3,
[](const property &a, const property &b) { return a.ipos < b.ipos; });
state si;
for (int i = 0; i < 3; ++i) {
si[i].thr = si[i].moved = false;
si[i].acc = 0;
si[i].pos = P[i].ipos;
}
dfs(si);
printf("%d\n", res);
fprintf(stderr, "%d\n", S.size());
return 0;
}
|
This is an interactive problem.
Chouti was tired of studying, so he opened the computer and started playing a puzzle game.
Long long ago, the boy found a sequence s_1, s_2, …, s_n of length n, kept by a tricky interactor. It consisted of 0s and 1s only and the number of 1s is t. The boy knows nothing about this sequence except n and t, but he can try to find it out with some queries with the interactor.
We define an operation called flipping. Flipping [l,r] (1 ≤ l ≤ r ≤ n) means for each x ∈ [l,r], changing s_x to 1-s_x.
In each query, the boy can give the interactor two integers l,r satisfying 1 ≤ l ≤ r ≤ n and the interactor will either flip [1,r] or [l,n] (both outcomes have the same probability and all decisions made by interactor are independent from each other, see Notes section for more details). The interactor will tell the current number of 1s after each operation. Note, that the sequence won't be restored after each operation.
Help the boy to find the original sequence in no more than 10000 interactions.
"Weird legend, dumb game." he thought. However, after several tries, he is still stuck with it. Can you help him beat this game?
Interaction
The interaction starts with a line containing two integers n and t (1 ≤ n ≤ 300, 0 ≤ t ≤ n) — the length of the sequence and the number of 1s in it.
After that, you can make queries.
To make a query, print a line "? l r" (1 ≤ l ≤ r ≤ n), then flush the output.
After each query, read a single integer t (-1 ≤ t ≤ n).
* If t=-1, it means that you're out of queries, you should terminate your program immediately, then you will get Wrong Answer, otherwise the judging result would be undefined because you will interact with a closed stream.
* If t ≥ 0, it represents the current number of 1s in the sequence.
When you found the original sequence, print a line "! s", flush the output and terminate. Print s_1, s_2, …, s_n as a binary string and do not print spaces in between.
Your solution will get Idleness Limit Exceeded if you don't print anything or forget to flush the output.
To flush you need to do the following right after printing a query and a line end:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
Hacks
For hacks, use the following format:
In the first and only line, print a non-empty binary string. Its length will be n and it will be treated as s_1, s_2, …, s_n.
For example, the the test corresponding to the example contains a line "0011".
Example
Input
4 2
2
2
0
Output
? 1 1
? 1 1
? 3 4
! 0011
Note
For first query 1,1, the interactor should flip [1,1] or [1,4]. It chose to flip [1,4], so the sequence became 1100.
For second query 1,1, the interactor should flip [1,1] or [1,4]. It again chose to flip [1,4], so the sequence became 0011.
For third query 3,4, the interactor should flip [1,4] or [3,4]. It chose to flip [3,4], so the sequence became 0000.
Q: How does interactor choose between [1,r] and [l,n]? Is it really random?
A: The interactor will use a secret [pseudorandom number generator](https://en.wikipedia.org/wiki/Pseudorandom_number_generator). Only s and your queries will be hashed and used as the seed. So if you give the same sequence of queries twice for the same secret string, you will get the same results. Except this, you can consider the choices fully random, like flipping a fair coin. You needn't (and shouldn't) exploit the exact generator to pass this problem.
|
#include <bits/stdc++.h>
using namespace std;
int s[101010];
int ask(int x, int y) {
printf("? %d %d\n", x, y);
fflush(stdout);
scanf("%d", &x);
return x;
}
void ok(int n) {
int i;
printf("! ");
for (i = 1; i <= n; i++) printf("%d", s[i]);
fflush(stdout);
}
int main() {
int n, t, now, i, shd = 0, tmp, sw = 0, n1, nowi;
scanf("%d%d", &n, &t);
if (n == 1) {
cout << "! " << t << endl;
return 0;
}
now = t;
if (n & 1) {
while (1) {
tmp = ask(2, n);
if (abs(now - tmp) % 2 == 0) break;
sw ^= 1;
now = tmp;
}
shd = n - now;
if (tmp > shd)
s[1] = 1;
else
s[1] = 0;
s[1] ^= sw;
nowi = s[1] ^ sw;
shd = s[1] ^ sw;
sw ^= 1;
now = tmp;
for (i = 1; i < n; i++) {
while (1) {
tmp = ask(i, i + 1);
if (abs(tmp - now) % 2 != i % 2) break;
now = tmp;
if (nowi)
shd--;
else
shd++;
nowi ^= 1;
sw ^= 1;
}
shd = i - shd;
n1 = (i + 1 + tmp - now) / 2;
s[i + 1] = n1 - shd;
shd = n1;
s[i + 1] ^= sw;
s[i + 1] ^= 1;
nowi = s[i + 1] ^ sw ^ 1;
now = tmp;
}
ok(n);
} else {
for (i = 1; i <= n; i++) {
while (1) {
tmp = ask(i, i);
if (abs(now - tmp) % 2 == i % 2) break;
now = tmp;
sw ^= 1;
}
shd = i - 1 - shd;
n1 = (i + tmp - now) / 2;
s[i] = n1 - shd;
shd = n1;
s[i] ^= sw;
s[i] ^= 1;
now = tmp;
}
ok(n);
}
return 0;
}
|
Ivan loves burgers and spending money. There are n burger joints on the street where Ivan lives. Ivan has q friends, and the i-th friend suggested to meet at the joint l_i and walk to the joint r_i (l_i ≤ r_i). While strolling with the i-th friend Ivan can visit all joints x which satisfy l_i ≤ x ≤ r_i.
For each joint Ivan knows the cost of the most expensive burger in it, it costs c_i burles. Ivan wants to visit some subset of joints on his way, in each of them he will buy the most expensive burger and spend the most money. But there is a small issue: his card broke and instead of charging him for purchases, the amount of money on it changes as follows.
If Ivan had d burles before the purchase and he spent c burles at the joint, then after the purchase he would have d ⊕ c burles, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
Currently Ivan has 2^{2^{100}} - 1 burles and he wants to go out for a walk. Help him to determine the maximal amount of burles he can spend if he goes for a walk with the friend i. The amount of burles he spends is defined as the difference between the initial amount on his account and the final account.
Input
The first line contains one integer n (1 ≤ n ≤ 500 000) — the number of burger shops.
The next line contains n integers c_1, c_2, …, c_n (0 ≤ c_i ≤ 10^6), where c_i — the cost of the most expensive burger in the burger joint i.
The third line contains one integer q (1 ≤ q ≤ 500 000) — the number of Ivan's friends.
Each of the next q lines contain two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — pairs of numbers of burger shops between which Ivan will walk.
Output
Output q lines, i-th of which containing the maximum amount of money Ivan can spend with the friend i.
Examples
Input
4
7 2 3 4
3
1 4
2 3
1 3
Output
7
3
7
Input
5
12 14 23 13 7
15
1 1
1 2
1 3
1 4
1 5
2 2
2 3
2 4
2 5
3 3
3 4
3 5
4 4
4 5
5 5
Output
12
14
27
27
31
14
25
26
30
23
26
29
13
13
7
Note
In the first test, in order to spend the maximum amount of money with the first and third friends, Ivan just needs to go into the first burger. With a second friend, Ivan just go to the third burger.
In the second test for a third friend (who is going to walk from the first to the third burger), there are only 8 options to spend money — 0, 12, 14, 23, 12 ⊕ 14 = 2, 14 ⊕ 23 = 25, 12 ⊕ 23 = 27, 12 ⊕ 14 ⊕ 23 = 20. The maximum amount of money it turns out to spend, if you go to the first and third burger — 12 ⊕ 23 = 27.
|
#include <bits/stdc++.h>
using namespace std;
int b[500005], ans[500005];
struct Base {
int a[23], pos[23];
Base() {
for (int i = 0; i < 23; i++) a[i] = 0;
}
void up(int &a, int b) {
if (b > a) a = b;
}
void ins(int x, int r) {
for (int i = 22; ~i; i--)
if (x >> i & 1) {
if (a[i]) {
if (pos[i] < r) {
swap(pos[i], r);
swap(a[i], x);
}
x ^= a[i];
} else {
a[i] = x;
pos[i] = r;
break;
}
}
}
int ask(int r) {
int t = 0;
for (int i = 22; ~i; i--)
if (pos[i] >= r) up(t, t ^ a[i]);
return t;
}
} f;
struct node {
int l, r, idx;
bool operator<(const node &a) const {
if (r == a.r) return l < a.l;
return r < a.r;
}
} e[500005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &e[i].l, &e[i].r);
e[i].idx = i;
}
sort(e + 1, e + 1 + q);
int r = 0;
for (int i = 1; i <= q; i++) {
while (r < n && r < e[i].r) {
r++;
f.ins(b[r], r);
}
ans[e[i].idx] = f.ask(e[i].l);
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
In Morse code, an letter of English alphabet is represented as a string of some length from 1 to 4. Moreover, each Morse code representation of an English letter contains only dots and dashes. In this task, we will represent a dot with a "0" and a dash with a "1".
Because there are 2^1+2^2+2^3+2^4 = 30 strings with length 1 to 4 containing only "0" and/or "1", not all of them correspond to one of the 26 English letters. In particular, each string of "0" and/or "1" of length at most 4 translates into a distinct English letter, except the following four strings that do not correspond to any English alphabet: "0011", "0101", "1110", and "1111".
You will work with a string S, which is initially empty. For m times, either a dot or a dash will be appended to S, one at a time. Your task is to find and report, after each of these modifications to string S, the number of non-empty sequences of English letters that are represented with some substring of S in Morse code.
Since the answers can be incredibly tremendous, print them modulo 10^9 + 7.
Input
The first line contains an integer m (1 ≤ m ≤ 3 000) — the number of modifications to S.
Each of the next m lines contains either a "0" (representing a dot) or a "1" (representing a dash), specifying which character should be appended to S.
Output
Print m lines, the i-th of which being the answer after the i-th modification to S.
Examples
Input
3
1
1
1
Output
1
3
7
Input
5
1
0
1
0
1
Output
1
4
10
22
43
Input
9
1
1
0
0
0
1
1
0
1
Output
1
3
10
24
51
109
213
421
833
Note
Let us consider the first sample after all characters have been appended to S, so S is "111".
As you can see, "1", "11", and "111" all correspond to some distinct English letter. In fact, they are translated into a 'T', an 'M', and an 'O', respectively. All non-empty sequences of English letters that are represented with some substring of S in Morse code, therefore, are as follows.
1. "T" (translates into "1")
2. "M" (translates into "11")
3. "O" (translates into "111")
4. "TT" (translates into "11")
5. "TM" (translates into "111")
6. "MT" (translates into "111")
7. "TTT" (translates into "111")
Although unnecessary for this task, a conversion table from English alphabets into Morse code can be found [here](https://en.wikipedia.org/wiki/Morse_code).
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
int N, n, SA[3003], lcp[3003], arr[3003], rsa[3003];
long long D[3003][3003], T[3003];
char S[3003];
void SuffixArray() {
int i, j, k;
int m = 2;
vector<int> cnt(max(N, m) + 1, 0), first(N + 1, 0), second(N + 1, 0);
for (i = 1; i <= N; i++) cnt[first[i] = S[i] - 'a' + 1]++;
for (i = 1; i <= m; i++) cnt[i] += cnt[i - 1];
for (i = N; i; i--) SA[cnt[first[i]]--] = i;
for (int len = 1, p = 1; p < N; len <<= 1, m = p) {
for (p = 0, i = N - len; ++i <= N;) second[++p] = i;
for (i = 1; i <= N; i++)
if (SA[i] > len) second[++p] = SA[i] - len;
for (i = 0; i <= m; i++) cnt[i] = 0;
for (i = 1; i <= N; i++) cnt[first[second[i]]]++;
for (i = 1; i <= m; i++) cnt[i] += cnt[i - 1];
for (i = N; i; i--) SA[cnt[first[second[i]]]--] = second[i];
swap(first, second);
p = 1;
first[SA[1]] = 1;
for (i = 1; i < N; i++)
first[SA[i + 1]] = SA[i] + len <= N && SA[i + 1] + len <= N &&
second[SA[i]] == second[SA[i + 1]] &&
second[SA[i] + len] == second[SA[i + 1] + len]
? p
: ++p;
}
}
void LCP() {
int i, j, k = 0;
vector<int> rank(N + 1, 0);
for (i = 1; i <= N; i++) rank[SA[i]] = i;
for (i = 1; i <= N; lcp[rank[i++]] = k)
for (k ? k-- : 0, j = SA[rank[i] - 1]; S[i + k] == S[j + k]; k++)
;
}
char bstr[4][5] = {"0011", "0101", "1110", "1111"};
bool bad(int s, int e) {
int i, j;
for (j = 0; j < 4; j++) {
for (i = s; i <= e; i++)
if (bstr[j][i - s] - '0' != arr[i]) break;
if (i == e + 1) return 1;
}
return 0;
}
int rns[3003];
int fin(int idx) {
int i, p;
for (i = 1; i <= n; i++)
if (SA[i] == idx) break;
p = i;
int t = lcp[p];
for (i = p - 1; i; i--) {
rns[SA[i]] = t;
t = min(t, lcp[i]);
}
t = lcp[p + 1];
for (i = p + 1; i <= n; i++) {
rns[SA[i]] = t;
t = min(t, lcp[i + 1]);
}
int maxi = 0;
for (i = 1; i < idx; i++) {
maxi = max(maxi, rns[i]);
}
return idx - maxi;
}
int main() {
int i, j, k;
scanf("%d", &n);
N = n;
for (i = 1; i <= n; i++) scanf("%d", &arr[i]);
for (i = n; i > 0; i--) S[n + 1 - i] = 'a' + arr[i];
SuffixArray();
LCP();
for (i = 1; i <= n; i++) SA[i] = n + 1 - SA[i];
for (i = 1; i <= n; i++) {
for (j = 1; j <= i; j++) {
for (k = 0; k <= 3 && k < i; k++) {
if (k == 3 && bad(i - k, i)) continue;
D[i][j] = (D[i][j] + D[i - k - 1][min(j, i - k - 1)]) % MOD;
if (i - k <= j) D[i][j]++;
}
}
int t = fin(i);
T[i] = (T[i - 1] + D[i][t]) % MOD;
printf("%lld\n", T[i]);
}
return 0;
}
|
Codefortia is a small island country located somewhere in the West Pacific. It consists of n settlements connected by m bidirectional gravel roads. Curiously enough, the beliefs of the inhabitants require the time needed to pass each road to be equal either to a or b seconds. It's guaranteed that one can go between any pair of settlements by following a sequence of roads.
Codefortia was recently struck by the financial crisis. Therefore, the king decided to abandon some of the roads so that:
* it will be possible to travel between each pair of cities using the remaining roads only,
* the sum of times required to pass each remaining road will be minimum possible (in other words, remaining roads must form minimum spanning tree, using the time to pass the road as its weight),
* among all the plans minimizing the sum of times above, the time required to travel between the king's residence (in settlement 1) and the parliament house (in settlement p) using the remaining roads only will be minimum possible.
The king, however, forgot where the parliament house was. For each settlement p = 1, 2, ..., n, can you tell what is the minimum time required to travel between the king's residence and the parliament house (located in settlement p) after some roads are abandoned?
Input
The first line of the input contains four integers n, m, a and b (2 ≤ n ≤ 70, n - 1 ≤ m ≤ 200, 1 ≤ a < b ≤ 10^7) — the number of settlements and gravel roads in Codefortia, and two possible travel times. Each of the following lines contains three integers u, v, c (1 ≤ u, v ≤ n, u ≠ v, c ∈ \\{a, b\}) denoting a single gravel road between the settlements u and v, which requires c minutes to travel.
You can assume that the road network is connected and has no loops or multiedges.
Output
Output a single line containing n integers. The p-th of them should denote the minimum possible time required to travel from 1 to p after the selected roads are abandoned. Note that for each p you can abandon a different set of roads.
Examples
Input
5 5 20 25
1 2 25
2 3 25
3 4 20
4 5 20
5 1 20
Output
0 25 60 40 20
Input
6 7 13 22
1 2 13
2 3 13
1 4 22
3 4 13
4 5 13
5 6 13
6 1 13
Output
0 13 26 39 26 13
Note
The minimum possible sum of times required to pass each road in the first example is 85 — exactly one of the roads with passing time 25 must be abandoned. Note that after one of these roads is abandoned, it's now impossible to travel between settlements 1 and 3 in time 50.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 80, N2 = (1 << 18) + 1;
int cnt, n, m, A, B, fa[N], sz[N], bl[N], dis[N][N2], inq[N][N2], ans[N];
queue<pair<int, int> > q;
vector<pair<int, int> > g[N];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> A >> B;
for (int i = 1; i <= n; ++i) fa[i] = i, sz[i] = 1;
for (int i = 1; i <= m; ++i) {
int x, y, z;
cin >> x >> y >> z;
g[x].emplace_back(y, z);
g[y].emplace_back(x, z);
if (z == A && (x = find(x)) != (y = find(y))) fa[x] = y, sz[y] += sz[x];
}
for (int i = 1; i <= n; ++i)
if (sz[find(i)] >= 4) {
if (!bl[find(i)]) bl[find(i)] = 1 << (cnt++);
bl[i] = bl[find(i)];
}
memset(ans, 0x3f, sizeof ans);
memset(dis, 0x3f, sizeof dis);
dis[1][bl[1]] = 0;
q.emplace(1, bl[1]);
while (!q.empty()) {
auto x = q.front();
q.pop();
inq[x.first][x.second] = 0;
int d = dis[x.first][x.second];
ans[x.first] = min(ans[x.first], d);
for (auto i : g[x.first])
if (i.second == A) {
if (dis[i.first][x.second] > d + i.second) {
dis[i.first][x.second] = d + i.second;
if (!inq[i.first][x.second])
inq[i.first][x.second] = 1, q.emplace(i.first, x.second);
}
} else if (find(x.first) != find(i.first) &&
((x.second & bl[i.first]) == 0)) {
if (dis[i.first][x.second | bl[i.first]] > d + i.second) {
dis[i.first][x.second | bl[i.first]] = d + i.second;
if (!inq[i.first][x.second | bl[i.first]])
inq[i.first][x.second | bl[i.first]] = 1,
q.emplace(i.first, x.second | bl[i.first]);
}
}
}
for (int i = 1; i <= n; ++i) cout << ans[i] << " \n"[i == n];
return 0;
}
|
Consider a sequence of digits of length 2^k [a_1, a_2, …, a_{2^k}]. We perform the following operation with it: replace pairs (a_{2i+1}, a_{2i+2}) with (a_{2i+1} + a_{2i+2})mod 10 for 0≤ i<2^{k-1}. For every i where a_{2i+1} + a_{2i+2}≥ 10 we get a candy! As a result, we will get a sequence of length 2^{k-1}.
Less formally, we partition sequence of length 2^k into 2^{k-1} pairs, each consisting of 2 numbers: the first pair consists of the first and second numbers, the second of the third and fourth …, the last pair consists of the (2^k-1)-th and (2^k)-th numbers. For every pair such that sum of numbers in it is at least 10, we get a candy. After that, we replace every pair of numbers with a remainder of the division of their sum by 10 (and don't change the order of the numbers).
Perform this operation with a resulting array until it becomes of length 1. Let f([a_1, a_2, …, a_{2^k}]) denote the number of candies we get in this process.
For example: if the starting sequence is [8, 7, 3, 1, 7, 0, 9, 4] then:
After the first operation the sequence becomes [(8 + 7)mod 10, (3 + 1)mod 10, (7 + 0)mod 10, (9 + 4)mod 10] = [5, 4, 7, 3], and we get 2 candies as 8 + 7 ≥ 10 and 9 + 4 ≥ 10.
After the second operation the sequence becomes [(5 + 4)mod 10, (7 + 3)mod 10] = [9, 0], and we get one more candy as 7 + 3 ≥ 10.
After the final operation sequence becomes [(9 + 0) mod 10] = [9].
Therefore, f([8, 7, 3, 1, 7, 0, 9, 4]) = 3 as we got 3 candies in total.
You are given a sequence of digits of length n s_1, s_2, … s_n. You have to answer q queries of the form (l_i, r_i), where for i-th query you have to output f([s_{l_i}, s_{l_i+1}, …, s_{r_i}]). It is guaranteed that r_i-l_i+1 is of form 2^k for some nonnegative integer k.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the length of the sequence.
The second line contains n digits s_1, s_2, …, s_n (0 ≤ s_i ≤ 9).
The third line contains a single integer q (1 ≤ q ≤ 10^5) — the number of queries.
Each of the next q lines contains two integers l_i, r_i (1 ≤ l_i ≤ r_i ≤ n) — i-th query. It is guaranteed that r_i-l_i+1 is a nonnegative integer power of 2.
Output
Output q lines, in i-th line output single integer — f([s_{l_i}, s_{l_i + 1}, …, s_{r_i}]), answer to the i-th query.
Examples
Input
8
8 7 3 1 7 0 9 4
3
1 8
2 5
7 7
Output
3
1
0
Input
6
0 1 2 3 3 5
3
1 2
1 4
3 6
Output
0
0
1
Note
The first example illustrates an example from the statement.
f([7, 3, 1, 7]) = 1: sequence of operations is [7, 3, 1, 7] → [(7 + 3)mod 10, (1 + 7)mod 10] = [0, 8] and one candy as 7 + 3 ≥ 10 → [(0 + 8) mod 10] = [8], so we get only 1 candy.
f([9]) = 0 as we don't perform operations with it.
|
import sys
input = lambda: sys.stdin.readline().strip()
from math import log2
n = int(input())
ls = list(map(int, input().split()))
Sum = [0]
for i in ls:
Sum.append(Sum[-1]+i)
q = int(input())
for i in range(q):
a, b = map(int, input().split())
print((Sum[b]-Sum[a-1])//10)
|
Let us define a magic grid to be a square matrix of integers of size n × n, satisfying the following conditions.
* All integers from 0 to (n^2 - 1) inclusive appear in the matrix exactly once.
* [Bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of all elements in a row or a column must be the same for each row and column.
You are given an integer n which is a multiple of 4. Construct a magic grid of size n × n.
Input
The only line of input contains an integer n (4 ≤ n ≤ 1000). It is guaranteed that n is a multiple of 4.
Output
Print a magic grid, i.e. n lines, the i-th of which contains n space-separated integers, representing the i-th row of the grid.
If there are multiple answers, print any. We can show that an answer always exists.
Examples
Input
4
Output
8 9 1 13
3 12 7 5
0 2 4 11
6 10 15 14
Input
8
Output
19 55 11 39 32 36 4 52
51 7 35 31 12 48 28 20
43 23 59 15 0 8 16 44
3 47 27 63 24 40 60 56
34 38 6 54 17 53 9 37
14 50 30 22 49 5 33 29
2 10 18 46 41 21 57 13
26 42 62 58 1 45 25 61
Note
In the first example, XOR of each row and each column is 13.
In the second example, XOR of each row and each column is 60.
|
n = int(input())
for i in range(n):
printlist = []
m=i//4
k=i%4
for j in range(n):
printlist.append(str(4*n*m+4*j+k))
print(' '.join(printlist))
|
You are fed up with your messy room, so you decided to clean it up.
Your room is a bracket sequence s=s_{1}s_{2}... s_{n} of length n. Each character of this string is either an opening bracket '(' or a closing bracket ')'.
In one operation you can choose any consecutive substring of s and reverse it. In other words, you can choose any substring s[l ... r]=s_l, s_{l+1}, ..., s_r and change the order of elements in it into s_r, s_{r-1}, ..., s_{l}.
For example, if you will decide to reverse substring s[2 ... 4] of string s="((()))" it will be equal to s="()(())".
A regular (aka balanced) bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters '1' and '+' between the original characters of the sequence. For example, bracket sequences "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
A prefix of a string s is a substring that starts at position 1. For example, for s="(())()" there are 6 prefixes: "(", "((", "(()", "(())", "(())(" and "(())()".
In your opinion, a neat and clean room s is a bracket sequence that:
* the whole string s is a regular bracket sequence;
* and there are exactly k prefixes of this sequence which are regular (including whole s itself).
For example, if k = 2, then "(())()" is a neat and clean room.
You want to use at most n operations to make your room neat and clean. Operations are applied one after another sequentially.
It is guaranteed that the answer exists. Note that you do not need to minimize the number of operations: find any way to achieve the desired configuration in n or less operations.
Input
The first line contains integer number t (1 ≤ t ≤ 100) — the number of test cases in the input. Then t test cases follow.
The first line of a test case contains two integers n and k (1 ≤ k ≤ n/2, 2 ≤ n ≤ 2000, n is even) — length of s and required number of regular prefixes.
The second line of a test case contains s of length n — the given bracket sequence. It contains only '(' and ')'.
It is guaranteed that there are exactly n/2 characters '(' and exactly n/2 characters ')' in the given string.
The sum of all values n over all the test cases in the input doesn't exceed 2000.
Output
For each test case print an answer.
In the first line print integer m (0 ≤ m ≤ n) — the number of operations. You do not need to minimize m, any value is suitable.
In the following m lines print description of the operations, each line should contain two integers l,r (1 ≤ l ≤ r ≤ n), representing single reverse operation of s[l ... r]=s_{l}s_{l+1}... s_{r}. Operations are applied one after another sequentially.
The final s after all operations should be a regular, also it should be exactly k prefixes (including s) which are regular.
It is guaranteed that the answer exists. If there are several possible answers you can print any.
Example
Input
4
8 2
()(())()
10 3
))()()()((
2 1
()
2 1
)(
Output
4
3 4
1 1
5 8
2 2
3
4 10
1 4
6 7
0
1
1 2
Note
In the first example, the final sequence is "()(()())", where two prefixes are regular, "()" and "()(()())". Note, that all the operations except "5 8" in the example output are useless (they do not change s).
|
#include <bits/stdc++.h>
#pragma GCC optimize "trapv"
using namespace std;
const int INF = 1e9;
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
void solve() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<pair<int, int>> ans;
for (int i = 0; i < n; i++) {
if (i % 2 == 0 && s[i] == ')') {
for (int j = i + 1; j < n; j++) {
if (s[j] == '(') {
ans.push_back({i + 1, j + 1});
string t = s.substr(i, j - i + 1);
reverse(t.begin(), t.end());
s.replace(i, j - i + 1, t);
break;
}
}
} else if (i % 2 == 1 && s[i] == '(') {
for (int j = i + 1; j < n; j++) {
if (s[j] == ')') {
ans.push_back({i + 1, j + 1});
string t = s.substr(i, j - i + 1);
reverse(t.begin(), t.end());
s.replace(i, j - i + 1, t);
break;
}
}
}
}
int count = n / 2;
vector<int> val(n + 1, 0);
for (int i = 0; i < n; i++) {
val[i + 1] = val[i] + (s[i] == '(' ? 1 : -1);
};
if (count > k) {
count -= k;
for (int i = 1; i <= n && count; i++) {
if (val[i] == 0) {
ans.push_back({i, i + 1});
i++;
count--;
}
}
}
cout << ans.size() << endl;
for (auto x : ans) {
cout << x.first << " " << x.second << endl;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) solve();
}
|
You are given a Young diagram.
Given diagram is a histogram with n columns of lengths a_1, a_2, …, a_n (a_1 ≥ a_2 ≥ … ≥ a_n ≥ 1).
<image> Young diagram for a=[3,2,2,2,1].
Your goal is to find the largest number of non-overlapping dominos that you can draw inside of this histogram, a domino is a 1 × 2 or 2 × 1 rectangle.
Input
The first line of input contain one integer n (1 ≤ n ≤ 300 000): the number of columns in the given histogram.
The next line of input contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 300 000, a_i ≥ a_{i+1}): the lengths of columns.
Output
Output one integer: the largest number of non-overlapping dominos that you can draw inside of the given Young diagram.
Example
Input
5
3 2 2 2 1
Output
4
Note
Some of the possible solutions for the example:
<image> <image>
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.FilterInputStream;
import java.io.BufferedInputStream;
import java.io.InputStream;
/**
* @author khokharnikunj8
*/
public class Main {
public static void main(String[] args) {
new Thread(null, new Runnable() {
public void run() {
new Main().solve();
}
}, "1", 1 << 26).start();
}
void solve() {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
ScanReader in = new ScanReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
DDominoForYoung solver = new DDominoForYoung();
solver.solve(1, in, out);
out.close();
}
static class DDominoForYoung {
public void solve(int testNumber, ScanReader in, PrintWriter out) {
int n = in.scanInt();
int[] ar = new int[n];
in.scanInt(ar, n);
long odd = 0;
long even = 0;
for (int i = 0; i < n; i++) {
odd += (ar[i] / 2);
even += (ar[i] / 2);
if (ar[i] % 2 == 1) {
if (i % 2 == 0) odd++;
else even++;
}
}
out.println(Math.min(odd, even));
}
}
static class ScanReader {
private byte[] buf = new byte[4 * 1024];
private int index;
private BufferedInputStream in;
private int total;
public ScanReader(InputStream inputStream) {
in = new BufferedInputStream(inputStream);
}
private int scan() {
if (index >= total) {
index = 0;
try {
total = in.read(buf);
} catch (Exception e) {
e.printStackTrace();
}
if (total <= 0) return -1;
}
return buf[index++];
}
public int scanInt() {
int integer = 0;
int n = scan();
while (isWhiteSpace(n)) n = scan();
int neg = 1;
if (n == '-') {
neg = -1;
n = scan();
}
while (!isWhiteSpace(n)) {
if (n >= '0' && n <= '9') {
integer *= 10;
integer += n - '0';
n = scan();
}
}
return neg * integer;
}
private boolean isWhiteSpace(int n) {
if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1) return true;
else return false;
}
public void scanInt(int[] A, int size) {
for (int i = 0; i < size; i++) A[i] = scanInt();
}
}
}
|
Let's call two strings s and t anagrams of each other if it is possible to rearrange symbols in the string s to get a string, equal to t.
Let's consider two strings s and t which are anagrams of each other. We say that t is a reducible anagram of s if there exists an integer k ≥ 2 and 2k non-empty strings s_1, t_1, s_2, t_2, ..., s_k, t_k that satisfy the following conditions:
1. If we write the strings s_1, s_2, ..., s_k in order, the resulting string will be equal to s;
2. If we write the strings t_1, t_2, ..., t_k in order, the resulting string will be equal to t;
3. For all integers i between 1 and k inclusive, s_i and t_i are anagrams of each other.
If such strings don't exist, then t is said to be an irreducible anagram of s. Note that these notions are only defined when s and t are anagrams of each other.
For example, consider the string s = "gamegame". Then the string t = "megamage" is a reducible anagram of s, we may choose for example s_1 = "game", s_2 = "gam", s_3 = "e" and t_1 = "mega", t_2 = "mag", t_3 = "e":
<image>
On the other hand, we can prove that t = "memegaga" is an irreducible anagram of s.
You will be given a string s and q queries, represented by two integers 1 ≤ l ≤ r ≤ |s| (where |s| is equal to the length of the string s). For each query, you should find if the substring of s formed by characters from the l-th to the r-th has at least one irreducible anagram.
Input
The first line contains a string s, consisting of lowercase English characters (1 ≤ |s| ≤ 2 ⋅ 10^5).
The second line contains a single integer q (1 ≤ q ≤ 10^5) — the number of queries.
Each of the following q lines contain two integers l and r (1 ≤ l ≤ r ≤ |s|), representing a query for the substring of s formed by characters from the l-th to the r-th.
Output
For each query, print a single line containing "Yes" (without quotes) if the corresponding substring has at least one irreducible anagram, and a single line containing "No" (without quotes) otherwise.
Examples
Input
aaaaa
3
1 1
2 4
5 5
Output
Yes
No
Yes
Input
aabbbbbbc
6
1 2
2 4
2 2
1 9
5 7
3 5
Output
No
Yes
Yes
Yes
No
No
Note
In the first sample, in the first and third queries, the substring is "a", which has itself as an irreducible anagram since two or more non-empty strings cannot be put together to obtain "a". On the other hand, in the second query, the substring is "aaa", which has no irreducible anagrams: its only anagram is itself, and we may choose s_1 = "a", s_2 = "aa", t_1 = "a", t_2 = "aa" to show that it is a reducible anagram.
In the second query of the second sample, the substring is "abb", which has, for example, "bba" as an irreducible anagram.
|
s = input()
mp = [ [0 for i in range(26)] for _ in range(len(s))]
for i in range(len(s)) :
mp[i][ord(s[i]) - ord('a')] += 1
if i > 0 :
for j in range(26) :
mp[i][j] += mp[i - 1][j]
for _ in range(int(input())) :
l, r = map(int, input().split())
sc = 0
for i in range(26) :
t = mp[r - 1][i]
if l > 1 :
t -= mp[l - 2][i]
if t :
sc += 1
if s[l - 1] != s[r - 1] or l == r or sc >= 3 :
print('Yes')
else : print('No')
|
You are given two integers n and d. You need to construct a rooted binary tree consisting of n vertices with a root at the vertex 1 and the sum of depths of all vertices equals to d.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a vertex v is the last different from v vertex on the path from the root to the vertex v. The depth of the vertex v is the length of the path from the root to the vertex v. Children of vertex v are all vertices for which v is the parent. The binary tree is such a tree that no vertex has more than 2 children.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains two integers n and d (2 ≤ n, d ≤ 5000) — the number of vertices in the tree and the required sum of depths of all vertices.
It is guaranteed that the sum of n and the sum of d both does not exceed 5000 (∑ n ≤ 5000, ∑ d ≤ 5000).
Output
For each test case, print the answer.
If it is impossible to construct such a tree, print "NO" (without quotes) in the first line. Otherwise, print "{YES}" in the first line. Then print n-1 integers p_2, p_3, ..., p_n in the second line, where p_i is the parent of the vertex i. Note that the sequence of parents you print should describe some binary tree.
Example
Input
3
5 7
10 19
10 18
Output
YES
1 2 1 3
YES
1 2 3 3 9 9 2 1 6
NO
Note
Pictures corresponding to the first and the second test cases of the example:
<image>
<image>
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5050;
int min_depth[N], max_depth[N];
void prec() {
for (int n = 1; n <= 5000; n++) {
int nn = n - 1, h = 0, cnt = 1;
while (nn) {
h++;
cnt *= 2;
min_depth[n] += min(nn, cnt) * h;
nn -= min(nn, cnt);
}
max_depth[n] = n * (n - 1) / 2;
}
}
int timer = 0;
vector<int> p;
void solver(int root, int n, int d) {
if (n == 1) return;
d -= (n - 1);
for (int l = 0; l <= n - 1; l++) {
int r = (n - 1) - l;
if (!(min_depth[l] + min_depth[r] <= d && d <= max_depth[l] + max_depth[r]))
continue;
int flag = 0;
for (int depth_l : {min_depth[l], max_depth[l]}) {
if (min_depth[r] <= d - depth_l && d - depth_l <= max_depth[r]) {
if (l) {
int lv = timer++;
p.push_back(root);
solver(lv, l, depth_l);
}
if (r) {
int rv = timer++;
p.push_back(root);
solver(rv, r, d - depth_l);
}
flag = 1;
break;
}
}
if (flag) break;
}
}
void solve() {
int n, d;
cin >> n >> d;
if (!(min_depth[n] <= d && d <= max_depth[n])) {
cout << "NO\n";
return;
}
cout << "YES\n";
p.clear();
timer = 2;
solver(1, n, d);
for (auto x : p) cout << x << " ";
cout << "\n";
}
int main() {
ios::sync_with_stdio(NULL), cin.tie(0), cout.tie(0);
cout.setf(ios::fixed), cout.precision(20);
prec();
int t;
cin >> t;
while (t--) solve();
}
|
You are playing another computer game, and now you have to slay n monsters. These monsters are standing in a circle, numbered clockwise from 1 to n. Initially, the i-th monster has a_i health.
You may shoot the monsters to kill them. Each shot requires exactly one bullet and decreases the health of the targeted monster by 1 (deals 1 damage to it). Furthermore, when the health of some monster i becomes 0 or less than 0, it dies and explodes, dealing b_i damage to the next monster (monster i + 1, if i < n, or monster 1, if i = n). If the next monster is already dead, then nothing happens. If the explosion kills the next monster, it explodes too, damaging the monster after it and possibly triggering another explosion, and so on.
You have to calculate the minimum number of bullets you have to fire to kill all n monsters in the circle.
Input
The first line contains one integer T (1 ≤ T ≤ 150000) — the number of test cases.
Then the test cases follow, each test case begins with a line containing one integer n (2 ≤ n ≤ 300000) — the number of monsters. Then n lines follow, each containing two integers a_i and b_i (1 ≤ a_i, b_i ≤ 10^{12}) — the parameters of the i-th monster in the circle.
It is guaranteed that the total number of monsters in all test cases does not exceed 300000.
Output
For each test case, print one integer — the minimum number of bullets you have to fire to kill all of the monsters.
Example
Input
1
3
7 15
2 14
5 3
Output
6
|
from sys import stdin, stdout
import io, os
input = stdin.buffer.readline
def inp():
return int(input())
def arrinp():
return [int(x) for x in input().split()]
l = []
def main():
t = inp()
for _ in range(t):
n = inp()
A, B = zip(*[list(map(int, input().split())) for i in range(n)])
ans, min_cost = 0, float('inf')
for i in range(n):
ans += max(A[i] - B[i-1], 0)
min_cost = min(min_cost, A[i] - max(0, A[i] - B[i-1]))
l.append(str(min_cost+ans)+"\n")
stdout.writelines(l)
if __name__ == '__main__':
main()
|
You are given an undirected graph without self-loops or multiple edges which consists of n vertices and m edges. Also you are given three integers n_1, n_2 and n_3.
Can you label each vertex with one of three numbers 1, 2 or 3 in such way, that:
1. Each vertex should be labeled by exactly one number 1, 2 or 3;
2. The total number of vertices with label 1 should be equal to n_1;
3. The total number of vertices with label 2 should be equal to n_2;
4. The total number of vertices with label 3 should be equal to n_3;
5. |col_u - col_v| = 1 for each edge (u, v), where col_x is the label of vertex x.
If there are multiple valid labelings, print any of them.
Input
The first line contains two integers n and m (1 ≤ n ≤ 5000; 0 ≤ m ≤ 10^5) — the number of vertices and edges in the graph.
The second line contains three integers n_1, n_2 and n_3 (0 ≤ n_1, n_2, n_3 ≤ n) — the number of labels 1, 2 and 3, respectively. It's guaranteed that n_1 + n_2 + n_3 = n.
Next m lines contan description of edges: the i-th line contains two integers u_i, v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — the vertices the i-th edge connects. It's guaranteed that the graph doesn't contain self-loops or multiple edges.
Output
If valid labeling exists then print "YES" (without quotes) in the first line. In the second line print string of length n consisting of 1, 2 and 3. The i-th letter should be equal to the label of the i-th vertex.
If there is no valid labeling, print "NO" (without quotes).
Examples
Input
6 3
2 2 2
3 1
5 4
2 5
Output
YES
112323
Input
5 9
0 2 3
1 2
1 3
1 5
2 3
2 4
2 5
3 4
3 5
4 5
Output
NO
|
// Don't place your source in a package
import javax.swing.*;
import java.lang.reflect.Array;
import java.text.DecimalFormat;
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
import java.util.stream.Stream;
// Please name your class Main
public class Main {
static FastScanner fs=new FastScanner();
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
public String next() {
while (!st.hasMoreElements())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int Int() {
return Integer.parseInt(next());
}
long Long() {
return Long.parseLong(next());
}
String Str(){
return next();
}
}
public static void main (String[] args) throws java.lang.Exception {
PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
int T=1;
for(int t=0;t<T;t++){
int n=Int(),m=Int();
int a=Int(),b=Int(),c=Int();
int edges[][]=new int[m][2];
for(int i=0;i<edges.length;i++){
edges[i][0]=Int()-1;
edges[i][1]=Int()-1;
}
Solution sol=new Solution(out);
sol.solution(n,a,b,c,edges);
}
out.close();
}
public static int Int(){
return fs.Int();
}
public static long Long(){
return fs.Long();
}
public static String Str(){
return fs.Str();
}
}
class Solution{
PrintWriter out;
public Solution(PrintWriter out){
this.out=out;
}
List<Integer>graph[];
int colors[];
boolean bad=false;
List<List<Integer>>list=new ArrayList<>();
int a,b,c;
boolean dp[][];
int path[][];
int cnt=0;
public void solution(int n,int a,int b,int c,int edges[][]){
this.a=a;this.b=b;this.c=c;
graph=new ArrayList[n];
colors=new int[n];
Arrays.fill(colors,-1);
Arrays.setAll(graph,e->new ArrayList<>());
for(int e[]:edges){
int u=e[0],v=e[1];
graph[u].add(v);
graph[v].add(u);
}
for(int i=0;i<n;i++){
if(colors[i]==-1){
List<Integer>A=new ArrayList<>();
List<Integer>B=new ArrayList<>();
dfs(i,0,A,B);
list.add(A);
list.add(B);
}
}
if(bad){
NO();
return;
}
dp=new boolean[list.size()/2+1][b+1];
path=new int[list.size()/2+1][b+1];
dp[0][0]=true;
for(int i=0;i<list.size()/2;i++){
int aa=list.get(i*2).size();
int bb=list.get(i*2+1).size();
for(int j=0;j<=b;j++){
if(j-aa>=0){
dp[i+1][j]|=dp[i][j-aa];
if(dp[i][j-aa]){
path[i+1][j]=i*2;
}
}
if(j-bb>=0){
dp[i+1][j]|=dp[i][j-bb];
if(dp[i][j-bb]){
path[i+1][j]=i*2+1;
}
}
}
}
if(!dp[list.size()/2][b]){
NO();
return;
}
int res[]=new int[n];
int i=list.size()/2;
int j=b;
Set<Integer>set=new HashSet<>();
while(j>0){
List<Integer>sub=list.get(path[i][j]);
set.add(path[i][j]);
for(int index:sub)res[index]=2;
j-=sub.size();
i--;
}
for(i=0;i<list.size();i++){
if(set.contains(i))continue;
List<Integer>A=list.get(i);
for(int index:A){
if(a>0){
res[index]=1;a--;
}
else{
res[index]=3;
}
}
}
out.println("YES");
for(int x:res)out.print(x);
out.println();
}
/*public boolean dfs1(int n,int i){
if(i>=list.size()/2){
if(n==0)return true;
else return false;
}
if(n<0)return false;
if(dp[n][i][0])return dp[n][i][1];
boolean a=dfs1(n-list.get(i*2).size(),i+1);
boolean b=dfs1(n-list.get(i*2+1).size(),i+1);
if(a){
path[n][i]=i*2;
}
if(b){
path[n][i]=i*2+1;
}
dp[n][i][0]=true;
dp[n][i][1]=(a|b);
cnt++;
return a|b;
}*/
public void NO(){
out.println("NO");
}
public void dfs(int root,int color,List<Integer>A,List<Integer>B){
if(color==0)A.add(root);
else B.add(root);
colors[root]=color;
int next=((color)+1)%2;
for(int child:graph[root]){
if(colors[child]==-1){
dfs(child,next,A,B);
}
else{
if(color==colors[child]){
bad=true;
}
}
}
}
}
/*
;\
|' \
_ ; : ;
/ `-. /: : |
| ,-.`-. ,': : |
\ : `. `. ,'-. : |
\ ; ; `-.__,' `-.|
\ ; ; ::: ,::'`:. `.
\ `-. : ` :. `. \
\ \ , ; ,: (\
\ :., :. ,'o)): ` `-.
,/,' ;' ,::"'`.`---' `. `-._
,/ : ; '" `;' ,--`.
;/ :; ; ,:' ( ,:)
,.,:. ; ,:., ,-._ `. \""'/
'::' `:'` ,'( \`._____.-'"'
;, ; `. `. `._`-. \\
;:. ;: `-._`-.\ \`.
'`:. : |' `. `\ ) \
-hrr- ` ;: | `--\__,'
'` ,'
,-'
free bug dog
*/
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.