input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
You are given a permutation p_1, p_2, ... , p_n (an array where each integer from 1 to n appears exactly once). The weight of the i-th element of this permutation is a_i.
At first, you separate your permutation into two non-empty sets — prefix and suffix. More formally, the first set contains elements p_1, p_2, ... , p_k, the second — p_{k+1}, p_{k+2}, ... , p_n, where 1 ≤ k < n.
After that, you may move elements between sets. The operation you are allowed to do is to choose some element of the first set and move it to the second set, or vice versa (move from the second set to the first). You have to pay a_i dollars to move the element p_i.
Your goal is to make it so that each element of the first set is less than each element of the second set. Note that if one of the sets is empty, this condition is met.
For example, if p = [3, 1, 2] and a = [7, 1, 4], then the optimal strategy is: separate p into two parts [3, 1] and [2] and then move the 2-element into first set (it costs 4). And if p = [3, 5, 1, 6, 2, 4], a = [9, 1, 9, 9, 1, 9], then the optimal strategy is: separate p into two parts [3, 5, 1] and [6, 2, 4], and then move the 2-element into first set (it costs 1), and 5-element into second set (it also costs 1).
Calculate the minimum number of dollars you have to spend.
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of permutation.
The second line contains n integers p_1, p_2, ... , p_n (1 ≤ p_i ≤ n). It's guaranteed that this sequence contains each element from 1 to n exactly once.
The third line contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9).
Output
Print one integer — the minimum number of dollars you have to spend.
Examples
Input
3
3 1 2
7 1 4
Output
4
Input
4
2 4 1 3
5 9 8 3
Output
3
Input
6
3 5 1 6 2 4
9 1 9 9 1 9
Output
2
|
#include <bits/stdc++.h>
using namespace std;
using lld = long long int;
using pii = pair<int, int>;
using pll = pair<lld, lld>;
using pli = pair<lld, int>;
using pil = pair<int, lld>;
int n, m;
lld ms[2 * 262144];
lld mt[2 * 262144];
pii a[200009];
pii b[200009];
void update(int dep, int ql, int qr, int ll, int rr, int v) {
if (ql <= ll && rr <= qr) {
mt[dep] += v;
return;
}
if (qr < ll || rr < ql) return;
update(dep * 2, ql, qr, ll, (ll + rr) / 2, v);
update(dep * 2 + 1, ql, qr, (ll + rr) / 2 + 1, rr, v);
ms[dep] = min(ms[dep * 2] + mt[dep * 2], ms[dep * 2 + 1] + mt[dep * 2 + 1]);
}
lld getms(int dep, int ql, int qr, int ll, int rr) {
if (ql <= ll && rr <= qr) {
return ms[dep] + mt[dep];
}
if (qr < ll || rr < ql) return 1000000000000009LL;
lld p = getms(dep * 2, ql, qr, ll, (ll + rr) / 2);
lld q = getms(dep * 2 + 1, ql, qr, (ll + rr) / 2 + 1, rr);
return min(p, q) + mt[dep];
}
int main() {
int i, j, k;
int t = 1, tv = 0;
while (t--) {
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i].first);
}
for (i = 0; i < n; i++) {
scanf("%d", &a[i].second);
}
for (i = 0; i < n; i++) {
b[a[i].first - 1] = pii(i, a[i].second);
}
for (i = 0; i < n; i++) {
ms[i + 262144 + 1] = ms[i + 262144] + a[i].second;
}
for (; i + 1 < 262144; i++) {
ms[i + 262144 + 1] = ms[i + 262144];
}
for (i = 262144 - 1; i > 0; i--) {
ms[i] = min(ms[i * 2], ms[i * 2 + 1]);
}
lld res = getms(1, 1, n - 1, 0, 262144 - 1);
for (i = 0; i < n; i++) {
j = b[i].first;
update(1, 0, j, 0, 262144 - 1, b[i].second);
update(1, j + 1, 262144 - 1, 0, 262144 - 1, -b[i].second);
lld cur = getms(1, 1, n - 1, 0, 262144 - 1);
res = min(res, cur);
}
printf("%lld\n", res);
}
}
|
Alice, the president of club FCB, wants to build a team for the new volleyball tournament. The team should consist of p players playing in p different positions. She also recognizes the importance of audience support, so she wants to select k people as part of the audience.
There are n people in Byteland. Alice needs to select exactly p players, one for each position, and exactly k members of the audience from this pool of n people. Her ultimate goal is to maximize the total strength of the club.
The i-th of the n persons has an integer a_{i} associated with him — the strength he adds to the club if he is selected as a member of the audience.
For each person i and for each position j, Alice knows s_{i, j} — the strength added by the i-th person to the club if he is selected to play in the j-th position.
Each person can be selected at most once as a player or a member of the audience. You have to choose exactly one player for each position.
Since Alice is busy, she needs you to help her find the maximum possible strength of the club that can be achieved by an optimal choice of players and the audience.
Input
The first line contains 3 integers n,p,k (2 ≤ n ≤ 10^{5}, 1 ≤ p ≤ 7, 1 ≤ k, p+k ≤ n).
The second line contains n integers a_{1},a_{2},…,a_{n}. (1 ≤ a_{i} ≤ 10^{9}).
The i-th of the next n lines contains p integers s_{i, 1}, s_{i, 2}, ..., s_{i, p}. (1 ≤ s_{i,j} ≤ 10^{9})
Output
Print a single integer {res} — the maximum possible strength of the club.
Examples
Input
4 1 2
1 16 10 3
18
19
13
15
Output
44
Input
6 2 3
78 93 9 17 13 78
80 97
30 52
26 17
56 68
60 36
84 55
Output
377
Input
3 2 1
500 498 564
100002 3
422332 2
232323 1
Output
422899
Note
In the first sample, we can select person 1 to play in the 1-st position and persons 2 and 3 as audience members. Then the total strength of the club will be equal to a_{2}+a_{3}+s_{1,1}.
|
import java.util.*;
import java.io.*;
public class TeamBuilding {
// https://codeforces.com/contest/1316/problem/E
static int n, p, k;
static A[] a;
static long[][] s, memo;
static int[] map;
static long sum=0, INF = (long)(1e15);
public static void main(String[] args) throws IOException, FileNotFoundException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
//BufferedReader in = new BufferedReader(new FileReader("TeamBuilding"));
int t = 1;
while (t-- > 0) {
StringTokenizer st = new StringTokenizer(in.readLine());
n = Integer.parseInt(st.nextToken());
p = Integer.parseInt(st.nextToken());
k = Integer.parseInt(st.nextToken());
st = new StringTokenizer(in.readLine());
a = new A[n];
map = new int[n];
for (int i=0; i<n; i++) a[i] = new A(Integer.parseInt(st.nextToken()), i);
Arrays.parallelSort(a);
for (int i=0; i<n; i++ ) {
map[a[i].index] = i;
if (i<k) sum += a[i].val;
}
s = new long[n][p];
for (int i=0; i<n; i++) {
st = new StringTokenizer(in.readLine());
for (int j=0; j<p; j++) {
s[i][j] = Integer.parseInt(st.nextToken());
}
}
// System.out.println(sum);
// System.out.println(Arrays.toString(map));
memo = new long[n][1 << p];
for (int i=0; i<n; i++) {
Arrays.fill(memo[i], -1);
}
long ans = dp(0, 0, 0);
// for (int i=0; i<n; i++) {
// System.out.println(Arrays.toString(memo[i]));
// }
System.out.println(ans);
}
}
public static long dp(int index, int mask, int count) {
if (index >= n) {
if (mask == (1 << p) - 1) {
return 0;
}
return -INF;
}
if (memo[index][mask] != -1) return memo[index][mask];
// dont take
long ans = 0;
if (index + 1 - count > k) ans = dp(index+1, mask, count);
else ans = dp(index+1, mask, count) + a[index].val;
// take
for (int i=0; i<p; i++) {
if (((mask >> i)&1) == 0) {
ans = Math.max(ans, s[a[index].index][i] + dp(index+1, mask + (1 << i), count+1));
}
}
return memo[index][mask] = ans;
}
static class A implements Comparable<A> {
long val; int index;
A (long a, int b) {
val = a; index = b;
}
public int compareTo(A o) {
return Long.compare(o.val, val);
}
}
}
|
You have an array a of length n. For every positive integer x you are going to perform the following operation during the x-th second:
* Select some distinct indices i_{1}, i_{2}, …, i_{k} which are between 1 and n inclusive, and add 2^{x-1} to each corresponding position of a. Formally, a_{i_{j}} := a_{i_{j}} + 2^{x-1} for j = 1, 2, …, k. Note that you are allowed to not select any indices at all.
You have to make a nondecreasing as fast as possible. Find the smallest number T such that you can make the array nondecreasing after at most T seconds.
Array a is nondecreasing if and only if a_{1} ≤ a_{2} ≤ … ≤ a_{n}.
You have to answer t independent test cases.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^{4}) — the number of test cases.
The first line of each test case contains single integer n (1 ≤ n ≤ 10^{5}) — the length of array a. It is guaranteed that the sum of values of n over all test cases in the input does not exceed 10^{5}.
The second line of each test case contains n integers a_{1}, a_{2}, …, a_{n} (-10^{9} ≤ a_{i} ≤ 10^{9}).
Output
For each test case, print the minimum number of seconds in which you can make a nondecreasing.
Example
Input
3
4
1 7 6 5
5
1 2 3 4 5
2
0 -4
Output
2
0
3
Note
In the first test case, if you select indices 3, 4 at the 1-st second and 4 at the 2-nd second, then a will become [1, 7, 7, 8]. There are some other possible ways to make a nondecreasing in 2 seconds, but you can't do it faster.
In the second test case, a is already nondecreasing, so answer is 0.
In the third test case, if you do nothing at first 2 seconds and select index 2 at the 3-rd second, a will become [0, 0].
|
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
static long sx = 0, sy = 0, mod = (long) (1e9 + 7);
static ArrayList<Integer>[] a;
static long[][][] dp;
static long[] fa;
static long[] farr;
public static PrintWriter out;
static ArrayList<pair> pa = new ArrayList<>();
static long[] fact = new long[(int) 1e6];
static boolean b = false;
static StringBuilder sb = new StringBuilder();
static boolean cycle = false;
// static long m = 998244353;
static long[] no, col;
static String s;
static int k = 0, n = 0, m = 0;
static int[] c;
static long ans = 0;
static HashMap<Integer, Integer> hm;
// static ArrayList<Integer> p = new ArrayList<>();
static long[] arr;;
static long[] p;
public static void main(String[] args) throws IOException {
// Scanner scn = new Scanner(new BufferedReader(new
// InputStreamReader(System.in)));
out = new PrintWriter(System.out);
Reader scn = new Reader();
int t = scn.nextInt();
while (t-- != 0) {
int n = scn.nextInt();
long[] a = scn.nextLongArray(n);
long ans = 0;
for (int i = 1; i < n; i++) {
if (a[i] < a[i - 1]) {
long d = a[i - 1] - a[i];
long pow = 1, sum = 0;
long cnt = 0;
while (sum < d) {
sum += pow;
pow *= 2;
cnt++;
}
ans = Math.max(ans, cnt);
a[i] = a[i - 1];
}
}
System.out.println(ans);
}
}
// _________________________TEMPLATE_____________________________________________________________
// public static long lcm(long x, long y) {
//
// return (x * y) / gcd(x, y);
// }
//
// private static long gcd(long x, long y) {
// if (x == 0)
// return y;
//
// return gcd(y % x, x);
// }
//
// static class comp implements Comparator<pair> {
//
// @Override
// public int compare(pair p1, pair p2) {
// return p1.i - p2.i;
// }
//
// }
//
// public static long pow(long a, long b) {
//
// if (b < 0)
// return 0;
// if (b == 0 || b == 1)
// return (long) Math.pow(a, b);
//
// if (b % 2 == 0) {
//
// long ret = pow(a, b / 2);
// ret = (ret % mod * ret % mod) % mod;
// return ret;
// }
//
// else {
// return ((pow(a, b - 1) % mod) * a % mod) % mod;
// }
// }
private static class pair implements Comparable<pair> {
long no;
long s, e;
pair(long n, long c, long d) {
no = n;
s = c;
e = d;
}
@Override
public int compareTo(pair o) {
return 1;
}
// @Override
//
// public int hashCode() {
// return i;
// }
//
// @Override
//
// public boolean equals(Object o) {
//
// pair p = (pair) o;
// return this.i == p.i;
// }
}
private static String reverse(String s) {
return new StringBuilder(s).reverse().toString();
}
public static class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Reader() {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Reader(String file_name) throws IOException {
din = new DataInputStream(new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException {
byte[] buf = new byte[1000000 + 1]; // line length
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n')
break;
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
public int nextInt() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public long nextLong() throws IOException {
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public double nextDouble() throws IOException {
double ret = 0, div = 1;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (c == '.') {
while ((c = read()) >= '0' && c <= '9') {
ret += (c - '0') / (div *= 10);
}
}
if (neg)
return -ret;
return ret;
}
private void fillBuffer() throws IOException {
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}
private byte read() throws IOException {
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}
public void close() throws IOException {
if (din == null)
return;
din.close();
}
public int[] nextIntArray(int n) throws IOException {
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = nextInt();
}
return arr;
}
public long[] nextLongArray(int n) throws IOException {
long[] arr = new long[n];
for (int i = 0; i < n; i++) {
arr[i] = nextLong();
}
return arr;
}
public int[][] nextInt2DArray(int m, int n) throws IOException {
int[][] arr = new int[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++)
arr[i][j] = nextInt();
}
return arr;
}
public long[][] nextInt2DArrayL(int m, int n) throws IOException {
long[][] arr = new long[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++)
arr[i][j] = nextInt();
}
return arr;
}
// kickstart - Solution
// atcoder - Main
}
}
|
Little Petya very much likes strings. Recently he has received a voucher to purchase a string as a gift from his mother. The string can be bought in the local shop. One can consider that the shop has all sorts of strings over the alphabet of fixed size. The size of the alphabet is equal to k. However, the voucher has a string type limitation: specifically, the voucher can be used to purchase string s if the length of string's longest substring that is also its weak subsequence (see the definition given below) equals w.
String a with the length of n is considered the weak subsequence of the string s with the length of m, if there exists such a set of indexes 1 ≤ i1 < i2 < ... < in ≤ m, that has the following two properties:
* ak = sik for all k from 1 to n;
* there exists at least one such k (1 ≤ k < n), for which ik + 1 – ik > 1.
Petya got interested how many different strings are available for him to purchase in the shop. As the number of strings can be very large, please find it modulo 1000000007 (109 + 7). If there are infinitely many such strings, print "-1".
Input
The first line contains two integers k (1 ≤ k ≤ 106) and w (2 ≤ w ≤ 109) — the alphabet size and the required length of the maximum substring that also is the weak subsequence, correspondingly.
Output
Print a single number — the number of strings Petya can buy using the voucher, modulo 1000000007 (109 + 7). If there are infinitely many such strings, print "-1" (without the quotes).
Examples
Input
2 2
Output
10
Input
3 5
Output
1593
Input
2 139
Output
717248223
Note
In the first sample Petya can buy the following strings: aaa, aab, abab, abb, abba, baa, baab, baba, bba, bbb.
|
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
Task solver = new Task();
solver.solve(in, out);
out.close();
}
}
class Task {
final static int MAXN = 2111111;
final static long MD = 1000000007;
long[] inv, fact, factInv;
long pow(int x, int y) {
long ret = 1, tmp = x;
for (; y > 0; y >>= 1) {
if ((y & 1) == 1)
ret = ret * tmp % MD;
tmp = tmp * tmp % MD;
}
return ret;
}
long perm(int n, int m) {
return n < m ? 0 : fact[n] * factInv[n - m] % MD;
}
void solve(Scanner in, PrintWriter out) {
int k = in.nextInt(), w = in.nextInt();
inv = new long[MAXN];
fact = new long[MAXN];
factInv = new long[MAXN];
inv[1] = 1;
for (int i = 2; i < MAXN; ++i)
inv[i] = (MD - MD / i * inv[(int)MD % i] % MD) % MD;
fact[0] = factInv[0] = 1;
for (int i = 1; i < MAXN; ++i) {
fact[i] = fact[i - 1] * i % MD;
factInv[i] = factInv[i - 1] * inv[i] % MD;
}
long ans = 0;
for (int t = 1; t <= k; ++t) {
if (w - 1 >= t)
ans = (ans + perm(k, t) * perm(k, t) % MD * t % MD * pow(k, w - 1 - t) % MD) % MD;
else
ans = (ans + perm(k, t) * perm(k - t + w - 1, w - 1) % MD * w % MD) % MD;
if (w - 1 >= t + 1)
ans = (ans + perm(k, t) * perm(k, t + 1) % MD * t % MD * pow(k, w - 2 - t) % MD) % MD;
else
ans = (ans + perm(k, t) * perm(k - 2 - t + w, w - 1) % MD * (w - 1) % MD) % MD;
}
out.println(ans);
}
}
|
You are given a permutation p_1, p_2, ..., p_n. Recall that sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
Find three indices i, j and k such that:
* 1 ≤ i < j < k ≤ n;
* p_i < p_j and p_j > p_k.
Or say that there are no such indices.
Input
The first line contains a single integer T (1 ≤ T ≤ 200) — the number of test cases.
Next 2T lines contain test cases — two lines per test case. The first line of each test case contains the single integer n (3 ≤ n ≤ 1000) — the length of the permutation p.
The second line contains n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n; p_i ≠ p_j if i ≠ j) — the permutation p.
Output
For each test case:
* if there are such indices i, j and k, print YES (case insensitive) and the indices themselves;
* if there are no such indices, print NO (case insensitive).
If there are multiple valid triples of indices, print any of them.
Example
Input
3
4
2 1 4 3
6
4 6 1 2 5 3
5
5 3 1 2 4
Output
YES
2 3 4
YES
3 5 6
NO
|
def solve(arr):
for i in range(1, len(arr)-1):
if arr[i] > arr[i-1] and arr[i] > arr[i+1]:
print("YES")
print(i, i+1, i+2)
return
print("NO")
for _ in range(int(input())):
input()
arr = [int(e) for e in input().split()]
solve(arr)
|
A binary string is a string where each character is either 0 or 1. Two binary strings a and b of equal length are similar, if they have the same character in some position (there exists an integer i such that a_i = b_i). For example:
* 10010 and 01111 are similar (they have the same character in position 4);
* 10010 and 11111 are similar;
* 111 and 111 are similar;
* 0110 and 1001 are not similar.
You are given an integer n and a binary string s consisting of 2n-1 characters. Let's denote s[l..r] as the contiguous substring of s starting with l-th character and ending with r-th character (in other words, s[l..r] = s_l s_{l + 1} s_{l + 2} ... s_r).
You have to construct a binary string w of length n which is similar to all of the following strings: s[1..n], s[2..n+1], s[3..n+2], ..., s[n..2n-1].
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 50).
The second line of each test case contains the binary string s of length 2n - 1. Each character s_i is either 0 or 1.
Output
For each test case, print the corresponding binary string w of length n. If there are multiple such strings — print any of them. It can be shown that at least one string w meeting the constraints always exists.
Example
Input
4
1
1
3
00000
4
1110000
2
101
Output
1
000
1010
00
Note
The explanation of the sample case (equal characters in equal positions are bold):
The first test case:
* 1 is similar to s[1..1] = 1.
The second test case:
* 000 is similar to s[1..3] = 000;
* 000 is similar to s[2..4] = 000;
* 000 is similar to s[3..5] = 000.
The third test case:
* 1010 is similar to s[1..4] = 1110;
* 1010 is similar to s[2..5] = 1100;
* 1010 is similar to s[3..6] = 1000;
* 1010 is similar to s[4..7] = 0000.
The fourth test case:
* 00 is similar to s[1..2] = 10;
* 00 is similar to s[2..3] = 01.
|
t = int(input())
for _ in range(t):
n = int(input())
s = input()
print(s[0::2])
|
In the Kingdom of Wakanda, the 2020 economic crisis has made a great impact on each city and its surrounding area. Cities have made a plan to build a fast train rail between them to boost the economy, but because of the insufficient funds, each city can only build a rail with one other city, and they want to do it together.
Cities which are paired up in the plan will share the cost of building the rail between them, and one city might need to pay more than the other. Each city knows the estimated cost of building their part of the rail to every other city. One city can not have the same cost of building the rail with two different cities.
If in a plan, there are two cities that are not connected, but the cost to create a rail between them is lower for each of them than the cost to build the rail with their current pairs, then that plan is not acceptable and the collaboration won't go on. Your task is to create a suitable plan for the cities (pairing of the cities) or say that such plan doesn't exist.
Input
First line contains one integer N \;(2 ≤ N ≤ 10^3) — the number of cities.
Each of the next N lines contains N-1 integers A_{i,1}, A_{i,2}, ..., A_{i,i-1}, A_{i,i+1}, ..., A_{i,N-1}\; (1 ≤ A_{i,j} ≤ 10^9) — where A_{i,j} represents the cost for city i to build the rail to city j. Note that in each line A_{i,i} is skipped.
Output
Output should contain N integers O_{1}, O_{2}, ..., O_N, where O_i represents the city with which city i should build the rail with, or -1 if it is not possible to find the stable pairing.
Examples
Input
4
35 19 20
76 14 75
23 43 78
14 76 98
Output
3
4
1
2
Input
4
2 5 8
7 1 12
4 6 7
8 4 5
Output
-1
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using db = double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<db, db>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<db>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
template <class T>
using V = vector<T>;
template <class T, size_t SZ>
using AR = array<T, SZ>;
const int MOD = 1e9 + 7;
const int MX = 2e5 + 5;
const ll INF = 1e18;
const ld PI = acos((ld)-1);
const int xd[4] = {1, 0, -1, 0}, yd[4] = {0, 1, 0, -1};
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
constexpr int pct(int x) { return __builtin_popcount(x); }
constexpr int bits(int x) { return 31 - __builtin_clz(x); }
ll cdiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); }
ll fdiv(ll a, ll b) { return a / b - ((a ^ b) < 0 && a % b); }
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <class T, class U>
T fstTrue(T lo, T hi, U first) {
hi++;
assert(lo <= hi);
while (lo < hi) {
T mid = lo + (hi - lo) / 2;
first(mid) ? hi = mid : lo = mid + 1;
}
return lo;
}
template <class T, class U>
T lstTrue(T lo, T hi, U first) {
lo--;
assert(lo <= hi);
while (lo < hi) {
T mid = lo + (hi - lo + 1) / 2;
first(mid) ? lo = mid : hi = mid - 1;
}
return lo;
}
template <class T>
void remDup(vector<T>& v) {
sort(begin(v), end(v));
v.erase(unique(begin(v), end(v)), end(v));
}
template <class T, class U>
void erase(T& t, const U& u) {
auto it = t.find(u);
assert(it != end(t));
t.erase(u);
}
template <class T>
void re(complex<T>& c);
template <class T, class U>
void re(pair<T, U>& p);
template <class T>
void re(vector<T>& v);
template <class T, size_t SZ>
void re(AR<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(db& d) {
str t;
re(t);
d = stod(t);
}
void re(ld& d) {
str t;
re(t);
d = stold(t);
}
template <class T, class... U>
void re(T& t, U&... u) {
re(t);
re(u...);
}
template <class T>
void re(complex<T>& c) {
T a, b;
re(a, b);
c = {a, b};
}
template <class T, class U>
void re(pair<T, U>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& x) {
for (auto& a : x) re(a);
}
template <class T, size_t SZ>
void re(AR<T, SZ>& x) {
for (auto& a : x) re(a);
}
str to_string(char c) { return str(1, c); }
str to_string(const char* second) { return (str)second; }
str to_string(str second) { return second; }
str to_string(bool b) { return to_string((int)b); }
template <class T>
str to_string(complex<T> c) {
stringstream ss;
ss << c;
return ss.str();
}
str to_string(vector<bool> v) {
str res = "{";
for (int i = (0); i < ((int)(v).size()); ++i) res += char('0' + v[i]);
res += "}";
return res;
}
template <size_t SZ>
str to_string(bitset<SZ> b) {
str res = "";
for (int i = (0); i < (SZ); ++i) res += char('0' + b[i]);
return res;
}
template <class T, class U>
str to_string(pair<T, U> p);
template <class T>
str to_string(T v) {
bool fst = 1;
str res = "";
for (const auto& x : v) {
if (!fst) res += " ";
fst = 0;
res += to_string(x);
}
return res;
}
template <class T, class U>
str to_string(pair<T, U> p) {
return to_string(p.first) + " " + to_string(p.second);
}
template <class T>
void pr(T x) {
cout << to_string(x);
}
template <class T, class... U>
void pr(const T& t, const U&... u) {
pr(t);
pr(u...);
}
void ps() { pr("\n"); }
template <class T, class... U>
void ps(const T& t, const U&... u) {
pr(t);
if (sizeof...(u)) pr(" ");
ps(u...);
}
void DBG() { cerr << "]" << endl; }
template <class T, class... U>
void DBG(const T& t, const U&... u) {
cerr << to_string(t);
if (sizeof...(u)) cerr << ", ";
DBG(u...);
}
void setIn(str second) { freopen(second.c_str(), "r", stdin); }
void setOut(str second) { freopen(second.c_str(), "w", stdout); }
void unsyncIO() { cin.tie(0)->sync_with_stdio(0); }
void setIO(str second = "") {
unsyncIO();
if ((int)(second).size()) {
setIn(second + ".in"), setOut(second + ".out");
}
}
int N, A[1000][1000];
bool active[1000][1000];
deque<int> pref[1000];
int propose[1000], proposed[1000];
void fin() {
ps(-1);
exit(0);
}
void rem(int x, int y) { active[x][y] = active[y][x] = 0; }
void clip(int x) {
while ((int)(pref[x]).size() && !active[x][pref[x].front()])
pref[x].pop_front();
while ((int)(pref[x]).size() && !active[x][pref[x].back()])
pref[x].pop_back();
if (!(int)(pref[x]).size()) fin();
}
void ad(int x, int y) {
propose[x] = y, proposed[y] = x;
while (1) {
clip(y);
if (pref[y].back() != x)
rem(y, pref[y].back());
else
break;
}
assert(pref[y].back() == x);
}
int nex(int x) {
assert((int)(pref[x]).size() > 1);
int y = pref[x].front();
pref[x].pop_front();
clip(x);
pref[x].push_front(y);
return proposed[pref[x][1]];
}
int main() {
setIO();
re(N);
if (N & 1) fin();
for (int i = (0); i < (N); ++i) {
for (int j = (0); j < (N); ++j)
if (i != j) {
re(A[i][j]);
pref[i].push_back(j);
active[i][j] = 1;
}
sort(begin(pref[i]), end(pref[i]),
[&](int x, int y) { return A[i][x] < A[i][y]; });
0;
}
for (int i = (0); i < (N); ++i) propose[i] = proposed[i] = -1;
queue<int> q;
for (int i = (0); i < (N); ++i) q.push(i);
while (1) {
0;
while ((int)(q).size()) {
int x = q.front();
q.pop();
if (propose[x] != -1) continue;
0;
while (1) {
clip(x);
int y = pref[x].front();
if (proposed[y] != -1 && A[y][proposed[y]] < A[y][x]) {
assert(active[y][x]);
rem(x, y);
assert(!active[y][x]);
continue;
}
if (proposed[y] != -1) {
q.push(proposed[y]);
propose[proposed[y]] = -1;
proposed[y] = -1;
}
ad(x, y);
break;
}
}
int st = -1;
for (int i = (0); i < (N); ++i) {
clip(i);
assert(proposed[i] != -1);
0;
assert(pref[i].back() == proposed[i]);
if ((int)(pref[i]).size() > 1) {
st = i;
break;
}
}
if (st == -1) {
for (int i = (0); i < (N); ++i) assert(proposed[propose[i]] == i);
for (int i = (0); i < (N); ++i) ps(propose[i] + 1);
exit(0);
}
vi cyc;
{
int x = st, y = st;
do {
x = nex(x), y = nex(nex(y));
} while (x != y);
do {
cyc.push_back(y);
y = nex(y);
} while (x != y);
}
for (auto& x : cyc) {
int y = propose[x];
proposed[y] = -1, propose[x] = -1;
rem(x, y);
q.push(x), q.push(y);
}
}
}
|
You are given an array a of length 2n. Consider a partition of array a into two subsequences p and q of length n each (each element of array a should be in exactly one subsequence: either in p or in q).
Let's sort p in non-decreasing order, and q in non-increasing order, we can denote the sorted versions by x and y, respectively. Then the cost of a partition is defined as f(p, q) = ∑_{i = 1}^n |x_i - y_i|.
Find the sum of f(p, q) over all correct partitions of array a. Since the answer might be too big, print its remainder modulo 998244353.
Input
The first line contains a single integer n (1 ≤ n ≤ 150 000).
The second line contains 2n integers a_1, a_2, …, a_{2n} (1 ≤ a_i ≤ 10^9) — elements of array a.
Output
Print one integer — the answer to the problem, modulo 998244353.
Examples
Input
1
1 4
Output
6
Input
2
2 1 2 1
Output
12
Input
3
2 2 2 2 2 2
Output
0
Input
5
13 8 35 94 9284 34 54 69 123 846
Output
2588544
Note
Two partitions of an array are considered different if the sets of indices of elements included in the subsequence p are different.
In the first example, there are two correct partitions of the array a:
1. p = [1], q = [4], then x = [1], y = [4], f(p, q) = |1 - 4| = 3;
2. p = [4], q = [1], then x = [4], y = [1], f(p, q) = |4 - 1| = 3.
In the second example, there are six valid partitions of the array a:
1. p = [2, 1], q = [2, 1] (elements with indices 1 and 2 in the original array are selected in the subsequence p);
2. p = [2, 2], q = [1, 1];
3. p = [2, 1], q = [1, 2] (elements with indices 1 and 4 are selected in the subsequence p);
4. p = [1, 2], q = [2, 1];
5. p = [1, 1], q = [2, 2];
6. p = [2, 1], q = [2, 1] (elements with indices 3 and 4 are selected in the subsequence p).
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v);
template <typename A, typename B>
ostream &operator<<(ostream &cout, pair<A, B> const &p) {
return cout << "(" << p.first << ", " << p.second << ")";
}
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v) {
cout << "[";
for (int i = 0; i < v.size(); i++) {
if (i) cout << ", ";
cout << v[i];
}
return cout << "]";
}
template <typename A, typename B>
istream &operator>>(istream &cin, pair<A, B> &p) {
cin >> p.first;
return cin >> p.second;
}
const long long M = 998244353;
void solve() {
long long n;
cin >> n;
vector<long long> a(2 * n + 1, 0), inv(n + 2, 0);
inv[1] = 1;
for (long long i = 1; i <= 2 * n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
for (long long i = 2; i <= n + 1; i++) {
inv[i] = M - (M / i) * inv[M % i] % M;
}
long long ans = 1;
for (long long i = 1; i <= 2 * n - 1; i++) {
ans *= i;
ans %= M;
}
for (long long i = 1; i <= n; i++) {
ans *= inv[i];
ans %= M;
}
for (long long i = 1; i <= n - 1; i++) {
ans *= inv[i];
ans %= M;
}
ans *= 2;
ans %= M;
long long temp = 0;
for (long long i = n + 1; i <= 2 * n; i++) {
temp = (temp + a[i]);
temp %= M;
}
for (long long i = 1; i <= n; i++) {
temp = (temp - a[i] + M);
temp %= M;
}
cout << (ans * temp) % M << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int testcase = 1;
for (int i = 0; i < testcase; i++) {
solve();
}
return 0;
}
|
You want to build a fence that will consist of n equal sections. All sections have a width equal to 1 and height equal to k. You will place all sections in one line side by side.
Unfortunately, the ground beneath the fence is not flat. For simplicity, you can think that the ground level under the i-th section is equal to h_i.
You should follow several rules to build the fence:
1. the consecutive sections should have a common side of length at least 1;
2. the first and the last sections should stand on the corresponding ground levels;
3. the sections between may be either on the ground level or higher, but not higher than k - 1 from the ground level h_i (the height should be an integer);
<image> One of possible fences (blue color) for the first test case
Is it possible to build a fence that meets all rules?
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5; 2 ≤ k ≤ 10^8) — the number of sections in the fence and the height of each section.
The second line of each test case contains n integers h_1, h_2, ..., h_n (0 ≤ h_i ≤ 10^8), where h_i is the ground level beneath the i-th section.
It's guaranteed that the sum of n over test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case print YES if it's possible to build the fence that meets all rules. Otherwise, print NO.
You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer).
Example
Input
3
6 3
0 0 2 5 1 1
2 3
0 2
3 2
3 0 2
Output
YES
YES
NO
Note
In the first test case, one of the possible fences is shown in the picture.
In the second test case, according to the second rule, you should build both sections on the corresponding ground levels, and since k = 3, h_1 = 0, and h_2 = 2 the first rule is also fulfilled.
In the third test case, according to the second rule, you should build the first section on height 3 and the third section on height 2. According to the first rule, the second section should be on the height of at least 2 (to have a common side with the first section), but according to the third rule, the second section can be built on the height of at most h_2 + k - 1 = 1.
|
//Be Name Khoda
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define pb push_back
#define pp pop_back
#define all(x) x.begin(), x.end()
#define pll pair< ll, ll >
const ll mxn = 1e5 + 10;
ll t, n, k, q;
vector<ll> v, v2;
void input() {
v.clear(), v2.clear();
cin >> n >> k;
for(int i = 0; i < n; i++) {
cin >> q;
v.pb(q);
}
}
void solve() {
ll mn = v[0] + 1, mx = v[0] + k;
bool ch = 1;
for(int i = 1; i < n - 1; i++) {
if(mn > v[i] + k - 1 + k) {
ch = 0;
break;
}
if(mx <= v[i]) {
ch = 0;
break;
}
int x = mn, y = mx;
x = max(mn - (k - 1), v[i] + 1);
y = min(mx + k - 1, v[i] + k - 1 + k);
mn = x, mx = y;
}
int x = v[n - 1] + 1, y = v[n - 1] + k;
if(mn > y || mx < x) {
ch = 0;
}
if(!ch) {
cout << "NO\n";
}
else {
cout << "Yes\n";
}
}
int main() {
ios::sync_with_stdio(false);
cin >> t;
while(t--) {
input(), solve();
}
return 0;
}
/*
*/
|
You are given a directed graph consisting of n vertices. Each directed edge (or arc) labeled with a single character. Initially, the graph is empty.
You should process m queries with it. Each query is one of three types:
* "+ u v c" — add arc from u to v with label c. It's guaranteed that there is no arc (u, v) in the graph at this moment;
* "- u v" — erase arc from u to v. It's guaranteed that the graph contains arc (u, v) at this moment;
* "? k" — find the sequence of k vertices v_1, v_2, ..., v_k such that there exist both routes v_1 → v_2 → ... → v_k and v_k → v_{k - 1} → ... → v_1 and if you write down characters along both routes you'll get the same string. You can visit the same vertices any number of times.
Input
The first line contains two integers n and m (2 ≤ n ≤ 2 ⋅ 10^5; 1 ≤ m ≤ 2 ⋅ 10^5) — the number of vertices in the graph and the number of queries.
The next m lines contain queries — one per line. Each query is one of three types:
* "+ u v c" (1 ≤ u, v ≤ n; u ≠ v; c is a lowercase Latin letter);
* "- u v" (1 ≤ u, v ≤ n; u ≠ v);
* "? k" (2 ≤ k ≤ 10^5).
It's guaranteed that you don't add multiple edges and erase only existing edges. Also, there is at least one query of the third type.
Output
For each query of the third type, print YES if there exist the sequence v_1, v_2, ..., v_k described above, or NO otherwise.
Example
Input
3 11
+ 1 2 a
+ 2 3 b
+ 3 2 a
+ 2 1 b
? 3
? 2
- 2 1
- 3 2
+ 2 1 c
+ 3 2 d
? 5
Output
YES
NO
YES
Note
In the first query of the third type k = 3, we can, for example, choose a sequence [1, 2, 3], since 1 \xrightarrow{a} 2 \xrightarrow{b} 3 and 3 \xrightarrow{a} 2 \xrightarrow{b} 1.
In the second query of the third type k = 2, and we can't find sequence p_1, p_2 such that arcs (p_1, p_2) and (p_2, p_1) have the same characters.
In the third query of the third type, we can, for example, choose a sequence [1, 2, 3, 2, 1], where 1 \xrightarrow{a} 2 \xrightarrow{b} 3 \xrightarrow{d} 2 \xrightarrow{c} 1.
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
set<pair<int, int>> mp[26];
map<pair<int, int>, char> st;
int main() {
int n, m, ans[2] = {0};
cin >> n >> m;
while(m--){
char x;
cin >> x;
if (x == '+') {
int u, v;
char c;
cin >> u >> v >> c;
st[{u, v}] = c;
mp[c-'a'].insert({u, v});
if(mp[c-'a'].find({v, u}) != mp[c-'a'].end()) ans[0]++;
for(int i = 0; i < 26; i++){
if(mp[i].find({v, u}) != mp[i].end()) ans[1]++;
}
} else if (x == '-') {
int u, v;
cin >> u >> v;
char c = st[{u, v}];
mp[c-'a'].erase({u, v});
if(mp[c-'a'].find({v, u}) != mp[c-'a'].end()) ans[0]--;
for(int i = 0; i < 26; i++){
if(mp[i].find({v, u}) != mp[i].end()) ans[1]--;
}
} else {
int u;
cin >> u;
cout << (ans[u%2] ? "YES" :"NO") << endl;
}
}
return 0;
}
|
You are wandering in the explorer space of the 2050 Conference.
The explorer space can be viewed as an undirected weighted grid graph with size n× m. The set of vertices is \{(i, j)|1≤ i≤ n, 1≤ j≤ m\}. Two vertices (i_1,j_1) and (i_2, j_2) are connected by an edge if and only if |i_1-i_2|+|j_1-j_2|=1.
At each step, you can walk to any vertex connected by an edge with your current vertex. On each edge, there are some number of exhibits. Since you already know all the exhibits, whenever you go through an edge containing x exhibits, your boredness increases by x.
For each starting vertex (i, j), please answer the following question: What is the minimum possible boredness if you walk from (i, j) and go back to it after exactly k steps?
You can use any edge for multiple times but the boredness on those edges are also counted for multiple times. At each step, you cannot stay on your current vertex. You also cannot change direction while going through an edge. Before going back to your starting vertex (i, j) after k steps, you can visit (i, j) (or not) freely.
Input
The first line contains three integers n, m and k (2≤ n, m≤ 500, 1≤ k≤ 20).
The j-th number (1≤ j ≤ m - 1) in the i-th line of the following n lines is the number of exibits on the edge between vertex (i, j) and vertex (i, j+1).
The j-th number (1≤ j≤ m) in the i-th line of the following n-1 lines is the number of exibits on the edge between vertex (i, j) and vertex (i+1, j).
The number of exhibits on each edge is an integer between 1 and 10^6.
Output
Output n lines with m numbers each. The j-th number in the i-th line, answer_{ij}, should be the minimum possible boredness if you walk from (i, j) and go back to it after exactly k steps.
If you cannot go back to vertex (i, j) after exactly k steps, answer_{ij} should be -1.
Examples
Input
3 3 10
1 1
1 1
1 1
1 1 1
1 1 1
Output
10 10 10
10 10 10
10 10 10
Input
2 2 4
1
3
4 2
Output
4 4
10 6
Input
2 2 3
1
2
3 4
Output
-1 -1
-1 -1
Note
In the first example, the answer is always 10 no matter how you walk.
In the second example, answer_{21} = 10, the path is (2,1) → (1,1) → (1,2) → (2,2) → (2,1), the boredness is 4 + 1 + 2 + 3 = 10.
|
// Author : RegalBeast
import java.io.*;
import java.util.*;
public class Main {
static final FastReader FR = new FastReader();
static final PrintWriter PW = new PrintWriter(new OutputStreamWriter(System.out));
public static void main(String[] args) {
StringBuilder solution = new StringBuilder();
int rows = FR.nextInt();
int cols = FR.nextInt();
int moves = FR.nextInt();
List<List<Integer>> horizontalEdgeWeights = new ArrayList<List<Integer>>(rows);
for (int r = 0; r < rows; r++) {
horizontalEdgeWeights.add(new ArrayList<Integer>(cols-1));
for (int c = 0; c < cols - 1; c++) {
horizontalEdgeWeights.get(r).add(FR.nextInt());
}
}
List<List<Integer>> verticalEdgeWeights = new ArrayList<List<Integer>>(rows-1);
for (int r = 0; r < rows - 1; r++) {
verticalEdgeWeights.add(new ArrayList<Integer>(cols));
for (int c = 0; c < cols; c++) {
verticalEdgeWeights.get(r).add(FR.nextInt());
}
}
List<List<Integer>> result = getResult(rows, cols, moves, horizontalEdgeWeights, verticalEdgeWeights);
for (int r = 0; r < rows; r++) {
for (int c = 0; c < cols; c++) {
int value = (result != null ? result.get(r).get(c) : -1);
solution.append(value + " ");
}
solution.append("\n");
}
PW.print(solution.toString());
PW.close();
}
static List<List<Integer>> getResult(int rows, int cols, int moves, List<List<Integer>> horizontalEdgeWeights, List<List<Integer>> verticalEdgeWeights) {
if ((moves & 1) == 1) {
return null;
}
int mid = moves >> 1;
List<List<List<Integer>>> minForDistance = new ArrayList<List<List<Integer>>>(rows);
for (int r = 0; r < rows; r++) {
minForDistance.add(new ArrayList<List<Integer>>(cols));
for (int c = 0; c < cols; c++) {
minForDistance.get(r).add(new ArrayList<Integer>(Collections.nCopies(mid+1, Integer.MAX_VALUE)));
minForDistance.get(r).get(c).set(0, 0);
}
}
for (int m = 1; m <= mid; m++) {
for (int r = 0; r < rows; r++) {
for (int c = 0; c < cols; c++) {
int minBoredom = minForDistance.get(r).get(c).get(m);
if (r > 0) {
if (minForDistance.get(r-1).get(c).get(m-1) < Integer.MAX_VALUE) {
int candidateBoredom = minForDistance.get(r-1).get(c).get(m-1) + verticalEdgeWeights.get(r-1).get(c);
minBoredom = Math.min(minBoredom, candidateBoredom);
}
}
if (c > 0) {
if (minForDistance.get(r).get(c-1).get(m-1) < Integer.MAX_VALUE) {
int candidateBoredom = minForDistance.get(r).get(c-1).get(m-1) + horizontalEdgeWeights.get(r).get(c-1);
minBoredom = Math.min(minBoredom, candidateBoredom);
}
}
if (r + 1 < rows) {
if (minForDistance.get(r+1).get(c).get(m-1) < Integer.MAX_VALUE) {
int candidateBoredom = minForDistance.get(r+1).get(c).get(m-1) + verticalEdgeWeights.get(r).get(c);
minBoredom = Math.min(minBoredom, candidateBoredom);
}
}
if (c + 1 < cols) {
if (minForDistance.get(r).get(c+1).get(m-1) < Integer.MAX_VALUE) {
int candidateBoredom = minForDistance.get(r).get(c+1).get(m-1) + horizontalEdgeWeights.get(r).get(c);
minBoredom = Math.min(minBoredom, candidateBoredom);
}
}
minForDistance.get(r).get(c).set(m, minBoredom);
}
}
}
List<List<Integer>> result = new ArrayList<List<Integer>>(rows);
for (int r = 0; r < rows; r++) {
result.add(new ArrayList<Integer>(cols));
for (int c = 0; c < cols; c++) {
result.get(r).add(minForDistance.get(r).get(c).get(mid) << 1);
}
}
return result;
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
|
Cirno has prepared n arrays of length n each. Each array is a permutation of n integers from 1 to n. These arrays are special: for all 1 ≤ i ≤ n, if we take the i-th element of each array and form another array of length n with these elements, the resultant array is also a permutation of n integers from 1 to n. In the other words, if you put these n arrays under each other to form a matrix with n rows and n columns, this matrix is a [Latin square](https://en.wikipedia.org/wiki/Latin_square).
Afterwards, Cirno added additional n arrays, each array is a permutation of n integers from 1 to n. For all 1 ≤ i ≤ n, there exists at least one position 1 ≤ k ≤ n, such that for the i-th array and the (n + i)-th array, the k-th element of both arrays is the same. Notice that the arrays indexed from n + 1 to 2n don't have to form a Latin square.
Also, Cirno made sure that for all 2n arrays, no two arrays are completely equal, i. e. for all pair of indices 1 ≤ i < j ≤ 2n, there exists at least one position 1 ≤ k ≤ n, such that the k-th elements of the i-th and j-th array are different.
Finally, Cirno arbitrarily changed the order of 2n arrays.
AquaMoon calls a subset of all 2n arrays of size n good if these arrays from a Latin square.
AquaMoon wants to know how many good subsets exist. Because this number may be particularly large, find it modulo 998 244 353. Also, she wants to find any good subset. Can you help her?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (5 ≤ n ≤ 500).
Then 2n lines followed. The i-th of these lines contains n integers, representing the i-th array.
It is guaranteed, that the sum of n over all test cases does not exceed 500.
Output
For each test case print two lines.
In the first line, print the number of good subsets by modulo 998 244 353.
In the second line, print n indices from 1 to 2n — indices of the n arrays that form a good subset (you can print them in any order). If there are several possible answers — print any of them.
Example
Input
3
7
1 2 3 4 5 6 7
2 3 4 5 6 7 1
3 4 5 6 7 1 2
4 5 6 7 1 2 3
5 6 7 1 2 3 4
6 7 1 2 3 4 5
7 1 2 3 4 5 6
1 2 3 4 5 7 6
1 3 4 5 6 7 2
1 4 5 6 7 3 2
1 5 6 7 4 2 3
1 6 7 5 2 3 4
1 7 6 2 3 4 5
1 7 2 3 4 5 6
5
4 5 1 2 3
3 5 2 4 1
1 2 3 4 5
5 2 4 1 3
3 4 5 1 2
2 3 4 5 1
1 3 5 2 4
4 1 3 5 2
2 4 1 3 5
5 1 2 3 4
6
2 3 4 5 6 1
3 1 2 6 4 5
6 1 2 3 4 5
5 6 1 3 2 4
4 3 6 5 2 1
5 6 1 2 3 4
4 5 6 1 2 3
3 4 5 6 1 2
1 2 3 4 5 6
2 5 4 1 6 3
3 2 5 4 1 6
1 4 3 6 5 2
Output
1
1 2 3 4 5 6 7
2
1 3 5 6 10
4
1 3 6 7 8 9
Note
In the first test case, the number of good subsets is 1. The only such subset is the set of arrays with indices 1, 2, 3, 4, 5, 6, 7.
In the second test case, the number of good subsets is 2. They are 1, 3, 5, 6, 10 or 2, 4, 7, 8, 9.
|
#include <cstdio>
#include <vector>
#include <set>
using namespace std;
const int mod = 998244353;
set<int> e[510][510];
int a[1010][510], d[1010][1010], u[1010];
vector<int> col[2], g[1010];
void dfs(int v, int b) {
u[v] = -2;
col[b].push_back(v);
for (int i = 0; i < g[v].size(); i++) {
int w = g[v][i];
if (u[w] == -1) dfs(w, !b);
}
}
void solve() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
e[i][j].clear();
}
}
for (int i = 0; i < 2 * n; i++) {
for (int j = 0; j < 2 * n; j++) {
d[i][j] = 0;
}
}
for (int i = 0; i < 2 * n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &a[i][j]);
--a[i][j];
e[j][a[i][j]].insert(i);
}
u[i] = -1;
}
vector<int> ad;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (e[i][j].size() == 1) {
int x = *e[i][j].begin();
if (u[x] != 1) {
ad.push_back(x);
u[x] = 1;
}
e[i][j].clear();
}
}
}
while (ad.size()) {
set<int> de;
for (int i = 0; i < ad.size(); i++) {
for (int j = 0; j < n; j++) {
int x = a[ad[i]][j];
e[j][x].erase(ad[i]);
de.insert(e[j][x].begin(), e[j][x].end());
e[j][x].clear();
}
}
ad.clear();
vector<int> v(de.begin(), de.end());
for (int i = 0; i < v.size(); i++) {
u[v[i]] = 0;
for (int j = 0; j < n; j++) {
int x = a[v[i]][j];
e[j][x].erase(v[i]);
if (e[j][x].size() == 1) {
int y = *e[j][x].begin();
if (u[y] != 1) {
ad.push_back(y);
u[y] = 1;
}
e[j][x].clear();
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
vector<int> w(e[i][j].begin(), e[i][j].end());
for (int k = 0; k < w.size(); k++) {
for (int l = k + 1; l < w.size(); l++) {
d[w[k]][w[l]] = d[w[l]][w[k]] = 1;
}
}
}
}
for (int i = 0; i < 2 * n; i++) {
g[i].clear();
for (int j = 0; j < 2 * n; j++) {
if (d[i][j]) g[i].push_back(j);
}
}
int ans = 1;
for (int i = 0; i < 2 * n; i++) {
if (u[i] != -1) continue;
col[0].clear();
col[1].clear();
dfs(i, 0);
int t = col[0].size() < col[1].size();
for (int k = 0; k < 2; k++) {
for (int j = 0; j < col[k].size(); j++) {
u[col[k][j]] = k == t;
}
}
if (col[0].size() == col[1].size()) {
ans += ans;
if (ans >= mod) ans -= mod;
}
}
printf("%d\n", ans);
for (int i = 0; i < 2 * n; i++) {
if (u[i]) printf("%d ", i + 1);
}
puts("");
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
solve();
}
return 0;
}
|
Polycarpus has recently got interested in sequences of pseudorandom numbers. He learned that many programming languages generate such sequences in a similar way: <image> (for i ≥ 1). Here a, b, m are constants, fixed for the given realization of the pseudorandom numbers generator, r0 is the so-called randseed (this value can be set from the program using functions like RandSeed(r) or srand(n)), and <image> denotes the operation of taking the remainder of division.
For example, if a = 2, b = 6, m = 12, r0 = 11, the generated sequence will be: 4, 2, 10, 2, 10, 2, 10, 2, 10, 2, 10, ....
Polycarpus realized that any such sequence will sooner or later form a cycle, but the cycle may occur not in the beginning, so there exist a preperiod and a period. The example above shows a preperiod equal to 1 and a period equal to 2.
Your task is to find the period of a sequence defined by the given values of a, b, m and r0. Formally, you have to find such minimum positive integer t, for which exists such positive integer k, that for any i ≥ k: ri = ri + t.
Input
The single line of the input contains four integers a, b, m and r0 (1 ≤ m ≤ 105, 0 ≤ a, b ≤ 1000, 0 ≤ r0 < m), separated by single spaces.
Output
Print a single integer — the period of the sequence.
Examples
Input
2 6 12 11
Output
2
Input
2 3 5 1
Output
4
Input
3 6 81 9
Output
1
Note
The first sample is described above.
In the second sample the sequence is (starting from the first element): 0, 3, 4, 1, 0, 3, 4, 1, 0, ...
In the third sample the sequence is (starting from the first element): 33, 24, 78, 78, 78, 78, ...
|
#include <bits/stdc++.h>
using namespace std;
int d[100100], a, b, m, r;
int main() {
cin >> a >> b >> m >> r;
d[r] = 1;
for (int i = 2;; i++) {
r = (r * a + b) % m;
if (d[r]) {
cout << i - d[r] << endl;
return 0;
}
d[r] = i;
}
}
|
The ancient Berlanders believed that the longer the name, the more important its bearer is. Thus, Berland kings were famous for their long names. But long names are somewhat inconvenient, so the Berlanders started to abbreviate the names of their kings. They called every king by the first letters of its name. Thus, the king, whose name was Victorious Vasily Pupkin, was always called by the berlanders VVP.
In Berland over its long history many dynasties of kings replaced each other, but they were all united by common traditions. Thus, according to one Berland traditions, to maintain stability in the country, the first name of the heir should be the same as the last name his predecessor (hence, the first letter of the abbreviated name of the heir coincides with the last letter of the abbreviated name of the predecessor). Berlanders appreciate stability, so this tradition has never been broken. Also Berlanders like perfection, so another tradition requires that the first name of the first king in the dynasty coincides with the last name of the last king in this dynasty (hence, the first letter of the abbreviated name of the first king coincides with the last letter of the abbreviated name of the last king). This tradition, of course, has also been always observed.
The name of a dynasty is formed by very simple rules: we take all the short names of the kings in the order in which they ruled, and write them in one line. Thus, a dynasty of kings "ab" and "ba" is called "abba", and the dynasty, which had only the king "abca", is called "abca".
Vasya, a historian, has recently found a list of abbreviated names of all Berland kings and their relatives. Help Vasya to find the maximally long name of the dynasty that could have existed in Berland.
Note that in his list all the names are ordered by the time, that is, if name A is earlier in the list than B, then if A and B were kings, then king A ruled before king B.
Input
The first line contains integer n (1 ≤ n ≤ 5·105) — the number of names in Vasya's list. Next n lines contain n abbreviated names, one per line. An abbreviated name is a non-empty sequence of lowercase Latin letters. Its length does not exceed 10 characters.
Output
Print a single number — length of the sought dynasty's name in letters.
If Vasya's list is wrong and no dynasty can be found there, print a single number 0.
Examples
Input
3
abc
ca
cba
Output
6
Input
4
vvp
vvp
dam
vvp
Output
0
Input
3
ab
c
def
Output
1
Note
In the first sample two dynasties can exist: the one called "abcca" (with the first and second kings) and the one called "abccba" (with the first and third kings).
In the second sample there aren't acceptable dynasties.
The only dynasty in the third sample consists of one king, his name is "c".
|
import sys
import math
from heapq import *;
input = sys.stdin.readline
from functools import cmp_to_key;
def pi():
return(int(input()))
def pl():
return(int(input(), 16))
def ti():
return(list(map(int,input().split())))
def ts():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
mod = 1000000007;
f = [];
def fact(n,m):
global f;
f = [1 for i in range(n+1)];
f[0] = 1;
for i in range(1,n+1):
f[i] = (f[i-1]*i)%m;
def fast_mod_exp(a,b,m):
res = 1;
while b > 0:
if b & 1:
res = (res*a)%m;
a = (a*a)%m;
b = b >> 1;
return res;
def inverseMod(n,m):
return fast_mod_exp(n,m-2,m);
def ncr(n,r,m):
if n < 0 or r < 0 or r > n: return 0;
if r == 0: return 1;
return ((f[n]*inverseMod(f[n-r],m))%m*inverseMod(f[r],m))%m;
def main():
C();
def C():
n = pi();
x = [];
dp = [[0 for j in range(26)] for i in range(26)];
ans = 0;
for i in range(n):
x.append(input()[:-1]);
l = ord(x[i][0]) - ord('a');
r = ord(x[i][len(x[i])-1]) - ord('a');
for j in range(26):
if dp[j][l] != 0:
dp[j][r] = max(dp[j][r], dp[j][l]+len(x[i]));
dp[l][r] = max(dp[l][r], len(x[i]));
for i in range(26):
ans = max(ans, dp[i][i]);
print(ans);
main();
|
A new Berland businessman Vitaly is going to open a household appliances' store. All he's got to do now is to hire the staff.
The store will work seven days a week, but not around the clock. Every day at least k people must work in the store.
Berland has a law that determines the order of working days and non-working days. Namely, each employee must work for exactly n consecutive days, then rest for exactly m days, then work for n more days and rest for m more, and so on. Vitaly doesn't want to break the law. Fortunately, there is a loophole: the law comes into force on the day when the employee is hired. For example, if an employee is hired on day x, then he should work on days [x, x + 1, ..., x + n - 1], [x + m + n, x + m + n + 1, ..., x + m + 2n - 1], and so on. Day x can be chosen arbitrarily by Vitaly.
There is one more thing: the key to the store. Berland law prohibits making copies of keys, so there is only one key. Vitaly is planning to entrust the key to the store employees. At the same time on each day the key must be with an employee who works that day — otherwise on this day no one can get inside the store. During the day the key holder can give the key to another employee, if he also works that day. The key will handed to the first hired employee at his first working day.
Each employee has to be paid salary. Therefore, Vitaly wants to hire as few employees as possible provided that the store can operate normally on each day from 1 to infinity. In other words, on each day with index from 1 to infinity, the store must have at least k working employees, and one of the working employees should have the key to the store.
Help Vitaly and determine the minimum required number of employees, as well as days on which they should be hired.
Input
The first line contains three integers n, m and k (1 ≤ m ≤ n ≤ 1000, n ≠ 1, 1 ≤ k ≤ 1000).
Output
In the first line print a single integer z — the minimum required number of employees.
In the second line print z positive integers, separated by spaces: the i-th integer ai (1 ≤ ai ≤ 104) should represent the number of the day, on which Vitaly should hire the i-th employee.
If there are multiple answers, print any of them.
Examples
Input
4 3 2
Output
4
1 1 4 5
Input
3 3 1
Output
3
1 3 5
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, m, k;
vector<long long int> v;
cin >> n >> m >> k;
if (k == 1) {
for (long long int i = 1; i <= n + m; i += (n - 1)) v.push_back(i);
} else {
for (long long int i = 0; i < k; i++) v.push_back(1);
for (long long int i = 2; i <= n + m; ++i) {
if (i % n == 0)
v.push_back(i);
else if (i % n == 1) {
for (long long int j = 0; j < k - 1; j++) v.push_back(i);
}
}
}
cout << v.size() << "\n";
for (long long int i : v) cout << i << " ";
return;
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
solve();
return 0;
}
|
In 2N - 1 boxes there are apples and oranges. Your task is to choose N boxes so, that they will contain not less than half of all the apples and not less than half of all the oranges.
Input
The first input line contains one number T — amount of tests. The description of each test starts with a natural number N — amount of boxes. Each of the following 2N - 1 lines contains numbers ai and oi — amount of apples and oranges in the i-th box (0 ≤ ai, oi ≤ 109). The sum of N in all the tests in the input doesn't exceed 105. All the input numbers are integer.
Output
For each test output two lines. In the first line output YES, if it's possible to choose N boxes, or NO otherwise. If the answer is positive output in the second line N numbers — indexes of the chosen boxes. Boxes are numbered from 1 in the input order. Otherwise leave the second line empty. Separate the numbers with one space.
Examples
Input
2
2
10 15
5 7
20 18
1
0 0
Output
YES
1 3
YES
1
|
#include <bits/stdc++.h>
using namespace std;
struct box {
int a;
int o;
int ind;
};
vector<box> lst;
bool compare(const box &a, const box &b) { return a.a < b.a; }
int main() {
int t, n;
cin >> t;
while (t--) {
lst.clear();
cin >> n;
long long sumo = 0, tsumo = 0;
for (long long i = 0; i < 2 * n - 1; i++) {
box temp;
cin >> temp.a >> temp.o;
temp.ind = i + 1;
sumo += temp.o;
lst.push_back(temp);
}
sort(lst.begin(), lst.begin() + 2 * n - 1, compare);
for (int i = 0; i < 2 * n - 1; i += 2) {
tsumo += lst[i].o;
}
cout << "YES\n";
if (tsumo * 2 >= sumo) {
for (int i = 0; i < 2 * n - 1; i += 2) {
if (i > 0) cout << " ";
cout << lst[i].ind;
}
} else {
for (int i = 1; i < 2 * n - 1; i += 2) {
if (i > 1) cout << " ";
cout << lst[i].ind;
}
cout << " " << lst[2 * n - 2].ind;
}
cout << "\n";
}
return 0;
}
|
There is a sequence of colorful stones. The color of each stone is one of red, green, or blue. You are given a string s. The i-th (1-based) character of s represents the color of the i-th stone. If the character is "R", "G", or "B", the color of the corresponding stone is red, green, or blue, respectively.
Initially Squirrel Liss is standing on the first stone. You perform instructions one or more times.
Each instruction is one of the three types: "RED", "GREEN", or "BLUE". After an instruction c, if Liss is standing on a stone whose colors is c, Liss will move one stone forward, else she will not move.
You are given a string t. The number of instructions is equal to the length of t, and the i-th character of t represents the i-th instruction.
Calculate the final position of Liss (the number of the stone she is going to stand on in the end) after performing all the instructions, and print its 1-based position. It is guaranteed that Liss don't move out of the sequence.
Input
The input contains two lines. The first line contains the string s (1 ≤ |s| ≤ 50). The second line contains the string t (1 ≤ |t| ≤ 50). The characters of each string will be one of "R", "G", or "B". It is guaranteed that Liss don't move out of the sequence.
Output
Print the final 1-based position of Liss in a single line.
Examples
Input
RGB
RRR
Output
2
Input
RRRBGBRBBB
BBBRR
Output
3
Input
BRRBGBRGRBGRGRRGGBGBGBRGBRGRGGGRBRRRBRBBBGRRRGGBBB
BBRBGGRGRGBBBRBGRBRBBBBRBRRRBGBBGBBRRBBGGRBRRBRGRB
Output
15
|
import sys
a = sys.stdin.readline().strip()
b = sys.stdin.readline().strip()
count = 1
for i in b:
if i == a[count-1]:
count += 1
if count > len(a):
count = len(a)
print count
|
Little penguin Polo adores integer segments, that is, pairs of integers [l; r] (l ≤ r).
He has a set that consists of n integer segments: [l1; r1], [l2; r2], ..., [ln; rn]. We know that no two segments of this set intersect. In one move Polo can either widen any segment of the set 1 unit to the left or 1 unit to the right, that is transform [l; r] to either segment [l - 1; r], or to segment [l; r + 1].
The value of a set of segments that consists of n segments [l1; r1], [l2; r2], ..., [ln; rn] is the number of integers x, such that there is integer j, for which the following inequality holds, lj ≤ x ≤ rj.
Find the minimum number of moves needed to make the value of the set of Polo's segments divisible by k.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 105). Each of the following n lines contain a segment as a pair of integers li and ri ( - 105 ≤ li ≤ ri ≤ 105), separated by a space.
It is guaranteed that no two segments intersect. In other words, for any two integers i, j (1 ≤ i < j ≤ n) the following inequality holds, min(ri, rj) < max(li, lj).
Output
In a single line print a single integer — the answer to the problem.
Examples
Input
2 3
1 2
3 4
Output
2
Input
3 7
1 2
3 3
4 7
Output
0
|
import java.io.*;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;
public class Main {
FastScanner in;
PrintWriter out;
public void solve() throws IOException {
int result = 0;
int n = in.nextInt();
int k = in.nextInt();
int[] array = new int[n];
Random rng = new Random();
int count = 0;
for (int i=0; i<n; i++){
count += (in.nextInt() - in.nextInt()) * (-1) + 1;
}
result = (k - count%k)%k;
// for (int i=0; i<n; i++){
// int j = rng.nextInt(i + 1);
// long tmp = array[j];
// array[j] = array[i];
// array[i] = tmp;
// }
// Arrays.sort(array);
out.print(result);
// out.flush();
}
private boolean check(int turns, int x, int y, int x0, int y0) {
if (x0==x && y0==y){
out.println(turns);
return true;
}
return false;
}
public void run() {
try {
// in = new FastScanner(new File("Proba2.in"));
in = new FastScanner();
// out = new PrintWriter(new File(".out"));
out = new PrintWriter(System.out);
solve();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
class FastScanner {
BufferedReader br;
StringTokenizer st;
FastScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
FastScanner(File f) {
try {
br = new BufferedReader(new FileReader(f));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
}
public static void main(String[] arg) {
new Main().run();
}
}
|
During the last Sereja's Codesecrof round the server crashed many times, so the round was decided to be made unrated for some participants.
Let's assume that n people took part in the contest. Let's assume that the participant who got the first place has rating a1, the second place participant has rating a2, ..., the n-th place participant has rating an. Then changing the rating on the Codesecrof site is calculated by the formula <image>.
After the round was over, the Codesecrof management published the participants' results table. They decided that if for a participant di < k, then the round can be considered unrated for him. But imagine the management's surprise when they found out that the participants' rating table is dynamic. In other words, when some participant is removed from the rating, he is removed from the results' table and the rating is recalculated according to the new table. And of course, all applications for exclusion from the rating are considered in view of the current table.
We know that among all the applications for exclusion from the rating the first application to consider is from the participant with the best rank (the rank with the minimum number), for who di < k. We also know that the applications for exclusion from rating were submitted by all participants.
Now Sereja wonders, what is the number of participants to be excluded from the contest rating, and the numbers of the participants in the original table in the order of their exclusion from the rating. Pay attention to the analysis of the first test case for a better understanding of the statement.
Input
The first line contains two integers n, k (1 ≤ n ≤ 2·105, - 109 ≤ k ≤ 0). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — ratings of the participants in the initial table.
Output
Print the numbers of participants in the order in which they were removed from the table. Print the initial numbers of the participants, that is, the numbers that the participants had in the initial table.
Examples
Input
5 0
5 3 4 1 2
Output
2
3
4
Input
10 -10
5 5 1 7 5 1 2 4 9 2
Output
2
4
5
7
8
9
Note
Consider the first test sample.
1. Initially the sequence of the contest participants' ratings equals [5, 3, 4, 1, 2]. You can use this sequence to calculate the sequence of rating changes: [0, -9, -13, 8, 14]. According to the problem statement, the application of the participant who won the second place will be considered first.
2. As soon as the second place winner is out from the ratings, the participants' rating sequence will equal [5, 4, 1, 2]. By this sequence you can count the new sequence of rating changes: [0, -8, 2, 6]. According to the problem statement, the application of the participant who won the second place will be considered. Initially this participant won third place.
3. The new rating sequence equals [5, 1, 2], the new sequence of rating changes equals [0, -1, 1]. The second place participant's application is taken into consideration, initially this participant won the fourth place.
4. The new rating sequence equals [5, 2], the new sequence of rating changes equals [0, 0]. No more applications will be considered.
Thus, you should print 2, 3, 4.
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, a, c, sum;
int j = 1;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
c = n;
for (int i = 1; i <= n; ++i) {
cin >> a;
if ((sum - (c - j) * (j - 1) * a) < k) {
cout << i << '\n';
--c;
} else {
sum += a * (j - 1);
++j;
}
}
}
|
Vasily the bear has got a sequence of positive integers a1, a2, ..., an. Vasily the Bear wants to write out several numbers on a piece of paper so that the beauty of the numbers he wrote out was maximum.
The beauty of the written out numbers b1, b2, ..., bk is such maximum non-negative integer v, that number b1 and b2 and ... and bk is divisible by number 2v without a remainder. If such number v doesn't exist (that is, for any non-negative integer v, number b1 and b2 and ... and bk is divisible by 2v without a remainder), the beauty of the written out numbers equals -1.
Tell the bear which numbers he should write out so that the beauty of the written out numbers is maximum. If there are multiple ways to write out the numbers, you need to choose the one where the bear writes out as many numbers as possible.
Here expression x and y means applying the bitwise AND operation to numbers x and y. In programming languages C++ and Java this operation is represented by "&", in Pascal — by "and".
Input
The first line contains integer n (1 ≤ n ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ a1 < a2 < ... < an ≤ 109).
Output
In the first line print a single integer k (k > 0), showing how many numbers to write out. In the second line print k integers b1, b2, ..., bk — the numbers to write out. You are allowed to print numbers b1, b2, ..., bk in any order, but all of them must be distinct. If there are multiple ways to write out the numbers, choose the one with the maximum number of numbers to write out. If there still are multiple ways, you are allowed to print any of them.
Examples
Input
5
1 2 3 4 5
Output
2
4 5
Input
3
1 2 4
Output
1
4
|
#include <bits/stdc++.h>
using namespace std;
int n, ns[100100], cnt;
int ble(int a) {
while (a - (a & -a)) a -= a & -a;
return a;
}
bool test(int v) {
int a = -1;
cnt = 0;
for (int i = 0; i < n; ++i)
if (ns[i] & (1 << v)) a &= ns[i], cnt++;
return !(a % (1 << v));
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &ns[i]);
for (int v = 30; v >= 0; v--)
if (test(v)) {
printf("%d\n", cnt);
bool lol = 0;
int bla = 1 << v;
for (int i = 0; i < n; ++i)
if (ns[i] & bla) {
if (lol)
printf(" ");
else
lol = 1;
printf("%d", ns[i]);
}
puts("");
break;
}
return 0;
}
|
Simon has an array a1, a2, ..., an, consisting of n positive integers. Today Simon asked you to find a pair of integers l, r (1 ≤ l ≤ r ≤ n), such that the following conditions hold:
1. there is integer j (l ≤ j ≤ r), such that all integers al, al + 1, ..., ar are divisible by aj;
2. value r - l takes the maximum value among all pairs for which condition 1 is true;
Help Simon, find the required pair of numbers (l, r). If there are multiple required pairs find all of them.
Input
The first line contains integer n (1 ≤ n ≤ 3·105).
The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 106).
Output
Print two integers in the first line — the number of required pairs and the maximum value of r - l. On the following line print all l values from optimal pairs in increasing order.
Examples
Input
5
4 6 9 3 6
Output
1 3
2
Input
5
1 3 5 7 9
Output
1 4
1
Input
5
2 3 5 7 11
Output
5 0
1 2 3 4 5
Note
In the first sample the pair of numbers is right, as numbers 6, 9, 3 are divisible by 3.
In the second sample all numbers are divisible by number 1.
In the third sample all numbers are prime, so conditions 1 and 2 are true only for pairs of numbers (1, 1), (2, 2), (3, 3), (4, 4), (5, 5).
|
#include <bits/stdc++.h>
using namespace std;
int const N = 512312;
int const INF = 1e9 + 7;
int n, a[N], mn[35][N], gcd[35][N], numlog[N];
int gcd__(int a, int b) { return b ? gcd__(b, a % b) : a; }
void build1() {
numlog[1] = 0;
for (int c = 2; c <= n; c++) {
numlog[c] = numlog[c / 2] + 1;
}
for (int c = 0; c <= numlog[n]; c++) {
int len = 1 << c;
for (int i = 1; i <= n; i++) {
if (c == 0) {
mn[c][i] = a[i];
} else {
mn[c][i] = min(mn[c - 1][i], mn[c - 1][i + len / 2]);
}
}
}
}
void build2() {
for (int c = 0; c <= numlog[n]; c++) {
int len = 1 << c;
for (int i = 1; i <= n; i++) {
if (c == 0) {
gcd[c][i] = a[i];
} else {
gcd[c][i] = gcd__(gcd[c - 1][i], gcd[c - 1][i + len / 2]);
}
}
}
}
int get1(int l, int r) {
if (r > n) r = n;
if (l < 1) l = 1;
int len = numlog[r - l + 1];
return min(mn[len][l], mn[len][r - (1 << len) + 1]);
}
int get2(int l, int r) {
if (r > n) r = n;
if (l < 1) l = 1;
int len = numlog[r - l + 1];
return gcd__(gcd[len][l], gcd[len][r - (1 << len) + 1]);
}
bool ok(int len) {
for (int c = 1; c <= n - len + 1; c++) {
if (get1(c, c + len - 1) == get2(c, c + len - 1)) return true;
}
return false;
}
int main() {
scanf("%d", &n);
for (int c = 1; c <= n; c++) {
scanf("%d", &a[c]);
}
build1();
build2();
int l = 1, r = n, ans = 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (ok(mid)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
ans--;
vector<int> res;
for (int c = 1; c <= n - ans; c++) {
if (get1(c, c + ans) == get2(c, c + ans)) res.push_back(c);
}
cout << res.size() << " " << ans << endl;
for (int c = 0; c < res.size(); c++) {
cout << res[c] << " ";
}
return 0;
}
|
Everybody knows what an arithmetic progression is. Let us remind you just in case that an arithmetic progression is such sequence of numbers a1, a2, ..., an of length n, that the following condition fulfills:
a2 - a1 = a3 - a2 = a4 - a3 = ... = ai + 1 - ai = ... = an - an - 1.
For example, sequences [1, 5], [10], [5, 4, 3] are arithmetic progressions and sequences [1, 3, 2], [1, 2, 4] are not.
Alexander has n cards containing integers. Arthur wants to give Alexander exactly one more card with a number so that he could use the resulting n + 1 cards to make an arithmetic progression (Alexander has to use all of his cards).
Arthur has already bought a card but he hasn't written a number on it. Help him, print all integers that you can write on a card so that the described condition fulfilled.
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of cards. The next line contains the sequence of integers — the numbers on Alexander's cards. The numbers are positive integers, each of them doesn't exceed 108.
Output
If Arthur can write infinitely many distinct integers on the card, print on a single line -1.
Otherwise, print on the first line the number of integers that suit you. In the second line, print the numbers in the increasing order. Note that the numbers in the answer can exceed 108 or even be negative (see test samples).
Examples
Input
3
4 1 7
Output
2
-2 10
Input
1
10
Output
-1
Input
4
1 3 5 9
Output
1
7
Input
4
4 3 4 5
Output
0
Input
2
2 4
Output
3
0 3 6
|
#!/usr/bin/python
from __future__ import division
from sys import stdin, stdout, maxint
import fractions, math, bisect
N = int (stdin.readline ())
arr = map (int, stdin.readline ().split ())
if N == 1:
print -1
else:
arr.sort ()
mindiff = maxint
for n in xrange (N - 1):
mindiff = min (mindiff, arr[n + 1] - arr[n])
i, j, cnt = 0, 0, 0
for n in xrange (N - 1):
if arr[n + 1] - arr[n] != mindiff:
cnt += 1
i, j = n, n + 1
ans = set ()
if cnt == 0:
ans.add (arr[0] - mindiff)
ans.add (arr[N - 1] + mindiff)
if N == 2 and (arr[1] - arr[0]) % 2 == 0:
ans.add (arr[0] + (arr[1] - arr[0]) // 2)
elif cnt == 1:
insertion = arr[i] + mindiff
if insertion + mindiff == arr[j]:
ans.add (insertion)
print len (ans)
lst = sorted (list (ans))
for e in lst:
stdout.write (str (e) + ' ')
|
You have an array of positive integers a[1], a[2], ..., a[n] and a set of bad prime numbers b1, b2, ..., bm. The prime numbers that do not occur in the set b are considered good. The beauty of array a is the sum <image>, where function f(s) is determined as follows:
* f(1) = 0;
* Let's assume that p is the minimum prime divisor of s. If p is a good prime, then <image>, otherwise <image>.
You are allowed to perform an arbitrary (probably zero) number of operations to improve array a. The operation of improvement is the following sequence of actions:
* Choose some number r (1 ≤ r ≤ n) and calculate the value g = GCD(a[1], a[2], ..., a[r]).
* Apply the assignments: <image>, <image>, ..., <image>.
What is the maximum beauty of the array you can get?
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 5000) showing how many numbers are in the array and how many bad prime numbers there are.
The second line contains n space-separated integers a[1], a[2], ..., a[n] (1 ≤ a[i] ≤ 109) — array a. The third line contains m space-separated integers b1, b2, ..., bm (2 ≤ b1 < b2 < ... < bm ≤ 109) — the set of bad prime numbers.
Output
Print a single integer — the answer to the problem.
Examples
Input
5 2
4 20 34 10 10
2 5
Output
-2
Input
4 5
2 4 8 16
3 5 7 11 17
Output
10
Note
Note that the answer to the problem can be negative.
The GCD(x1, x2, ..., xk) is the maximum positive integer that divides each xi.
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 5005;
const int Maxm = 100005;
bool nprime[Maxm];
vector<int> pr;
bool bad[Maxm];
set<int> B;
int n, m;
int a[Maxn];
int g[Maxn], best[Maxn];
int delt[Maxn];
int sum, bdelt;
int gcd(int x, int y) { return x ? gcd(y % x, x) : y; }
int main() {
for (int i = 2; i < Maxm; i++)
if (!nprime[i]) {
pr.push_back(i);
for (int j = i + i; j < Maxm; j += i) nprime[j] = true;
}
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) {
int b;
scanf("%d", &b);
if (b < Maxm)
bad[b] = true;
else
B.insert(b);
}
for (int i = 1; i <= n; i++) {
int num = a[i];
for (int j = 0; pr[j] * pr[j] <= num; j++)
if (num % pr[j] == 0)
if (bad[pr[j]]) do {
sum--;
num /= pr[j];
} while (num % pr[j] == 0);
else
do {
sum++;
num /= pr[j];
} while (num % pr[j] == 0);
if (num > 1)
if (num < Maxm)
sum += bad[num] ? -1 : 1;
else
sum += B.count(num) ? -1 : 1;
g[i] = gcd(g[i - 1], a[i]);
}
for (int i = n; i >= 1; i--) {
int num = g[i];
delt[i] = 0;
for (int j = 0; pr[j] * pr[j] <= num; j++)
if (num % pr[j] == 0)
if (bad[pr[j]]) do {
delt[i]++;
num /= pr[j];
} while (num % pr[j] == 0);
else
do {
delt[i]--;
num /= pr[j];
} while (num % pr[j] == 0);
if (num > 1)
if (num < Maxm)
delt[i] += bad[num] ? 1 : -1;
else
delt[i] += B.count(num) ? 1 : -1;
best[i] = delt[i] * i;
for (int j = i + 1; j <= n; j++)
best[i] = max(best[i], (delt[i] - delt[j]) * i + best[j]);
bdelt = max(bdelt, best[i]);
}
printf("%d\n", sum + bdelt);
return 0;
}
|
Iahub is very proud of his recent discovery, propagating trees. Right now, he invented a new tree, called xor-tree. After this new revolutionary discovery, he invented a game for kids which uses xor-trees.
The game is played on a tree having n nodes, numbered from 1 to n. Each node i has an initial value initi, which is either 0 or 1. The root of the tree is node 1.
One can perform several (possibly, zero) operations on the tree during the game. The only available type of operation is to pick a node x. Right after someone has picked node x, the value of node x flips, the values of sons of x remain the same, the values of sons of sons of x flips, the values of sons of sons of sons of x remain the same and so on.
The goal of the game is to get each node i to have value goali, which can also be only 0 or 1. You need to reach the goal of the game by using minimum number of operations.
Input
The first line contains an integer n (1 ≤ n ≤ 105). Each of the next n - 1 lines contains two integers ui and vi (1 ≤ ui, vi ≤ n; ui ≠ vi) meaning there is an edge between nodes ui and vi.
The next line contains n integer numbers, the i-th of them corresponds to initi (initi is either 0 or 1). The following line also contains n integer numbers, the i-th number corresponds to goali (goali is either 0 or 1).
Output
In the first line output an integer number cnt, representing the minimal number of operations you perform. Each of the next cnt lines should contain an integer xi, representing that you pick a node xi.
Examples
Input
10
2 1
3 1
4 2
5 1
6 2
7 5
8 6
9 8
10 5
1 0 1 1 0 1 0 1 0 1
1 0 1 0 0 1 1 1 0 1
Output
2
4
7
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100001;
int n;
vector<int> g[N];
int a[N];
int b[N];
vector<int> ans;
void dfs(int now, int fa, int depth, int k[2]) {
a[now] ^= k[depth & 1];
if (a[now] != b[now]) {
ans.push_back(now);
k[depth & 1] ^= 1;
}
for (int i = 0; i < g[now].size(); ++i)
if (g[now][i] != fa) {
int kk[2];
kk[0] = k[0];
kk[1] = k[1];
dfs(g[now][i], now, depth + 1, kk);
}
}
int main() {
scanf("%d", &n);
int u, v;
for (int i = 0; i < n - 1; ++i) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &b[i]);
int k[2] = {0, 0};
dfs(1, 0, 0, k);
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); ++i) printf("%d\n", ans[i]);
return 0;
}
|
You are given a permutation of numbers from 1 to n. Determine whether there's a pair of integers a, b (1 ≤ a, b ≤ n; a ≠ b) such that the element <image> (note, that it is usual division, not integer one) is between a and b in this permutation.
Input
First line consists of a single integer n (1 ≤ n ≤ 300000) — the size of permutation.
Second line contains n integers — the permutation itself.
Output
Print "YES", if such a pair exists, "NO" otherwise (in both cases without quotes, the answer is case insensitive).
Examples
Input
4
1 3 4 2
Output
NO
Input
5
1 5 2 4 3
Output
YES
Note
In the second example 2 is between 1 and 3. Additionally 4 is between 3 and 5.
|
#include <bits/stdc++.h>
using namespace std;
namespace zzc {
const int maxn = 5e5 + 5;
long long c[maxn], a[maxn], l[maxn], r[maxn];
long long t, n;
long long lowbit(long long x) { return x & (-x); }
void update(long long pos, long long k) {
for (long long i = pos; i <= n; i += lowbit(i)) {
c[i] += k;
}
}
long long query(long long pos) {
long long res = 0;
for (long long i = pos; i; i -= lowbit(i)) {
res += c[i];
}
return res;
}
void work() {
scanf("%lld", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) {
if (a[i] * 2 - 1 <= n)
l[i] = query(a[i] * 2 - 1);
else
l[i] = query(n) - query(2 * a[i] - n - 1);
update(a[i], a[i]);
}
for (int i = n; i >= 1; i--) {
if (a[i] * 2 - 1 <= n)
r[i] = query(a[i] * 2 - 1);
else
r[i] = query(n) - query(a[i] * 2 - n - 1);
update(a[i], a[i]);
}
bool flag = false;
for (int i = 1; i <= n; i++) {
if (l[i] && r[i] && l[i] % (2 * a[i]) && r[i] % (2 * a[i])) {
flag = true;
printf("YES\n");
break;
}
}
if (!flag) printf("NO\n");
}
} // namespace zzc
int main() {
zzc::work();
return 0;
}
|
Given a sequence of integers a1, ..., an and q queries x1, ..., xq on it. For each query xi you have to count the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ n and gcd(al, al + 1, ..., ar) = xi.
<image> is a greatest common divisor of v1, v2, ..., vn, that is equal to a largest positive integer that divides all vi.
Input
The first line of the input contains integer n, (1 ≤ n ≤ 105), denoting the length of the sequence. The next line contains n space separated integers a1, ..., an, (1 ≤ ai ≤ 109).
The third line of the input contains integer q, (1 ≤ q ≤ 3 × 105), denoting the number of queries. Then follows q lines, each contain an integer xi, (1 ≤ xi ≤ 109).
Output
For each query print the result in a separate line.
Examples
Input
3
2 6 3
5
1
2
3
4
6
Output
1
2
2
0
1
Input
7
10 20 3 15 1000 60 16
10
1
2
3
4
5
6
10
20
60
1000
Output
14
0
2
2
2
0
2
2
1
1
|
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class Main extends PrintWriter {
final Random rand = new Random(31);
final int inf = (int) 1e9;
final long linf = (long) 1e18;
final static String IO = "_std";
int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
void solve() throws IOException {
int n = nextInt();
int[] a = nextIntArray(n);
Map<Integer, Long> ans = new TreeMap<>();
Map<Integer, Long> divs = new TreeMap<>();
Map<Integer, Long> nDivs = new TreeMap<>();
for (int i = 0; i < n; i++) {
nDivs.clear();
for (Map.Entry<Integer, Long> d : divs.entrySet()) {
nDivs.compute(gcd(a[i], d.getKey()), (k, v) -> v == null ? d.getValue() : v + d.getValue());
}
nDivs.compute(a[i], (k, v) -> v == null ? 1 : v + 1);
Map<Integer, Long> _ = divs;
divs = nDivs;
nDivs = _;
for (Map.Entry<Integer, Long> d : divs.entrySet()) {
ans.compute(d.getKey(), (k, v) -> v == null ? d.getValue() : v + d.getValue());
}
}
int q = nextInt();
while (q-- > 0) {
println(ans.getOrDefault(nextInt(), 0L));
}
}
BufferedReader in;
StringTokenizer stok;
Main() {
super(System.out);
in = new BufferedReader(new InputStreamReader(System.in));
}
Main(String fileIn, String fileOut) throws IOException {
super(fileOut);
in = new BufferedReader(new FileReader(fileIn));
}
public static void main(String[] args) throws IOException {
Main main;
if ("_std".equals(IO)) {
main = new Main();
} else if ("_iotxt".equals(IO)) {
main = new Main("input.txt", "output.txt");
} else {
main = new Main(IO + ".in", IO + ".out");
}
main.solve();
main.close();
}
String next() throws IOException {
while (stok == null || !stok.hasMoreTokens()) {
String s = in.readLine();
if (s == null) {
return null;
}
stok = new StringTokenizer(s);
}
return stok.nextToken();
}
int nextInt() throws IOException {
return Integer.parseInt(next());
}
long nextLong() throws IOException {
return Long.parseLong(next());
}
double nextDouble() throws IOException {
return Double.parseDouble(next());
}
int[] nextIntArray(int len) throws IOException {
int[] a = new int[len];
for (int i = 0; i < len; i++) {
a[i] = nextInt();
}
return a;
}
int[] nextIntArraySorted(int len) throws IOException {
int[] a = nextIntArray(len);
shuffle(a);
Arrays.sort(a);
return a;
}
void shuffle(int[] a) {
for (int i = 1; i < a.length; i++) {
int x = rand.nextInt(i + 1);
int _ = a[i];
a[i] = a[x];
a[x] = _;
}
}
void shuffleAndSort(int[] a) {
shuffle(a);
Arrays.sort(a);
}
boolean nextPermutation(int[] p) {
for (int a = p.length - 2; a >= 0; --a) {
if (p[a] < p[a + 1])
for (int b = p.length - 1; ; --b)
if (p[b] > p[a]) {
int t = p[a];
p[a] = p[b];
p[b] = t;
for (++a, b = p.length - 1; a < b; ++a, --b) {
t = p[a];
p[a] = p[b];
p[b] = t;
}
return true;
}
}
return false;
}
<T> List<T>[] createAdjacencyList(int n) {
List<T>[] res = new List[n];
for (int i = 0; i < n; i++) {
res[i] = new ArrayList<>();
}
return res;
}
void println(Object... a) {
for (int i = 0; i < a.length; i++) {
if (i != 0) {
print(" ");
}
print(a[i]);
}
println();
}
}
|
It turns out that you are a great fan of rock band AC/PE. Peter learned that and started the following game: he plays the first song of the list of n songs of the group, and you have to find out the name of the song. After you tell the song name, Peter immediately plays the following song in order, and so on.
The i-th song of AC/PE has its recognizability pi. This means that if the song has not yet been recognized by you, you listen to it for exactly one more second and with probability of pi percent you recognize it and tell it's name. Otherwise you continue listening it. Note that you can only try to guess it only when it is integer number of seconds after the moment the song starts playing.
In all AC/PE songs the first words of chorus are the same as the title, so when you've heard the first ti seconds of i-th song and its chorus starts, you immediately guess its name for sure.
For example, in the song Highway To Red the chorus sounds pretty late, but the song has high recognizability. In the song Back In Blue, on the other hand, the words from the title sound close to the beginning of the song, but it's hard to name it before hearing those words. You can name both of these songs during a few more first seconds.
Determine the expected number songs of you will recognize if the game lasts for exactly T seconds (i. e. you can make the last guess on the second T, after that the game stops).
If all songs are recognized faster than in T seconds, the game stops after the last song is recognized.
Input
The first line of the input contains numbers n and T (1 ≤ n ≤ 5000, 1 ≤ T ≤ 5000), separated by a space. Next n lines contain pairs of numbers pi and ti (0 ≤ pi ≤ 100, 1 ≤ ti ≤ T). The songs are given in the same order as in Petya's list.
Output
Output a single number — the expected number of the number of songs you will recognize in T seconds. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Examples
Input
2 2
50 2
10 1
Output
1.500000000
Input
2 2
0 2
100 2
Output
1.000000000
Input
3 3
50 3
50 2
25 2
Output
1.687500000
Input
2 2
0 2
0 2
Output
1.000000000
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005;
int n, T;
int p[maxn], t[maxn];
double dp[maxn][maxn];
double pp, p1, tmp, ans;
int main() {
while (scanf("%d%d", &n, &T) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d%d", &p[i], &t[i]);
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
ans = 0;
for (int i = 1; i <= n; i++) {
pp = 0.01 * p[i];
p1 = 1;
for (int j = 1; j < t[i]; j++) p1 *= 1 - pp;
for (int j = 1; j <= T; j++) {
if (j < t[i])
dp[i][j] = dp[i][j - 1] * (1 - pp) + dp[i - 1][j - 1] * pp;
else {
if (j > t[i])
tmp = dp[i][j - 1] - p1 * dp[i - 1][j - 1 - t[i]];
else
tmp = dp[i][j - 1];
dp[i][j] = tmp * (1 - pp) + dp[i - 1][j - 1] * pp +
dp[i - 1][j - t[i]] * p1 * (1 - pp);
}
ans += dp[i][j];
}
}
printf("%.7lf\n", ans);
}
return 0;
}
|
Polycarp is writing the prototype of a graphic editor. He has already made up his mind that the basic image transformations in his editor will be: rotate the image 90 degrees clockwise, flip the image horizontally (symmetry relative to the vertical line, that is, the right part of the image moves to the left, and vice versa) and zooming on the image. He is sure that that there is a large number of transformations that can be expressed through these three.
He has recently stopped implementing all three transformations for monochrome images. To test this feature, he asked you to write a code that will consecutively perform three actions with a monochrome image: first it will rotate the image 90 degrees clockwise, then it will flip the image horizontally and finally, it will zoom in twice on the image (that is, it will double all the linear sizes).
Implement this feature to help Polycarp test his editor.
Input
The first line contains two integers, w and h (1 ≤ w, h ≤ 100) — the width and height of an image in pixels. The picture is given in h lines, each line contains w characters — each character encodes the color of the corresponding pixel of the image. The line consists only of characters "." and "*", as the image is monochrome.
Output
Print 2w lines, each containing 2h characters — the result of consecutive implementing of the three transformations, described above.
Examples
Input
3 2
.*.
.*.
Output
....
....
****
****
....
....
Input
9 20
**.......
****.....
******...
*******..
..******.
....****.
......***
*.....***
*********
*********
*********
*********
....**...
...****..
..******.
.********
****..***
***...***
**.....**
*.......*
Output
********......**********........********
********......**********........********
********........********......********..
********........********......********..
..********......********....********....
..********......********....********....
..********......********..********......
..********......********..********......
....********....****************........
....********....****************........
....********....****************........
....********....****************........
......******************..**********....
......******************..**********....
........****************....**********..
........****************....**********..
............************......**********
............************......**********
|
import java.io.*;
import java.util.*;
import java.lang.*;
import java.math.BigInteger;
import java.util.Map.Entry;
import java.util.logging.Level;
import java.util.logging.Logger;
public class Main
{
static StringTokenizer st=new StringTokenizer("");
static BufferedReader br;
///////////////////////////////////////////////////////////////////////////////////
public static void main(String args[]) throws FileNotFoundException, IOException, Exception
{
//Scanner in =new Scanner(new FileReader("input.txt"));
//PrintWriter out = new PrintWriter(new FileWriter("output.txt"));
//Scanner in=new Scanner(System.in);
br=new BufferedReader(new InputStreamReader(System.in));
PrintWriter out=new PrintWriter(System.out);
//StringTokenizer st;//=new StringTokenizer(br.readLine());
int w=ni();
int h=ni();
StringBuilder ans[]=new StringBuilder[2*w];
char mat[][]=new char[h][w];
for(int i=0;i<h;i++) mat[i]=br.readLine().toCharArray();
int i=0;
for(int j=0;j<w;j++)
{
ans[i]=new StringBuilder("");
ans[i+1]=new StringBuilder("");
for(int k=0;k<h;k++)
{
char ch=mat[k][j];
ans[i].append(ch);ans[i].append(ch);
ans[i+1].append(ch);ans[i+1].append(ch);
}
i+=2;
}
for( i=0;i<2*w;i++)
out.println(ans[i]);
out.close();
}
///////////////////////////////////////////////////////////////////////////////
private static class pair implements Comparable<pair>
{
int ind;
long first;
long second;
pair()
{
ind=0;
first=0;
second=0;
}
pair(int i,long f,long s)
{
ind =i;
first=f;
second=s;
}
public int compareTo(pair o)
{
if(first < o.first)
return 1;
else if(first > o.first)
return -1;
else
return 0;
}
}
public static Integer ni() throws Exception
{
if(!st.hasMoreTokens())
st=new StringTokenizer(br.readLine());
return Integer.parseInt(st.nextToken());
}
public static BigInteger nb()throws Exception
{
if(!st.hasMoreElements())
st=new StringTokenizer(br.readLine());
return BigInteger.valueOf(Long.parseLong(st.nextToken()));
}
public static Long nl() throws Exception
{
if(!st.hasMoreTokens())
st=new StringTokenizer(br.readLine());
return Long.parseLong(st.nextToken());
}
public static Double nd()throws Exception
{
if(!st.hasMoreElements())
st=new StringTokenizer(br.readLine());
return Double.parseDouble(st.nextToken());
}
public static String ns()throws Exception
{
if(!st.hasMoreElements())
st=new StringTokenizer(br.readLine());
return st.nextToken();
}
}
|
Do you like summer? Residents of Berland do. They especially love eating ice cream in the hot summer. So this summer day a large queue of n Berland residents lined up in front of the ice cream stall. We know that each of them has a certain amount of berland dollars with them. The residents of Berland are nice people, so each person agrees to swap places with the person right behind him for just 1 dollar. More formally, if person a stands just behind person b, then person a can pay person b 1 dollar, then a and b get swapped. Of course, if person a has zero dollars, he can not swap places with person b.
Residents of Berland are strange people. In particular, they get upset when there is someone with a strictly smaller sum of money in the line in front of them.
Can you help the residents of Berland form such order in the line so that they were all happy? A happy resident is the one who stands first in the line or the one in front of who another resident stands with not less number of dollars. Note that the people of Berland are people of honor and they agree to swap places only in the manner described above.
Input
The first line contains integer n (1 ≤ n ≤ 200 000) — the number of residents who stand in the line.
The second line contains n space-separated integers ai (0 ≤ ai ≤ 109), where ai is the number of Berland dollars of a man standing on the i-th position in the line. The positions are numbered starting from the end of the line.
Output
If it is impossible to make all the residents happy, print ":(" without the quotes. Otherwise, print in the single line n space-separated integers, the i-th of them must be equal to the number of money of the person on position i in the new line. If there are multiple answers, print any of them.
Examples
Input
2
11 8
Output
9 10
Input
5
10 9 7 10 6
Output
:(
Input
3
12 3 3
Output
4 4 10
Note
In the first sample two residents should swap places, after that the first resident has 10 dollars and he is at the head of the line and the second resident will have 9 coins and he will be at the end of the line.
In the second sample it is impossible to achieve the desired result.
In the third sample the first person can swap with the second one, then they will have the following numbers of dollars: 4 11 3, then the second person (in the new line) swaps with the third one, and the resulting numbers of dollars will equal to: 4 4 10. In this line everybody will be happy.
|
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
try (PrintWriter out = new PrintWriter(outputStream)) {
TaskG solver = new TaskG();
solver.solve(in, out);
}
}
}
class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream inputstream) {
reader = new BufferedReader(new InputStreamReader(inputstream));
tokenizer = null;
}
public String nextLine(){
String fullLine=null;
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
fullLine=reader.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
return fullLine;
}
return fullLine;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public long nextLong() {
return Long.parseLong(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
}
class TaskG {
void solve(InputReader in,PrintWriter out){
int n=in.nextInt();
int arr[]=new int[n];
for(int i=0;i<n;i++){
arr[i]=in.nextInt();
arr[i]+=i;
}
Arrays.sort(arr);
for(int i=0;i<n;i++){
arr[i]-=i;
}
for(int i=0;i<n-1;i++){
if(arr[i+1]<arr[i]){
out.println(":(");
return;
}
}
for(int x:arr){
out.print(x+" ");
}
}
}
|
Company "Robots industries" produces robots for territory protection. Robots protect triangle territories — right isosceles triangles with catheti parallel to North-South and East-West directions.
Owner of some land buys and sets robots on his territory to protect it. From time to time, businessmen want to build offices on that land and want to know how many robots will guard it. You are to handle these queries.
Input
The first line contains integer N — width and height of the land, and integer Q — number of queries to handle.
Next Q lines contain queries you need to process.
Two types of queries:
1. 1 dir x y len — add a robot to protect a triangle. Depending on the value of dir, the values of x, y and len represent a different triangle:
* dir = 1: Triangle is defined by the points (x, y), (x + len, y), (x, y + len)
* dir = 2: Triangle is defined by the points (x, y), (x + len, y), (x, y - len)
* dir = 3: Triangle is defined by the points (x, y), (x - len, y), (x, y + len)
* dir = 4: Triangle is defined by the points (x, y), (x - len, y), (x, y - len)
2. 2 x y — output how many robots guard this point (robot guards a point if the point is inside or on the border of its triangle)
* 1 ≤ N ≤ 5000
* 1 ≤ Q ≤ 105
* 1 ≤ dir ≤ 4
* All points of triangles are within range [1, N]
* All numbers are positive integers
Output
For each second type query output how many robots guard this point. Each answer should be in a separate line.
Examples
Input
17 10
1 1 3 2 4
1 3 10 3 7
1 2 6 8 2
1 3 9 4 2
2 4 4
1 4 15 10 6
2 7 7
2 9 4
2 12 2
2 13 8
Output
2
2
2
0
1
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void maximize(T &a, T b) {
if (b > a) a = b;
}
template <typename T>
inline void minimize(T &a, T b) {
if (b < a) a = b;
}
template <typename T>
inline void xReplace(T v, T &mx, T &sx) {
if (v > mx)
sx = mx, mx = v;
else if (v > sx)
sx = v;
}
template <typename T>
inline void nReplace(T v, T &mn, T &sn) {
if (v < mn)
sn = mn, mn = v;
else if (v < sn)
sn = v;
}
inline long long fr() {
long long ret = 0, sym = 1;
int c = 0;
while (!isdigit(c)) sym = c == '-' ? -1 : 1, c = getchar();
while (isdigit(c)) ret = ret * 10 + c - '0', c = getchar();
return ret * sym;
}
const int maxn = 5e3 + 5;
const int maxq = 1e5 + 5;
int n, Q, irc[114514];
int dt_d[maxq] = {}, dt_a[maxq] = {};
int dt_x[maxq], dt_y[maxq], dt_l[maxq];
int C[maxn * 2][maxn] = {};
inline void add(int x, int y, int v) {
for (int i = x; i < maxn * 2; i += ((i) & (-(i)))) {
for (int j = y; j < maxn; j += ((j) & (-(j)))) {
C[i][j] += v;
}
}
}
inline int getsum(int x, int y) {
int ret = 0;
for (int i = x; i; i -= ((i) & (-(i)))) {
for (int j = y; j; j -= ((j) & (-(j)))) {
ret += C[i][j];
}
}
return ret;
}
inline void rectadd(int x1, int Y1, int x2, int y2, int v) {
if (!x2 || !y2) return;
++x2, ++y2;
add(x2, y2, v);
add(x1, y2, -v);
add(x2, Y1, -v);
add(x1, Y1, v);
}
int main() {
n = fr(), Q = fr();
for (int i = 1; i <= (Q); ++i) {
irc[0] = fr();
if (irc[0] == 1) {
dt_d[i] = fr(), dt_x[i] = fr(), dt_y[i] = fr(), dt_l[i] = fr();
if (dt_d[i] == 1)
rectadd(dt_x[i] + dt_y[i], 1, dt_x[i] + dt_y[i] + dt_l[i], dt_x[i] - 1,
-1);
if (dt_d[i] == 4)
rectadd(dt_x[i] + dt_y[i] - dt_l[i], dt_x[i] + 1, dt_x[i] + dt_y[i], n,
-1);
} else {
dt_x[i] = fr(), dt_y[i] = fr();
dt_a[i] += getsum(dt_x[i] + dt_y[i], dt_x[i]);
}
}
memset(C, 0, sizeof(C));
for (int i = 1; i <= (Q); ++i) {
if (dt_d[i] == 1)
rectadd(dt_x[i] + dt_y[i], 1, dt_x[i] + dt_y[i] + dt_l[i], dt_y[i] - 1,
-1);
if (dt_d[i] == 4)
rectadd(dt_x[i] + dt_y[i] - dt_l[i], dt_y[i] + 1, dt_x[i] + dt_y[i], n,
-1);
if (dt_d[i] == 0) dt_a[i] += getsum(dt_x[i] + dt_y[i], dt_y[i]);
}
memset(C, 0, sizeof(C));
for (int i = 1; i <= (Q); ++i) {
if (dt_d[i] == 2)
rectadd(dt_y[i] - dt_x[i] - dt_l[i] + maxn, 1, dt_y[i] - dt_x[i] + maxn,
dt_x[i] - 1, -1);
if (dt_d[i] == 3)
rectadd(dt_y[i] - dt_x[i] + maxn, dt_x[i] + 1,
dt_y[i] - dt_x[i] + dt_l[i] + maxn, n, -1);
if (dt_d[i] == 0) dt_a[i] += getsum(dt_y[i] - dt_x[i] + maxn, dt_x[i]);
}
memset(C, 0, sizeof(C));
for (int i = 1; i <= (Q); ++i) {
if (dt_d[i] == 2)
rectadd(dt_y[i] - dt_x[i] - dt_l[i] + maxn, dt_y[i] + 1,
dt_y[i] - dt_x[i] + maxn, n, -1);
if (dt_d[i] == 3)
rectadd(dt_y[i] - dt_x[i] + maxn, 1, dt_y[i] - dt_x[i] + dt_l[i] + maxn,
dt_y[i] - 1, -1);
if (dt_d[i] == 0) dt_a[i] += getsum(dt_y[i] - dt_x[i] + maxn, dt_y[i]);
}
memset(C, 0, sizeof(C));
for (int i = 1; i <= (Q); ++i) {
if (dt_d[i] == 1)
rectadd(dt_x[i] + dt_y[i], 1, dt_x[i] + dt_y[i] + dt_l[i], 1, 1);
if (dt_d[i] == 2)
rectadd(dt_y[i] - dt_x[i] - dt_l[i] + maxn, 2, dt_y[i] - dt_x[i] + maxn,
2, 1);
if (dt_d[i] == 3)
rectadd(dt_y[i] - dt_x[i] + maxn, 2, dt_y[i] - dt_x[i] + dt_l[i] + maxn,
2, 1);
if (dt_d[i] == 4)
rectadd(dt_x[i] + dt_y[i] - dt_l[i], 1, dt_x[i] + dt_y[i], 1, 1);
if (dt_d[i] == 0)
dt_a[i] +=
getsum(dt_x[i] + dt_y[i], 1) + getsum(dt_y[i] - dt_x[i] + maxn, 2),
printf("%d\n", dt_a[i]);
}
return 0;
}
|
Igor is in the museum and he wants to see as many pictures as possible.
Museum can be represented as a rectangular field of n × m cells. Each cell is either empty or impassable. Empty cells are marked with '.', impassable cells are marked with '*'. Every two adjacent cells of different types (one empty and one impassable) are divided by a wall containing one picture.
At the beginning Igor is in some empty cell. At every moment he can move to any empty cell that share a side with the current one.
For several starting positions you should calculate the maximum number of pictures that Igor can see. Igor is able to see the picture only if he is in the cell adjacent to the wall with this picture. Igor have a lot of time, so he will examine every picture he can see.
Input
First line of the input contains three integers n, m and k (3 ≤ n, m ≤ 1000, 1 ≤ k ≤ min(n·m, 100 000)) — the museum dimensions and the number of starting positions to process.
Each of the next n lines contains m symbols '.', '*' — the description of the museum. It is guaranteed that all border cells are impassable, so Igor can't go out from the museum.
Each of the last k lines contains two integers x and y (1 ≤ x ≤ n, 1 ≤ y ≤ m) — the row and the column of one of Igor's starting positions respectively. Rows are numbered from top to bottom, columns — from left to right. It is guaranteed that all starting positions are empty cells.
Output
Print k integers — the maximum number of pictures, that Igor can see if he starts in corresponding position.
Examples
Input
5 6 3
******
*..*.*
******
*....*
******
2 2
2 5
4 3
Output
6
4
10
Input
4 4 1
****
*..*
*.**
****
3 2
Output
8
|
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class cf598d {
public static void main(String[] args) throws IOException {
int n = rni(), m = ni(), k = ni(), ans[][] = new int[n][m];
boolean map[][] = new boolean[n][m], visited[][] = new boolean[n][m];
for (int i = 0; i < n; ++i) {
char[] row = rcha();
for (int j = 0; j < m; ++j) {
map[i][j] = row[j] == '*';
}
}
for (int i = 1; i < n - 1; ++i) {
for (int j = 1; j < m - 1; ++j) {
if (!map[i][j] && !visited[i][j]) {
fill(i, j, solve(i, j, map, visited), map, ans);
}
}
}
while (k --> 0) {
int x = rni() - 1, y = ni() - 1;
prln(ans[x][y]);
}
close();
}
static int dx[] = {0, 1, 0, -1}, dy[] = {-1, 0, 1, 0};
static int solve(int i, int j, boolean[][] map, boolean[][] visited) {
int ans = 0;
Queue<int[]> bfs = new LinkedList<>();
bfs.offer(new int[] {i ,j});
visited[i][j] = true;
while (!bfs.isEmpty()) {
int pos[] = bfs.poll(), x = pos[0], y = pos[1];
for (int k = 0; k < 4; ++k) {
int nx = x + dx[k], ny = y + dy[k];
if (map[nx][ny]) {
++ans;
} else if (!visited[nx][ny]) {
visited[nx][ny] = true;
bfs.offer(new int[] {nx, ny});
}
}
}
return ans;
}
static void fill(int i, int j, int val, boolean[][] map, int[][] ans) {
Queue<int[]> bfs = new LinkedList<>();
bfs.offer(new int[] {i, j});
ans[i][j] = val;
while (!bfs.isEmpty()) {
int pos[] = bfs.poll(), x = pos[0], y = pos[1];
for (int k = 0; k < 4; ++k) {
int nx = x + dx[k], ny = y + dy[k];
if (!map[nx][ny] && ans[nx][ny] == 0) {
ans[nx][ny] = val;
bfs.offer(new int[] {nx, ny});
}
}
}
}
/* static boolean oob(int i, int j, int n, int m) {
return i < 0 || i >= n || j < 0 || j >= m;
} */
// stack overflow
/* static int solve(int i, int j, boolean[][] map, boolean[][] visited, int n, int m) {
int ans = 0;
visited[i][j] = true;
for (int k = 0; k < 4; ++k) {
int ni = i + dx[k], nj = j + dy[k];
if (!oob(ni, nj, n, m)) {
if (map[ni][nj]) {
++ans;
} else if (!visited[ni][nj]) {
ans += solve(ni, nj, map, visited, n, m);
}
}
}
return ans;
} */
/* static void fill(int i, int j, int x, boolean[][] map, int[][] ans, int n, int m) {
ans[i][j] = x;
for (int k = 0; k < 4; ++k) {
int ni = i + dx[k], nj = j + dy[k];
if (!oob(ni, nj, n, m) && !map[ni][nj] && ans[ni][nj] == 0) {
fill(ni, nj, x, map, ans, n, m);
}
}
} */
static BufferedReader __in = new BufferedReader(new InputStreamReader(System.in));
static PrintWriter __out = new PrintWriter(new OutputStreamWriter(System.out));
static StringTokenizer input;
static Random __rand = new Random();
// references
// IBIG = 1e9 + 7
// IMAX ~= 2e9
// LMAX ~= 9e18
// constants
static final int IBIG = 1000000007;
static final int IMAX = 2147483647;
static final int IMIN = -2147483648;
static final long LMAX = 9223372036854775807L;
static final long LMIN = -9223372036854775808L;
// math util
static int minof(int a, int b, int c) {return min(a, min(b, c));}
static int minof(int... x) {if (x.length == 1) return x[0]; if (x.length == 2) return min(x[0], x[1]); if (x.length == 3) return min(x[0], min(x[1], x[2])); int min = x[0]; for (int i = 1; i < x.length; ++i) if (x[i] < min) min = x[i]; return min;}
static long minof(long a, long b, long c) {return min(a, min(b, c));}
static long minof(long... x) {if (x.length == 1) return x[0]; if (x.length == 2) return min(x[0], x[1]); if (x.length == 3) return min(x[0], min(x[1], x[2])); long min = x[0]; for (int i = 1; i < x.length; ++i) if (x[i] < min) min = x[i]; return min;}
static int maxof(int a, int b, int c) {return max(a, max(b, c));}
static int maxof(int... x) {if (x.length == 1) return x[0]; if (x.length == 2) return max(x[0], x[1]); if (x.length == 3) return max(x[0], max(x[1], x[2])); int max = x[0]; for (int i = 1; i < x.length; ++i) if (x[i] > max) max = x[i]; return max;}
static long maxof(long a, long b, long c) {return max(a, max(b, c));}
static long maxof(long... x) {if (x.length == 1) return x[0]; if (x.length == 2) return max(x[0], x[1]); if (x.length == 3) return max(x[0], max(x[1], x[2])); long max = x[0]; for (int i = 1; i < x.length; ++i) if (x[i] > max) max = x[i]; return max;}
static int powi(int a, int b) {if (a == 0) return 0; int ans = 1; while (b > 0) {if ((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
static long powl(long a, int b) {if (a == 0) return 0; long ans = 1; while (b > 0) {if ((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
static int fli(double d) {return (int) d;}
static int cei(double d) {return (int) ceil(d);}
static long fll(double d) {return (long) d;}
static long cel(double d) {return (long) ceil(d);}
static int gcf(int a, int b) {return b == 0 ? a : gcf(b, a % b);}
static long gcf(long a, long b) {return b == 0 ? a : gcf(b, a % b);}
static int lcm(int a, int b) {return a * b / gcf(a, b);}
static long lcm(long a, long b) {return a * b / gcf(a, b);}
static int randInt(int min, int max) {return __rand.nextInt(max - min + 1) + min;}
static long mix(long x) {x += 0x9e3779b97f4a7c15L; x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9L; x = (x ^ (x >> 27)) * 0x94d049bb133111ebL; return x ^ (x >> 31);}
// array util
static void reverse(int[] a) {for (int i = 0, n = a.length, half = n / 2; i < half; ++i) {int swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
static void reverse(long[] a) {for (int i = 0, n = a.length, half = n / 2; i < half; ++i) {long swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
static void reverse(double[] a) {for (int i = 0, n = a.length, half = n / 2; i < half; ++i) {double swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
static void reverse(char[] a) {for (int i = 0, n = a.length, half = n / 2; i < half; ++i) {char swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
static void shuffle(int[] a) {int n = a.length - 1; for (int i = 0; i < n; ++i) {int ind = randInt(i, n); int swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
static void shuffle(long[] a) {int n = a.length - 1; for (int i = 0; i < n; ++i) {int ind = randInt(i, n); long swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
static void shuffle(double[] a) {int n = a.length - 1; for (int i = 0; i < n; ++i) {int ind = randInt(i, n); double swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
static void rsort(int[] a) {shuffle(a); sort(a);}
static void rsort(long[] a) {shuffle(a); sort(a);}
static void rsort(double[] a) {shuffle(a); sort(a);}
static int[] copy(int[] a) {int[] ans = new int[a.length]; for (int i = 0; i < a.length; ++i) ans[i] = a[i]; return ans;}
static long[] copy(long[] a) {long[] ans = new long[a.length]; for (int i = 0; i < a.length; ++i) ans[i] = a[i]; return ans;}
static double[] copy(double[] a) {double[] ans = new double[a.length]; for (int i = 0; i < a.length; ++i) ans[i] = a[i]; return ans;}
static char[] copy(char[] a) {char[] ans = new char[a.length]; for (int i = 0; i < a.length; ++i) ans[i] = a[i]; return ans;}
// input
static void r() throws IOException {input = new StringTokenizer(rline());}
static int ri() throws IOException {return Integer.parseInt(rline());}
static long rl() throws IOException {return Long.parseLong(rline());}
static double rd() throws IOException {return Double.parseDouble(rline());}
static int[] ria(int n) throws IOException {int[] a = new int[n]; r(); for (int i = 0; i < n; ++i) a[i] = ni(); return a;}
static int[] riam1(int n) throws IOException {int[] a = new int[n]; r(); for (int i = 0; i < n; ++i) a[i] = ni() - 1; return a;}
static long[] rla(int n) throws IOException {long[] a = new long[n]; r(); for (int i = 0; i < n; ++i) a[i] = nl(); return a;}
static double[] rda(int n) throws IOException {double[] a = new double[n]; r(); for (int i = 0; i < n; ++i) a[i] = nd(); return a;}
static char[] rcha() throws IOException {return rline().toCharArray();}
static String rline() throws IOException {return __in.readLine();}
static String n() {return input.nextToken();}
static int rni() throws IOException {r(); return ni();}
static int ni() {return Integer.parseInt(n());}
static long rnl() throws IOException {r(); return nl();}
static long nl() {return Long.parseLong(n());}
static double rnd() throws IOException {r(); return nd();}
static double nd() {return Double.parseDouble(n());}
// output
static void pr(int i) {__out.print(i);}
static void prln(int i) {__out.println(i);}
static void pr(long l) {__out.print(l);}
static void prln(long l) {__out.println(l);}
static void pr(double d) {__out.print(d);}
static void prln(double d) {__out.println(d);}
static void pr(char c) {__out.print(c);}
static void prln(char c) {__out.println(c);}
static void pr(char[] s) {__out.print(new String(s));}
static void prln(char[] s) {__out.println(new String(s));}
static void pr(String s) {__out.print(s);}
static void prln(String s) {__out.println(s);}
static void pr(Object o) {__out.print(o);}
static void prln(Object o) {__out.println(o);}
static void prln() {__out.println();}
static void pryes() {prln("yes");}
static void pry() {prln("Yes");}
static void prY() {prln("YES");}
static void prno() {prln("no");}
static void prn() {prln("No");}
static void prN() {prln("NO");}
static boolean pryesno(boolean b) {prln(b ? "yes" : "no"); return b;};
static boolean pryn(boolean b) {prln(b ? "Yes" : "No"); return b;}
static boolean prYN(boolean b) {prln(b ? "YES" : "NO"); return b;}
static void prln(int... a) {for (int i = 0, len = a.length - 1; i < len; pr(a[i]), pr(' '), ++i); if (a.length > 0) prln(a[a.length - 1]); else prln();}
static void prln(long... a) {for (int i = 0, len = a.length - 1; i < len; pr(a[i]), pr(' '), ++i); if (a.length > 0) prln(a[a.length - 1]); else prln();}
static void prln(double... a) {for (int i = 0, len = a.length - 1; i < len; pr(a[i]), pr(' '), ++i); if (a.length > 0) prln(a[a.length - 1]); else prln();}
static <T> void prln(Collection<T> c) {int n = c.size() - 1; Iterator<T> iter = c.iterator(); for (int i = 0; i < n; pr(iter.next()), pr(' '), ++i); if (n >= 0) prln(iter.next()); else prln();}
static void h() {prln("hlfd"); flush();}
static void flush() {__out.flush();}
static void close() {__out.close();}
}
|
After the contest in comparing numbers, Shapur's teacher found out that he is a real genius and that no one could possibly do the calculations faster than him even using a super computer!
Some days before the contest, the teacher took a very simple-looking exam and all his n students took part in the exam. The teacher gave them 3 strings and asked them to concatenate them. Concatenating strings means to put them in some arbitrary order one after the other. For example from concatenating Alireza and Amir we can get to AlirezaAmir or AmirAlireza depending on the order of concatenation.
Unfortunately enough, the teacher forgot to ask students to concatenate their strings in a pre-defined order so each student did it the way he/she liked.
Now the teacher knows that Shapur is such a fast-calculating genius boy and asks him to correct the students' papers.
Shapur is not good at doing such a time-taking task. He rather likes to finish up with it as soon as possible and take his time to solve 3-SAT in polynomial time. Moreover, the teacher has given some advice that Shapur has to follow. Here's what the teacher said:
* As I expect you know, the strings I gave to my students (including you) contained only lowercase and uppercase Persian Mikhi-Script letters. These letters are too much like Latin letters, so to make your task much harder I converted all the initial strings and all of the students' answers to Latin.
* As latin alphabet has much less characters than Mikhi-Script, I added three odd-looking characters to the answers, these include "-", ";" and "_". These characters are my own invention of course! And I call them Signs.
* The length of all initial strings was less than or equal to 100 and the lengths of my students' answers are less than or equal to 600
* My son, not all students are genius as you are. It is quite possible that they make minor mistakes changing case of some characters. For example they may write ALiReZaAmIR instead of AlirezaAmir. Don't be picky and ignore these mistakes.
* Those signs which I previously talked to you about are not important. You can ignore them, since many students are in the mood for adding extra signs or forgetting about a sign. So something like Iran;;-- is the same as --;IRAN
* You should indicate for any of my students if his answer was right or wrong. Do this by writing "WA" for Wrong answer or "ACC" for a correct answer.
* I should remind you that none of the strings (initial strings or answers) are empty.
* Finally, do these as soon as possible. You have less than 2 hours to complete this.
Input
The first three lines contain a string each. These are the initial strings. They consists only of lowercase and uppercase Latin letters and signs ("-", ";" and "_"). All the initial strings have length from 1 to 100, inclusively.
In the fourth line there is a single integer n (0 ≤ n ≤ 1000), the number of students.
Next n lines contain a student's answer each. It is guaranteed that the answer meets what the teacher said. Each answer iconsists only of lowercase and uppercase Latin letters and signs ("-", ";" and "_"). Length is from 1 to 600, inclusively.
Output
For each student write in a different line. Print "WA" if his answer is wrong or "ACC" if his answer is OK.
Examples
Input
Iran_
Persian;
W_o;n;d;e;r;f;u;l;
7
WonderfulPersianIran
wonderful_PersIAN_IRAN;;_
WONDERFUL___IRAN__PERSIAN__;;
Ira__Persiann__Wonderful
Wonder;;fulPersian___;I;r;a;n;
__________IranPersianWonderful__________
PersianIran_is_Wonderful
Output
ACC
ACC
ACC
WA
ACC
ACC
WA
Input
Shapur;;
is___
a_genius
3
Shapur__a_is___geniUs
is___shapur___a__Genius;
Shapur;;is;;a;;geni;;us;;
Output
WA
ACC
ACC
|
import itertools
def remove_signs(s: str, signs: list) -> str:
for i in range(len(signs)):
s = s.replace(signs[i], '')
return s
def get_permulation_of_strings(s1, s2, s3):
return list(map("".join, itertools.permutations([s1, s2, s3])))
def main():
signs = [';', '_', '-']
str1 = remove_signs(input(), signs).lower()
str2 = remove_signs(input(), signs).lower()
str3 = remove_signs(input(), signs).lower()
n = int(input())
strPermulation = get_permulation_of_strings(str1, str2, str3)
for i in range(n):
isTrue = False
concatStr = remove_signs(input(), signs).lower()
for i in range(len(strPermulation)) :
if strPermulation[i] == concatStr:
isTrue = True
break
if (isTrue == True):
print('ACC')
else:
print('WA')
if __name__ == "__main__":
main()
|
The ship crashed into a reef and is sinking. Now the entire crew must be evacuated. All n crew members have already lined up in a row (for convenience let's label them all from left to right with positive integers from 1 to n) and await further instructions. However, one should evacuate the crew properly, in a strict order. Specifically:
The first crew members to leave the ship are rats. Then women and children (both groups have the same priority) leave the ship. After that all men are evacuated from the ship. The captain leaves the sinking ship last.
If we cannot determine exactly who should leave the ship first for any two members of the crew by the rules from the previous paragraph, then the one who stands to the left in the line leaves the ship first (or in other words, the one whose number in the line is less).
For each crew member we know his status as a crew member, and also his name. All crew members have different names. Determine the order in which to evacuate the crew.
Input
The first line contains an integer n, which is the number of people in the crew (1 ≤ n ≤ 100). Then follow n lines. The i-th of those lines contains two words — the name of the crew member who is i-th in line, and his status on the ship. The words are separated by exactly one space. There are no other spaces in the line. The names consist of Latin letters, the first letter is uppercase, the rest are lowercase. The length of any name is from 1 to 10 characters. The status can have the following values: rat for a rat, woman for a woman, child for a child, man for a man, captain for the captain. The crew contains exactly one captain.
Output
Print n lines. The i-th of them should contain the name of the crew member who must be the i-th one to leave the ship.
Examples
Input
6
Jack captain
Alice woman
Charlie man
Teddy rat
Bob child
Julia woman
Output
Teddy
Alice
Bob
Julia
Charlie
Jack
|
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
Person[] arr = new Person[n];
String type = "";
for (int i = 0; i < n; i++) {
arr[i] = new Person();
arr[i].name = input.next();
type = input.next();
if (type.equals("rat")) {
arr[i].type = "a";
} else if (type.equals("woman") || type.equals("child")) {
arr[i].type = "b";
} else if (type.equals("man")) {
arr[i].type = "c";
} else if (type.equals("captain")) {
arr[i].type = "d";
}
}
Arrays.sort(arr);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i].name);
}
}
}
class Person implements Comparable<Person>{
public String name;
public String type;
@Override
public int compareTo(Person t) {
return type.compareTo( t.type);
}
}
|
A famous sculptor Cicasso goes to a world tour!
Well, it is not actually a world-wide. But not everyone should have the opportunity to see works of sculptor, shouldn't he? Otherwise there will be no any exclusivity. So Cicasso will entirely hold the world tour in his native country — Berland.
Cicasso is very devoted to his work and he wants to be distracted as little as possible. Therefore he will visit only four cities. These cities will be different, so no one could think that he has "favourites". Of course, to save money, he will chose the shortest paths between these cities. But as you have probably guessed, Cicasso is a weird person. Although he doesn't like to organize exhibitions, he likes to travel around the country and enjoy its scenery. So he wants the total distance which he will travel to be as large as possible. However, the sculptor is bad in planning, so he asks you for help.
There are n cities and m one-way roads in Berland. You have to choose four different cities, which Cicasso will visit and also determine the order in which he will visit them. So that the total distance he will travel, if he visits cities in your order, starting from the first city in your list, and ending in the last, choosing each time the shortest route between a pair of cities — will be the largest.
Note that intermediate routes may pass through the cities, which are assigned to the tour, as well as pass twice through the same city. For example, the tour can look like that: <image>. Four cities in the order of visiting marked as overlines: [1, 5, 2, 4].
Note that Berland is a high-tech country. So using nanotechnologies all roads were altered so that they have the same length. For the same reason moving using regular cars is not very popular in the country, and it can happen that there are such pairs of cities, one of which generally can not be reached by car from the other one. However, Cicasso is very conservative and cannot travel without the car. Choose cities so that the sculptor can make the tour using only the automobile. It is guaranteed that it is always possible to do.
Input
In the first line there is a pair of integers n and m (4 ≤ n ≤ 3000, 3 ≤ m ≤ 5000) — a number of cities and one-way roads in Berland.
Each of the next m lines contains a pair of integers ui, vi (1 ≤ ui, vi ≤ n) — a one-way road from the city ui to the city vi. Note that ui and vi are not required to be distinct. Moreover, it can be several one-way roads between the same pair of cities.
Output
Print four integers — numbers of cities which Cicasso will visit according to optimal choice of the route. Numbers of cities should be printed in the order that Cicasso will visit them. If there are multiple solutions, print any of them.
Example
Input
8 9
1 2
2 3
3 4
4 1
4 5
5 6
6 7
7 8
8 5
Output
2 1 8 7
Note
Let d(x, y) be the shortest distance between cities x and y. Then in the example d(2, 1) = 3, d(1, 8) = 7, d(8, 7) = 3. The total distance equals 13.
|
#include <bits/stdc++.h>
using namespace std;
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << '\n';
err(++it, args...);
}
static constexpr int inf = std::numeric_limits<int>::max() / 4;
const int M = 3010;
struct data {
int u, c;
data(int a, int b) {
u = a;
c = b;
}
bool operator<(const data& d) const {
if (c == d.c)
return u < d.u;
else
return c < d.c;
}
};
vector<int> A[M], T[M];
set<data> F[M], R[M];
int dist[M][M], rev[M][M];
void bfs(int p) {
int visited[M], u, v, i;
memset((visited), (false), sizeof(visited));
queue<int> q;
q.push(p);
dist[p][p] = 0;
visited[p] = true;
while (!q.empty()) {
u = q.front();
q.pop();
for (i = 0; i < A[u].size(); i++) {
v = A[u][i];
if (!visited[v]) {
visited[v] = true;
dist[p][v] = dist[p][u] + 1;
q.push(v);
}
}
}
}
void bfs_rev(int p) {
int visited[M], u, v, i;
memset((visited), (false), sizeof(visited));
queue<int> q;
q.push(p);
rev[p][p] = 0;
visited[p] = true;
while (!q.empty()) {
u = q.front();
q.pop();
for (i = 0; i < T[u].size(); i++) {
v = T[u][i];
if (!visited[v]) {
visited[v] = true;
rev[p][v] = rev[p][u] + 1;
q.push(v);
}
}
}
}
int main() {
int i, j, k, l, n, m, u, v;
set<data>::iterator it, x, y;
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d%d", &u, &v);
A[u].push_back(v);
T[v].push_back(u);
}
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) dist[i][j] = -inf, rev[i][j] = -inf;
for (i = 1; i <= n; i++) bfs(i);
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (F[i].size() < 4)
F[i].insert(data(j, dist[i][j]));
else {
it = F[i].begin();
if (dist[i][j] > it->c) {
F[i].erase(it);
F[i].insert(data(j, dist[i][j]));
}
}
}
}
for (i = 1; i <= n; i++) bfs_rev(i);
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (R[i].size() < 4)
R[i].insert(data(j, rev[i][j]));
else {
it = R[i].begin();
if (rev[i][j] > it->c) {
R[i].erase(it);
R[i].insert(data(j, rev[i][j]));
}
}
}
}
int maxx = 0, a, b, c, d;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (i == j) continue;
for (__typeof((R[i]).begin()) x = (R[i]).begin(); x != (R[i]).end();
x++) {
for (__typeof((F[j]).begin()) y = (F[j]).begin(); y != (F[j]).end();
y++) {
k = x->u;
l = y->u;
if (k == l || i == k || i == l || j == k || j == l) continue;
if (dist[k][i] + dist[i][j] + dist[j][l] > maxx) {
maxx = dist[k][i] + dist[i][j] + dist[j][l];
a = k;
b = i;
c = j;
d = l;
}
}
}
}
}
printf("%d %d %d %d\n", a, b, c, d);
return 0;
}
|
Further research on zombie thought processes yielded interesting results. As we know from the previous problem, the nervous system of a zombie consists of n brains and m brain connectors joining some pairs of brains together. It was observed that the intellectual abilities of a zombie depend mainly on the topology of its nervous system. More precisely, we define the distance between two brains u and v (1 ≤ u, v ≤ n) as the minimum number of brain connectors used when transmitting a thought between these two brains. The brain latency of a zombie is defined to be the maximum distance between any two of its brains. Researchers conjecture that the brain latency is the crucial parameter which determines how smart a given zombie is. Help them test this conjecture by writing a program to compute brain latencies of nervous systems.
In this problem you may assume that any nervous system given in the input is valid, i.e., it satisfies conditions (1) and (2) from the easy version.
Input
The first line of the input contains two space-separated integers n and m (1 ≤ n, m ≤ 100000) denoting the number of brains (which are conveniently numbered from 1 to n) and the number of brain connectors in the nervous system, respectively. In the next m lines, descriptions of brain connectors follow. Every connector is given as a pair of brains a b it connects (1 ≤ a, b ≤ n and a ≠ b).
Output
Print one number – the brain latency.
Examples
Input
4 3
1 2
1 3
1 4
Output
2
Input
5 4
1 2
2 3
3 4
3 5
Output
3
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = (int)1E5 + 10;
int n, m;
vector<int> e[MAX];
int d[MAX];
void dfs(int u, int p) {
for (auto v : e[u])
if (v != p) {
d[v] = d[u] + 1;
dfs(v, u);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
e[x].push_back(y);
e[y].push_back(x);
}
d[0] = 0;
dfs(0, -1);
int mv = 0;
for (int i = 1; i < n; i++)
if (d[i] > d[mv]) mv = i;
d[mv] = 0;
dfs(mv, -1);
int res = 0;
for (int i = 0; i < n; i++) res = max(res, d[i]);
printf("%d", res);
}
|
Today an outstanding event is going to happen in the forest — hedgehog Filya will come to his old fried Sonya!
Sonya is an owl and she sleeps during the day and stay awake from minute l1 to minute r1 inclusive. Also, during the minute k she prinks and is unavailable for Filya.
Filya works a lot and he plans to visit Sonya from minute l2 to minute r2 inclusive.
Calculate the number of minutes they will be able to spend together.
Input
The only line of the input contains integers l1, r1, l2, r2 and k (1 ≤ l1, r1, l2, r2, k ≤ 1018, l1 ≤ r1, l2 ≤ r2), providing the segments of time for Sonya and Filya and the moment of time when Sonya prinks.
Output
Print one integer — the number of minutes Sonya and Filya will be able to spend together.
Examples
Input
1 10 9 20 1
Output
2
Input
1 100 50 200 75
Output
50
Note
In the first sample, they will be together during minutes 9 and 10.
In the second sample, they will be together from minute 50 to minute 74 and from minute 76 to minute 100.
|
l1,r1,l2,r2,k=map(int,input().split())
ma=max(l1,l2)
mi=min(r1,r2)
if k<=mi and k>=ma:
print(max(0,mi-ma))
else:
print(max(0,mi-ma+1))
|
Anton likes to play chess. Also, he likes to do programming. That is why he decided to write the program that plays chess. However, he finds the game on 8 to 8 board to too simple, he uses an infinite one instead.
The first task he faced is to check whether the king is in check. Anton doesn't know how to implement this so he asks you to help.
Consider that an infinite chess board contains one white king and the number of black pieces. There are only rooks, bishops and queens, as the other pieces are not supported yet. The white king is said to be in check if at least one black piece can reach the cell with the king in one move.
Help Anton and write the program that for the given position determines whether the white king is in check.
Remainder, on how do chess pieces move:
* Bishop moves any number of cells diagonally, but it can't "leap" over the occupied cells.
* Rook moves any number of cells horizontally or vertically, but it also can't "leap" over the occupied cells.
* Queen is able to move any number of cells horizontally, vertically or diagonally, but it also can't "leap".
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 500 000) — the number of black pieces.
The second line contains two integers x0 and y0 ( - 109 ≤ x0, y0 ≤ 109) — coordinates of the white king.
Then follow n lines, each of them contains a character and two integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — type of the i-th piece and its position. Character 'B' stands for the bishop, 'R' for the rook and 'Q' for the queen. It's guaranteed that no two pieces occupy the same position.
Output
The only line of the output should contains "YES" (without quotes) if the white king is in check and "NO" (without quotes) otherwise.
Examples
Input
2
4 2
R 1 1
B 1 5
Output
YES
Input
2
4 2
R 3 3
B 1 5
Output
NO
Note
Picture for the first sample:
<image> White king is in check, because the black bishop can reach the cell with the white king in one move. The answer is "YES".
Picture for the second sample:
<image> Here bishop can't reach the cell with the white king, because his path is blocked by the rook, and the bishop cant "leap" over it. Rook can't reach the white king, because it can't move diagonally. Hence, the king is not in check and the answer is "NO".
|
#include <bits/stdc++.h>
using namespace std;
char p[500005];
long long int px[500005], py[500005];
int main() {
long long int x, y;
int n;
scanf("%d", &n);
scanf("%lld %lld", &x, &y);
for (int i = 0; i < n; i++) cin >> p[i] >> px[i] >> py[i];
int flag = 0;
char pp;
pp = 'X';
long long int dist, md = 2000000000000;
for (int i = 0; i < n; i++) {
if (py[i] > y && px[i] == x) {
dist = py[i] - y;
if (dist < md) {
md = dist;
pp = p[i];
}
}
}
if (pp == 'Q' || pp == 'R') {
printf("YES\n");
exit(0);
}
pp = 'X';
md = 20000000000000;
for (int i = 0; i < n; i++) {
if (py[i] == y && px[i] > x) {
dist = px[i] - x;
if (dist < md) {
md = dist;
pp = p[i];
}
}
}
if (pp == 'Q' || pp == 'R') {
printf("YES\n");
exit(0);
}
pp = 'X';
md = 20000000000000;
for (int i = 0; i < n; i++) {
if (py[i] == y && px[i] < x) {
dist = x - px[i];
if (dist < md) {
md = dist;
pp = p[i];
}
}
}
if (pp == 'Q' || pp == 'R') {
printf("YES\n");
exit(0);
}
pp = 'X';
md = 20000000000000;
for (int i = 0; i < n; i++) {
if (px[i] == x && py[i] < y) {
dist = y - py[i];
if (dist < md) {
md = dist;
pp = p[i];
}
}
}
if (pp == 'Q' || pp == 'R') {
printf("YES\n");
exit(0);
}
pp = 'X';
md = 20000000000000;
for (int i = 0; i < n; i++) {
if (py[i] > y && px[i] > x && (py[i] - y) == (px[i] - x)) {
dist = (px[i] - x);
if (dist < md) {
md = dist;
pp = p[i];
}
}
}
if (pp == 'B' || pp == 'Q') {
printf("YES\n");
exit(0);
}
pp = 'X';
md = 20000000000000;
for (int i = 0; i < n; i++) {
if (py[i] < y && px[i] < x && (py[i] - y) == (px[i] - x)) {
dist = (x - px[i]);
if (dist < md) {
md = dist;
pp = p[i];
}
}
}
if (pp == 'B' || pp == 'Q') {
printf("YES\n");
exit(0);
}
pp = 'X';
md = 20000000000000;
for (int i = 0; i < n; i++) {
if (py[i] < y && px[i] > x && (py[i] - y) == -1 * (px[i] - x)) {
dist = (px[i] - x);
if (dist < md) {
md = dist;
pp = p[i];
}
}
}
if (pp == 'B' || pp == 'Q') {
printf("YES\n");
exit(0);
}
pp = 'X';
md = 20000000000000;
for (int i = 0; i < n; i++) {
if (py[i] > y && px[i] < x && (py[i] - y) == -1 * (px[i] - x)) {
dist = (py[i] - y);
if (dist < md) {
md = dist;
pp = p[i];
}
}
}
if (pp == 'B' || pp == 'Q') {
printf("YES\n");
exit(0);
}
printf("NO\n");
return 0;
}
|
Alexander is learning how to convert numbers from the decimal system to any other, however, he doesn't know English letters, so he writes any number only as a decimal number, it means that instead of the letter A he will write the number 10. Thus, by converting the number 475 from decimal to hexadecimal system, he gets 11311 (475 = 1·162 + 13·161 + 11·160). Alexander lived calmly until he tried to convert the number back to the decimal number system.
Alexander remembers that he worked with little numbers so he asks to find the minimum decimal number so that by converting it to the system with the base n he will get the number k.
Input
The first line contains the integer n (2 ≤ n ≤ 109). The second line contains the integer k (0 ≤ k < 1060), it is guaranteed that the number k contains no more than 60 symbols. All digits in the second line are strictly less than n.
Alexander guarantees that the answer exists and does not exceed 1018.
The number k doesn't contain leading zeros.
Output
Print the number x (0 ≤ x ≤ 1018) — the answer to the problem.
Examples
Input
13
12
Output
12
Input
16
11311
Output
475
Input
20
999
Output
3789
Input
17
2016
Output
594
Note
In the first example 12 could be obtained by converting two numbers to the system with base 13: 12 = 12·130 or 15 = 1·131 + 2·130.
|
n = input()
k = input()
digit = len(n)
lst = []
def recul(k):
if len(k)== 0:
return
if k[-digit:] < n:
lst.append(k[-digit:])
if k[-digit:][0:1] == '0' and len(k[-digit:]) != 1:
recul(k[:-digit]+'0')
else:
recul(k[:-digit])
else:
temp = -digit+1
while k[temp:temp+1]== '0' and temp<0:
temp += 1
if temp == 0:
lst.append('0')
recul(k[:-1])
return
lst.append(k[temp:])
recul(k[:temp])
if digit == 1:
print(int(k,int(n)))
exit()
recul(k)
ans = 0
for x in range(len(lst)):
ans += int(lst[x])*int(n)**x
print(ans)
|
For some reason in many American cartoons anvils fall from time to time onto heroes' heads. Of course, safes, wardrobes, cruisers, planes fall sometimes too... But anvils do so most of all.
Anvils come in different sizes and shapes. Quite often they get the hero stuck deep in the ground. But have you ever thought who throws anvils from the sky? From what height? We are sure that such questions have never troubled you!
It turns out that throwing an anvil properly is not an easy task at all. Let's describe one of the most popular anvil throwing models.
Let the height p of the potential victim vary in the range [0;a] and the direction of the wind q vary in the range [ - b;b]. p and q could be any real (floating) numbers. Then we can assume that the anvil will fit the toon's head perfectly only if the following equation has at least one real root:
<image>
Determine the probability with which an aim can be successfully hit by an anvil.
You can assume that the p and q coefficients are chosen equiprobably and independently in their ranges.
Input
The first line contains integer t (1 ≤ t ≤ 10000) — amount of testcases.
Each of the following t lines contain two space-separated integers a and b (0 ≤ a, b ≤ 106).
Pretests contain all the tests with 0 < a < 10, 0 ≤ b < 10.
Output
Print t lines — the probability of a successful anvil hit for each testcase. The absolute or relative error of the answer should not exceed 10 - 6.
Examples
Input
2
4 2
1 2
Output
0.6250000000
0.5312500000
|
import java.util.*;
public class MainC {
public static void main(String[]args){
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
ArrayList<Double>pr = new ArrayList<Double>();
double Q;
for (int i = 0; i<T;i++){
double a = sc.nextInt();
double b = sc.nextInt();
if (b==0) Q = 1;
else if (a==0) Q = 0.5;
else if(a/4 < b) Q = 0.5 + a/(b*16);
else Q = 1 - b/a;
pr.add(Q);
}
for (int i = 0; i<pr.size(); i++){
System.out.println(pr.get(i));
}
}
}
|
You are given matrix with n rows and n columns filled with zeroes. You should put k ones in it in such a way that the resulting matrix is symmetrical with respect to the main diagonal (the diagonal that goes from the top left to the bottom right corner) and is lexicographically maximal.
One matrix is lexicographically greater than the other if the first different number in the first different row from the top in the first matrix is greater than the corresponding number in the second one.
If there exists no such matrix then output -1.
Input
The first line consists of two numbers n and k (1 ≤ n ≤ 100, 0 ≤ k ≤ 106).
Output
If the answer exists then output resulting matrix. Otherwise output -1.
Examples
Input
2 1
Output
1 0
0 0
Input
3 2
Output
1 0 0
0 1 0
0 0 0
Input
2 5
Output
-1
|
#include <bits/stdc++.h>
const int MAXN = 110;
int a[MAXN][MAXN];
void solve(int n, int pos, int k) {
if (k == 1) {
a[pos][pos] = 1;
return;
}
if (k == 0) return;
if (k <= (n << 1) - 1) {
for (int i = pos; i <= pos + (k - 1 >> 1); i++) a[pos][i] = a[i][pos] = 1;
solve(n - 1, pos + 1, (k & 1) ^ 1);
} else {
for (int i = pos; i <= pos + n - 1; i++) a[pos][i] = a[i][pos] = 1;
solve(n - 1, pos + 1, k - (n << 1) + 1);
}
return;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
if (k > n * n) {
puts("-1");
return 0;
}
solve(n, 1, k);
for (int i = 1; i <= n; i++, puts(""))
for (int j = 1; j <= n; j++) printf("%d ", a[i][j]);
return 0;
}
|
Grigory loves strings. Recently he found a metal strip on a loft. The strip had length n and consisted of letters "V" and "K". Unfortunately, rust has eaten some of the letters so that it's now impossible to understand which letter was written.
Grigory couldn't understand for a long time what these letters remind him of, so he became interested in the following question: if we put a letter "V" or "K" on each unreadable position, which values can the period of the resulting string be equal to?
A period of a string is such an integer d from 1 to the length of the string that if we put the string shifted by d positions to the right on itself, then all overlapping letters coincide. For example, 3 and 5 are periods of "VKKVK".
Input
There are several (at least one) test cases in the input. The first line contains single integer — the number of test cases.
There is an empty line before each test case. Each test case is described in two lines: the first line contains single integer n (1 ≤ n ≤ 5·105) — the length of the string, the second line contains the string of length n, consisting of letters "V", "K" and characters "?". The latter means the letter on its position is unreadable.
It is guaranteed that the sum of lengths among all test cases doesn't exceed 5·105.
For hacks you can only use tests with one test case.
Output
For each test case print two lines. In the first line print the number of possible periods after we replace each unreadable letter with "V" or "K". In the next line print all these values in increasing order.
Example
Input
3
5
V??VK
6
??????
4
?VK?
Output
2
3 5
6
1 2 3 4 5 6
3
2 3 4
Note
In the first test case from example we can obtain, for example, "VKKVK", which has periods 3 and 5.
In the second test case we can obtain "VVVVVV" which has all periods from 1 to 6.
In the third test case string "KVKV" has periods 2 and 4, and string "KVKK" has periods 3 and 4.
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20);
const double pi = acos(-1);
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') x = x * 10 + (ch ^ '0'), ch = getchar();
return x * f;
}
struct CP {
double x, y;
CP(double xx = 0, double yy = 0) { x = xx, y = yy; }
};
CP operator+(CP aa, CP bb) { return CP(aa.x + bb.x, aa.y + bb.y); }
CP operator-(CP aa, CP bb) { return CP(aa.x - bb.x, aa.y - bb.y); }
CP operator*(CP aa, CP bb) {
return CP(aa.x * bb.x - aa.y * bb.y, aa.x * bb.y + aa.y * bb.x);
}
CP operator*(CP aa, double bb) { return CP(aa.x * bb, aa.y * bb); }
int pp[N], lim, Lim;
CP Pow[N], iPow[N];
void up(int x) {
for (lim = 1; lim <= x; lim <<= 1)
;
}
void revlim() {
for (int i = 0, iE = lim - 1; i <= iE; i++)
pp[i] = ((pp[i >> 1] >> 1) | ((i & 1) * (lim >> 1)));
}
void init(int x) {
up(x), Lim = lim;
Pow[0] = iPow[0] = CP(1, 0);
for (int i = 1, iE = Lim - 1; i <= iE; i++)
Pow[i] = iPow[Lim - i] = CP(cos(2 * pi / Lim * i), sin(2 * pi / Lim * i));
}
void FFT(CP *f, int flag) {
for (int i = 0, iE = lim - 1; i <= iE; i++)
if (pp[i] < i) swap(f[pp[i]], f[i]);
for (int i = 2; i <= lim; i <<= 1)
for (int j = 0, l = (i >> 1), ch = Lim / i; j < lim; j += i) {
for (int k = j, now = 0; k < j + l; k++) {
CP pa = f[k], pb = f[k + l] * (flag == 1 ? Pow[now] : iPow[now]);
f[k] = pa + pb, f[k + l] = pa - pb, now += ch;
}
}
if (flag == -1)
for (int i = 0, iE = lim - 1; i <= iE; i++) f[i].x /= lim, f[i].y /= lim;
}
int n, m, a[N], f[N], tot, g[N];
CP A[N], AA[N], AAA[N];
CP B[N], BB[N], BBB[N];
char s[N];
void Main() {
n = read(), scanf("%s", s);
up(n << 1), revlim();
for (int i = 0, iE = lim - 1; i <= iE; i++)
A[i] = B[i] = AA[i] = BB[i] = AAA[i] = BBB[i] = CP(0, 0);
for (int i = 0, iE = n - 1; i <= iE; i++) {
int o;
if (s[i] == '?') o = 0;
if (s[i] == 'V') o = 1;
if (s[i] == 'K') o = 2;
B[n - 1 - i].x = A[i].x = o;
BB[n - 1 - i].x = AA[i].x = o * o;
BBB[n - 1 - i].x = AAA[i].x = o * o * o;
;
}
FFT(A, 1), FFT(AA, 1), FFT(AAA, 1);
FFT(B, 1), FFT(BB, 1), FFT(BBB, 1);
for (int i = 0, iE = lim - 1; i <= iE; i++)
A[i] = A[i] * BBB[i] + AAA[i] * B[i] - AA[i] * BB[i] * 2;
FFT(A, -1);
for (int i = 0, iE = n - 1; i <= iE; i++) f[i] = A[n - 1 - i].x;
tot = 0;
for (int i = 1, iE = n; i <= iE; i++) {
bool ok = 1;
for (int j = 1, jE = (n - 1) / i; j <= jE; j++)
if (f[i * j]) ok = 0;
if (ok) g[++tot] = i;
}
printf("%d\n", tot);
for (int i = 1, iE = tot; i <= iE; i++) printf("%d ", g[i]);
puts("");
}
int main() {
init(1e6);
int T = read();
while (T--) Main();
return 0;
}
|
I won't feel lonely, nor will I be sorrowful... not before everything is buried.
A string of n beads is left as the message of leaving. The beads are numbered from 1 to n from left to right, each having a shape numbered by integers between 1 and n inclusive. Some beads may have the same shapes.
The memory of a shape x in a certain subsegment of beads, is defined to be the difference between the last position and the first position that shape x appears in the segment. The memory of a subsegment is the sum of memories over all shapes that occur in it.
From time to time, shapes of beads change as well as the memories. Sometimes, the past secreted in subsegments are being recalled, and you are to find the memory for each of them.
Input
The first line of input contains two space-separated integers n and m (1 ≤ n, m ≤ 100 000) — the number of beads in the string, and the total number of changes and queries, respectively.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ n) — the initial shapes of beads 1, 2, ..., n, respectively.
The following m lines each describes either a change in the beads or a query of subsegment. A line has one of the following formats:
* 1 p x (1 ≤ p ≤ n, 1 ≤ x ≤ n), meaning that the shape of the p-th bead is changed into x;
* 2 l r (1 ≤ l ≤ r ≤ n), denoting a query of memory of the subsegment from l to r, inclusive.
Output
For each query, print one line with an integer — the memory of the recalled subsegment.
Examples
Input
7 6
1 2 3 1 3 2 1
2 3 7
2 1 3
1 7 2
1 3 2
2 1 6
2 5 7
Output
5
0
7
1
Input
7 5
1 3 2 1 4 2 3
1 1 4
2 2 3
1 1 7
2 4 5
1 1 7
Output
0
0
Note
The initial string of beads has shapes (1, 2, 3, 1, 3, 2, 1).
Consider the changes and queries in their order:
1. 2 3 7: the memory of the subsegment [3, 7] is (7 - 4) + (6 - 6) + (5 - 3) = 5;
2. 2 1 3: the memory of the subsegment [1, 3] is (1 - 1) + (2 - 2) + (3 - 3) = 0;
3. 1 7 2: the shape of the 7-th bead changes into 2. Beads now have shapes (1, 2, 3, 1, 3, 2, 2) respectively;
4. 1 3 2: the shape of the 3-rd bead changes into 2. Beads now have shapes (1, 2, 2, 1, 3, 2, 2) respectively;
5. 2 1 6: the memory of the subsegment [1, 6] is (4 - 1) + (6 - 2) + (5 - 5) = 7;
6. 2 5 7: the memory of the subsegment [5, 7] is (7 - 6) + (5 - 5) = 1.
|
#include <bits/stdc++.h>
using namespace std;
struct fenwick_tree_1D {
long long n, log_n;
vector<long long> tree;
fenwick_tree_1D(long long _n)
: n(_n), log_n((long long)(log2(_n) + 1.0L)), tree(_n + 5) {}
void update(long long x, long long v) {
while (x <= n) {
tree[x] += v;
x += x & (-x);
}
}
long long prefix_sum(long long x) {
long long r = 0;
while (x) {
r += tree[x];
x -= x & (-x);
}
return r;
}
long long range_sum(long long l, long long r) {
return prefix_sum(r) - prefix_sum(l - 1);
}
};
const long long bs = 300;
fenwick_tree_1D bit(100005);
long long a[100005], nxt[100005], last[100005] = {0}, dl[2 * bs + 5],
id[100005], dc = 0, result[100005] = {0};
set<long long> s[100005];
long long qc;
struct query {
long long t, l, r, qno;
} q[bs + 5];
long long q2c;
struct query2 {
long long l, r, qno;
} q2[bs + 5];
vector<long long> ans;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
s[a[i]].insert(i);
}
for (long long h = 0; h < m; h += bs) {
qc = min(bs, m - h);
for (long long j = 0; j < qc; j++) {
cin >> q[j].t >> q[j].l >> q[j].r;
q[j].qno = h + j;
if (q[j].t == 1) {
if (!id[a[q[j].l]]) dl[dc] = a[q[j].l], id[a[q[j].l]] = 1, dc++;
if (!id[q[j].r]) dl[dc] = q[j].r, id[q[j].r] = 1, dc++;
} else
q2[q2c].l = q[j].l, q2[q2c].r = q[j].r, q2[q2c].qno = q[j].qno,
ans.push_back(q[j].qno), q2c++;
}
for (long long i = n; i >= 1; i--) {
if (id[a[i]]) {
nxt[i] = 0;
continue;
}
nxt[i] = last[a[i]];
if (nxt[i]) bit.update(nxt[i], nxt[i] - i);
last[a[i]] = i;
}
sort(q2, q2 + q2c,
[](const query2 &l, const query2 &r) { return l.l < r.l; });
long long pos = 1;
for (long long i = 0; i < q2c; i++) {
while (pos < q2[i].l) {
if (id[a[pos]] || !nxt[pos]) {
pos++;
continue;
}
bit.update(nxt[pos], pos - nxt[pos]);
pos++;
}
result[q2[i].qno] = bit.prefix_sum(q2[i].r);
}
for (long long i = 0; i < qc; i++) {
if (q[i].t == 1) {
s[a[q[i].l]].erase(q[i].l);
a[q[i].l] = q[i].r;
s[a[q[i].l]].insert(q[i].l);
} else {
for (long long j = 0; j < dc; j++) {
auto it1 = s[dl[j]].lower_bound(q[i].l);
auto it2 = s[dl[j]].upper_bound(q[i].r);
if (it1 != s[dl[j]].end() && it2 != s[dl[j]].begin()) {
it2--;
if (*it2 > *it1) result[q[i].qno] += *it2 - *it1;
}
}
}
}
for (long long i = 0; i < dc; i++) id[dl[i]] = 0;
dc = 0;
q2c = 0;
for (long long i = 1; i <= n; i++) bit.tree[i] = 0, last[i] = 0;
}
for (auto &k : ans) cout << result[k] << "\n";
}
|
This is an interactive problem.
Jury has hidden a permutation p of integers from 0 to n - 1. You know only the length n. Remind that in permutation all integers are distinct.
Let b be the inverse permutation for p, i.e. pbi = i for all i. The only thing you can do is to ask xor of elements pi and bj, printing two indices i and j (not necessarily distinct). As a result of the query with indices i and j you'll get the value <image>, where <image> denotes the xor operation. You can find the description of xor operation in notes.
Note that some permutations can remain indistinguishable from the hidden one, even if you make all possible n2 queries. You have to compute the number of permutations indistinguishable from the hidden one, and print one of such permutations, making no more than 2n queries.
The hidden permutation does not depend on your queries.
Input
The first line contains single integer n (1 ≤ n ≤ 5000) — the length of the hidden permutation. You should read this integer first.
Output
When your program is ready to print the answer, print three lines.
In the first line print "!".
In the second line print single integer answers_cnt — the number of permutations indistinguishable from the hidden one, including the hidden one.
In the third line print n integers p0, p1, ..., pn - 1 (0 ≤ pi < n, all pi should be distinct) — one of the permutations indistinguishable from the hidden one.
Your program should terminate after printing the answer.
Interaction
To ask about xor of two elements, print a string "? i j", where i and j — are integers from 0 to n - 1 — the index of the permutation element and the index of the inverse permutation element you want to know the xor-sum for. After that print a line break and make flush operation.
After printing the query your program should read single integer — the value of <image>.
For a permutation of length n your program should make no more than 2n queries about xor-sum. Note that printing answer doesn't count as a query. Note that you can't ask more than 2n questions. If you ask more than 2n questions or at least one incorrect question, your solution will get "Wrong answer".
If at some moment your program reads -1 as an answer, it should immediately exit (for example, by calling exit(0)). You will get "Wrong answer" in this case, it means that you asked more than 2n questions, or asked an invalid question. If you ignore this, you can get other verdicts since your program will continue to read from a closed stream.
Your solution will get "Idleness Limit Exceeded", if you don't print anything or forget to flush the output, including for the final answer .
To flush you can use (just after printing line break):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* For other languages see the documentation.
Hacking
For hacking use the following format:
n
p0 p1 ... pn - 1
Contestant programs will not be able to see this input.
Examples
Input
3
0
0
3
2
3
2
Output
? 0 0
? 1 1
? 1 2
? 0 2
? 2 1
? 2 0
!
1
0 1 2
Input
4
2
3
2
0
2
3
2
0
Output
? 0 1
? 1 2
? 2 3
? 3 3
? 3 2
? 2 1
? 1 0
? 0 0
!
2
3 1 2 0
Note
xor operation, or bitwise exclusive OR, is an operation performed over two integers, in which the i-th digit in binary representation of the result is equal to 1 if and only if exactly one of the two integers has the i-th digit in binary representation equal to 1. For more information, see [here](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
In the first example p = [0, 1, 2], thus b = [0, 1, 2], the values <image> are correct for the given i, j. There are no other permutations that give the same answers for the given queries.
The answers for the queries are:
* <image>,
* <image>,
* <image>,
* <image>,
* <image>,
* <image>.
In the second example p = [3, 1, 2, 0], and b = [3, 1, 2, 0], the values <image> match for all pairs i, j. But there is one more suitable permutation p = [0, 2, 1, 3], b = [0, 2, 1, 3] that matches all n2 possible queries as well. All other permutations do not match even the shown queries.
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-12;
const int MOD = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 5e3 + 4;
const int maxm = 1e3 + 4;
inline long long rule(long long x) { return (x %= MOD) += x < 0 ? MOD : 0; }
int A[maxn][maxn], n;
int B[maxn][maxn], p[maxn], b[maxn], a[maxn];
int vis[maxn];
int id = -1;
bool check(int num) {
p[0] = num;
vis[num] = num;
b[num] = 0;
for (int j = 1; j < n; ++j) {
p[j] = p[0] ^ B[0][j];
if (p[j] >= n || vis[p[j]] == num) return false;
vis[p[j]] = num;
b[p[j]] = j;
}
for (int i = 0; i < n; ++i) {
if ((p[i] ^ b[id]) != A[i][id]) return false;
if ((p[0] ^ b[i]) != A[0][i]) return false;
}
for (int i = 0; i < n; ++i) a[i] = p[i];
return true;
}
int main() {
int ik, i, j, k, kase;
scanf("%d", &n);
memset(A, -1, sizeof A);
memset(vis, -1, sizeof(vis));
for (int i = 0; i < n; ++i) {
printf("? 0 %d\n", i);
fflush(stdout);
scanf("%d", &A[0][i]);
if (A[0][i] == 0) id = i;
}
for (int j = 0; j < n; ++j) {
printf("? %d %d\n", j, id);
fflush(stdout);
scanf("%d", &A[j][id]);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j)
if (A[i][j] == -1) A[i][j] = A[i][id] ^ A[0][j];
}
for (int i = 0; i < 1; ++i) {
for (int j = 0; j < n; ++j) B[i][j] = A[i][0] ^ A[j][0];
}
int cnt = 0;
for (int i = 0; i < n; ++i) {
cnt += check(i);
}
printf("!\n");
fflush(stdout);
printf("%d\n", cnt);
fflush(stdout);
for (int i = 0; i < n; ++i) printf("%d%c", a[i], " \n"[i == n - 1]);
fflush(stdout);
return 0;
}
|
Vasya has n burles. One bottle of Ber-Cola costs a burles and one Bars bar costs b burles. He can buy any non-negative integer number of bottles of Ber-Cola and any non-negative integer number of Bars bars.
Find out if it's possible to buy some amount of bottles of Ber-Cola and Bars bars and spend exactly n burles.
In other words, you should find two non-negative integers x and y such that Vasya can buy x bottles of Ber-Cola and y Bars bars and x·a + y·b = n or tell that it's impossible.
Input
First line contains single integer n (1 ≤ n ≤ 10 000 000) — amount of money, that Vasya has.
Second line contains single integer a (1 ≤ a ≤ 10 000 000) — cost of one bottle of Ber-Cola.
Third line contains single integer b (1 ≤ b ≤ 10 000 000) — cost of one Bars bar.
Output
If Vasya can't buy Bars and Ber-Cola in such a way to spend exactly n burles print «NO» (without quotes).
Otherwise in first line print «YES» (without quotes). In second line print two non-negative integers x and y — number of bottles of Ber-Cola and number of Bars bars Vasya should buy in order to spend exactly n burles, i.e. x·a + y·b = n. If there are multiple answers print any of them.
Any of numbers x and y can be equal 0.
Examples
Input
7
2
3
Output
YES
2 1
Input
100
25
10
Output
YES
0 10
Input
15
4
8
Output
NO
Input
9960594
2551
2557
Output
YES
1951 1949
Note
In first example Vasya can buy two bottles of Ber-Cola and one Bars bar. He will spend exactly 2·2 + 1·3 = 7 burles.
In second example Vasya can spend exactly n burles multiple ways:
* buy two bottles of Ber-Cola and five Bars bars;
* buy four bottles of Ber-Cola and don't buy Bars bars;
* don't buy Ber-Cola and buy 10 Bars bars.
In third example it's impossible to but Ber-Cola and Bars bars in order to spend exactly n burles.
|
#include <bits/stdc++.h>
using namespace std;
inline void timer(void) {
int t = clock();
cout << (float(t)) / CLOCKS_PER_SEC;
}
int main() {
int n, a, b, x, y, x_ = 0;
cin >> n >> x >> y;
if (!(y % x))
if (!(n % x))
return !(cout << "YES" << endl << n / x << ' ' << 0);
else
return !(cout << "NO");
else
while (n % y && n > 0) n -= x, x_++;
if (n >= 0) return !(cout << "YES" << endl << x_ << ' ' << n / y);
return !(cout << "NO");
}
|
Suppose that you are in a campus and have to go for classes day by day. As you may see, when you hurry to a classroom, you surprisingly find that many seats there are already occupied. Today you and your friends went for class, and found out that some of the seats were occupied.
The classroom contains n rows of seats and there are m seats in each row. Then the classroom can be represented as an n × m matrix. The character '.' represents an empty seat, while '*' means that the seat is occupied. You need to find k consecutive empty seats in the same row or column and arrange those seats for you and your friends. Your task is to find the number of ways to arrange the seats. Two ways are considered different if sets of places that students occupy differs.
Input
The first line contains three positive integers n,m,k (1 ≤ n, m, k ≤ 2 000), where n,m represent the sizes of the classroom and k is the number of consecutive seats you need to find.
Each of the next n lines contains m characters '.' or '*'. They form a matrix representing the classroom, '.' denotes an empty seat, and '*' denotes an occupied seat.
Output
A single number, denoting the number of ways to find k empty seats in the same row or column.
Examples
Input
2 3 2
**.
...
Output
3
Input
1 2 2
..
Output
1
Input
3 3 4
.*.
*.*
.*.
Output
0
Note
In the first sample, there are three ways to arrange those seats. You can take the following seats for your arrangement.
* (1,3), (2,3)
* (2,2), (2,3)
* (2,1), (2,2)
|
'''input
1 10 1
..........
'''
n,m,k = map(int,raw_input().split())
arr = []
for i in range(n):
tmp = list(raw_input().strip())
arr.append(tmp)
ans = 0
for i in range(n):
cnt = 0
tmp = []
for j in range(m):
if arr[i][j] == '.':
cnt += 1
else:
if cnt >= k:
tmp.append(cnt)
cnt = 0
if cnt >= k:
tmp.append(cnt)
for o in tmp:
ans += (o-k+1)
for i in range(m):
cnt = 0
tmp = []
for j in range(n):
if arr[j][i] == '.':
cnt += 1
else:
if cnt >= k:
tmp.append(cnt)
cnt = 0
if cnt >= k:
tmp.append(cnt)
for o in tmp:
ans += (o-k+1)
if k == 1:
print ans//2
else:
print ans
|
You have two variables a and b. Consider the following sequence of actions performed with these variables:
1. If a = 0 or b = 0, end the process. Otherwise, go to step 2;
2. If a ≥ 2·b, then set the value of a to a - 2·b, and repeat step 1. Otherwise, go to step 3;
3. If b ≥ 2·a, then set the value of b to b - 2·a, and repeat step 1. Otherwise, end the process.
Initially the values of a and b are positive integers, and so the process will be finite.
You have to determine the values of a and b after the process ends.
Input
The only line of the input contains two integers n and m (1 ≤ n, m ≤ 1018). n is the initial value of variable a, and m is the initial value of variable b.
Output
Print two integers — the values of a and b after the end of the process.
Examples
Input
12 5
Output
0 1
Input
31 12
Output
7 12
Note
Explanations to the samples:
1. a = 12, b = 5 <image> a = 2, b = 5 <image> a = 2, b = 1 <image> a = 0, b = 1;
2. a = 31, b = 12 <image> a = 7, b = 12.
|
a, b = map(int, input().split())
while a != 0 and b != 0:
if a >= 2 * b:
a = a % (2 * b)
elif b >= 2 * a:
b = b % (2 * a)
else:
print(a, b)
exit(0)
print(a, b)
|
Petya likes horse racing very much. Horses numbered from l to r take part in the races. Petya wants to evaluate the probability of victory; for some reason, to do that he needs to know the amount of nearly lucky horses' numbers. A nearly lucky number is an integer number that has at least two lucky digits the distance between which does not exceed k. Petya learned from some of his mates from Lviv that lucky digits are digits 4 and 7. The distance between the digits is the absolute difference between their positions in the number of a horse. For example, if k = 2, then numbers 412395497, 404, 4070400000070004007 are nearly lucky and numbers 4, 4123954997, 4007000040070004007 are not.
Petya prepared t intervals [li, ri] and invented number k, common for all of them. Your task is to find how many nearly happy numbers there are in each of these segments. Since the answers can be quite large, output them modulo 1000000007 (109 + 7).
Input
The first line contains two integers t and k (1 ≤ t, k ≤ 1000) — the number of segments and the distance between the numbers correspondingly. Next t lines contain pairs of integers li and ri (1 ≤ l ≤ r ≤ 101000). All numbers are given without the leading zeroes. Numbers in each line are separated by exactly one space character.
Output
Output t lines. In each line print one integer — the answer for the corresponding segment modulo 1000000007 (109 + 7).
Examples
Input
1 2
1 100
Output
4
Input
1 2
70 77
Output
2
Input
2 1
1 20
80 100
Output
0
0
Note
In the first sample, the four nearly lucky numbers are 44, 47, 74, 77.
In the second sample, only 74 and 77 are in the given segment.
|
#include <bits/stdc++.h>
using namespace std;
long long dp[1111][1111][2];
const long long mod = 1000000007;
int lim, len;
char s[1111];
long long getdp(int l, int less, int last, int ok) {
if (l == -1) return ok;
long long &ret = dp[l][last][ok];
if (!less && ret != -1) return ret;
long long res = 0;
int u;
if (!less)
u = 9;
else
u = s[l] - '0';
if (ok == 1) {
for (int i = 0; i <= u; i++) {
int tl = 0;
res += getdp(l - 1, less && i == u, 0, 1);
if (res >= mod) res -= mod;
}
if (!less) ret = res;
return res;
}
for (int i = 0; i <= u; i++) {
int tl = 0;
if (i == 4 || i == 7) {
if (last != 1003 && last - l <= lim)
res += getdp(l - 1, less && i == u, l, 1);
else
res += getdp(l - 1, less && i == u, l, 0);
} else
res += getdp(l - 1, less && i == u, last, 0);
if (res >= mod) res -= mod;
}
if (!less) ret = res;
return res;
}
long gao(char *x) {
strcpy(s, x);
len = strlen(s);
reverse(s, s + len);
return getdp(len - 1, 1, 1003, 0);
}
long long test(char *x) {
int aa[1111], nn = 0, lll = strlen(x), i;
for (i = 0; i < lll; i++)
if (x[i] == '4' || x[i] == '7') aa[nn++] = i;
for (i = 0; i < nn - 1; i++) {
if (aa[i + 1] - aa[i] <= lim) return 1;
}
return 0;
}
void run() {
int cas;
scanf("%d%d", &cas, &lim);
char l[1111], r[1111];
while (cas--) {
scanf("%s%s", l, r);
long long ans = gao(r) - gao(l) + test(l);
ans = (ans % mod + mod) % mod;
cout << ans << endl;
}
}
int main() {
memset(dp, -1, sizeof(dp));
run();
return 0;
}
|
There are two small spaceship, surrounded by two groups of enemy larger spaceships. The space is a two-dimensional plane, and one group of the enemy spaceships is positioned in such a way that they all have integer y-coordinates, and their x-coordinate is equal to -100, while the second group is positioned in such a way that they all have integer y-coordinates, and their x-coordinate is equal to 100.
Each spaceship in both groups will simultaneously shoot two laser shots (infinite ray that destroys any spaceship it touches), one towards each of the small spaceships, all at the same time. The small spaceships will be able to avoid all the laser shots, and now want to position themselves at some locations with x=0 (with not necessarily integer y-coordinates), such that the rays shot at them would destroy as many of the enemy spaceships as possible. Find the largest numbers of spaceships that can be destroyed this way, assuming that the enemy spaceships can't avoid laser shots.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 60), the number of enemy spaceships with x = -100 and the number of enemy spaceships with x = 100, respectively.
The second line contains n integers y_{1,1}, y_{1,2}, …, y_{1,n} (|y_{1,i}| ≤ 10 000) — the y-coordinates of the spaceships in the first group.
The third line contains m integers y_{2,1}, y_{2,2}, …, y_{2,m} (|y_{2,i}| ≤ 10 000) — the y-coordinates of the spaceships in the second group.
The y coordinates are not guaranteed to be unique, even within a group.
Output
Print a single integer – the largest number of enemy spaceships that can be destroyed.
Examples
Input
3 9
1 2 3
1 2 3 7 8 9 11 12 13
Output
9
Input
5 5
1 2 3 4 5
1 2 3 4 5
Output
10
Note
In the first example the first spaceship can be positioned at (0, 2), and the second – at (0, 7). This way all the enemy spaceships in the first group and 6 out of 9 spaceships in the second group will be destroyed.
In the second example the first spaceship can be positioned at (0, 3), and the second can be positioned anywhere, it will be sufficient to destroy all the enemy spaceships.
|
#include <bits/stdc++.h>
using namespace std;
int x[78], y[78];
set<int> mp[400005];
int delta = 200000;
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", x + i);
}
for (int i = 1; i <= m; i++) {
scanf("%d", y + i);
}
set<int> st;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int slope = (y[j] - x[i]);
int c = slope + x[i] * 2;
mp[c + delta].insert(i);
mp[c + delta].insert(n + j);
st.insert(c);
}
}
vector<int> v;
for (set<int>::iterator it = st.begin(); it != st.end(); it++) {
v.push_back(*it);
}
int maxi = 0;
if (v.size() == 1) {
printf("%d\n", (int)mp[v[0] + delta].size());
return 0;
}
for (int i = 0; i < v.size(); i++) {
for (int j = i + 1; j < v.size(); j++) {
set<int> lol;
for (set<int>::iterator it = mp[v[i] + delta].begin();
it != mp[v[i] + delta].end(); it++) {
lol.insert(*it);
}
for (set<int>::iterator it = mp[v[j] + delta].begin();
it != mp[v[j] + delta].end(); it++) {
lol.insert(*it);
}
maxi = max(maxi, (int)lol.size());
}
}
cout << maxi;
}
|
A boy named Mohan was very fond of integer arrays and loved performing various operations on them.
Once he decided to calculate a unique value of the array, which he named as Babua value.
To find that value, he calculates the absolute difference between all consecutive elements in an array
and adds it to the first element of the array for a permutation.
He does this for all permutations of the array and finds the average value.
He calls this value as Babua Value of array.
Your task is to find this value given an array.
Input
First line of input contains x (2 ≤ x ≤ 100000).
Next line contains x integers a1, a2, ..., ax (1 ≤ ai ≤ 10000000).
All the integers will be distinct.
Output
Output two integers separated by '/'. The first integer being the numerator and second integer being the denominator of a fraction
which is equal to the Babua value. The fraction must be irreducible.
SAMPLE INPUT
3
1 2 4
SAMPLE OUTPUT
19/3
Explanation
Consider 6 possible permutations:
[1, 2, 4]: total sum for a permutation: 1 + |2 – 1| + |4 – 2| = 4;
[1, 4, 2]: 1 + |4 – 1| + |2 – 4| = 6;
[2, 1, 4]: 2 + |1 – 2| + |4 – 1| = 6;
[2, 4, 1]: 2 + |4 – 2| + |1 – 4| = 7;
[4, 1, 2]: 4 + |1 – 4| + |2 – 1| = 8;
[4, 2, 1]: 4 + |2 – 4| + |1 – 2| = 7.
The average travel distance is = 19/3.
|
def gcd(a,b):
if (a%b==0):
return b
return gcd(b,a%b)
z=input()
a=map(int,raw_input().split())
a=sorted(a)
ans=0
for x in a:
ans+=x
#for x in a:
# for y in a:
# ans+=abs(x-y)
start=0
aa=0
count=0
for x in a:
aa+=2*(count*x-start)
start+=x
count+=1
ans+=aa
num=ans
den=z
g=gcd(num,den)
num,den=num/g,den/g
print str(num)+"/"+str(den)
|
"Too close Yet too far"
It is well known that our chotu is chotu (Height-wise :P). On Hug day his short height is creating problems for him as most of the girls are taller than him so he can't hug them properly. To overcome the problem he has decided that he shall hug the girl whose height is closest to him.
Given that the height of chotu is H and there are N girls, whose heights are given as a1,a2,a3,a4...aN.Find the minimum absolute difference between Height of girls and height of Chotu.
Input
First line contains number of test cases, T.
First line of each test case contains two space separated integers N and H denoting number of girls and the height of chotu.
Second line of each test case contains N space separated integers denoting height of each girl.
Output
For each test case print in a single line minimum absolute difference between height of chotu and height of girls.
Constrains
1 ≤ T ≤ 100
1 ≤ N ≤ 1000
1 ≤ H, ai ≤ 10000
SAMPLE INPUT
2
5 4
10 1 2 3 6
4 8
8 8 8 8
SAMPLE OUTPUT
1
0
Explanation
For the first case, he will hug girl with height 3.
For 2nd test case, he can hug any girl.
|
import math
t = int(raw_input())
while t>0:
a = raw_input().split(' ')
a = [int(x) for x in a if x!='']
b = raw_input().split(' ')
b = [int(x) for x in b if x!='']
for i in range(0, len(b)):
b[i]=abs(b[i]-a[1])
b.sort()
print b[0]
t=t-1
|
Sorry folks,, admin has no time to create a story for this problem...
You have two integers n and m and you have to print value of factorial(n)%m.
OUTPUT
a single integer containing answer of problem.
Input
23 14567
NOTE You do not need to create a program for this problem you have to write your answers of given input in given code snippet
To see how to submit solution please check this link
SAMPLE INPUT
5 11
SAMPLE OUTPUT
10
|
from math import factorial
a,b=map(int,raw_input().split())
j=factorial(a)
p=j%b
print p
|
Hanuman has been a great admirer of Ram. However, there is one thing that Hanuman finds really difficult when talking to Ram. Hanuman can only understand sentences in reverse order but Ram,though an incarnation of God,is somehow unable to speak in reverse.
Help Ram by creating a program that will generate the sentence(string S) given by Ram in reverse order word by word.
INPUT:
An integer T (1 ≤ T ≤ 1000) : number of testcases
Each test case is represented by a sentence (1 ≤ length_of_sentence ≤ 100)
OUTPUT:
For each test case T, output a sentence which is in the reverse order of that of the user given sentence(word by word and not letter by letter)
SAMPLE INPUT
3
I have always been fond of you, Hanuman
SpacelessSentence
A B C D 5
SAMPLE OUTPUT
Hanuman you, of fond been always have I
SpacelessSentence
5 D C B A
|
noOfSentences = int(raw_input())
def reverseString(s):
strings = s.split(" ")
strings = strings[::-1]
return ' '.join(strings)
for caseNo in range(1, noOfSentences + 1):
print reverseString(raw_input())
|
There was girl named Julia in their neighbourhood. Both of them liked her and were trying to impress her. Now that Tim and Bob are done with daddy’s game. Julia thought that Tim solved the game on his own and was deeply impressed. After few days, Julia and Tim realised they fell in love with each other. They started talking in code words when someone is around them. Bob, who was feeling very disheartened that he didn’t get Julia tried to understand what are they talking about. He concluded with a pattern and decoded their conversation. He thinks each letter of their word is shifted by 2 places further through the alphabet (e.g. 'A' shifts to 'C', 'R' shifts to 'T', etc.).
For example, "IMISSU" shifted by 2 places will be encoded as "KOKUUW". In other words, if given (quotes for clarity) "KOKUUW" and 2 as input, you will return "IMISSU".
They can, of course, try shifting by any number. Given a coded text and a number of places to shift, decode it.
Help Bob to decode Tim and Julia’s code word.
Input
First line contains T denoting number of test cases, Each test case consist of K denoting key, the number by which the letters are shifted. The next line contains the one code word of their conversation.
Output
The output contains the decoded word i.e. it stands for the original meaning of the word meant by them.
Constraints
1 ≤ T ≤ 10
Each code word has length between 0 to 50 characters inclusive.
Each character of code word is an uppercase letter 'A'-'Z'.
SAMPLE INPUT
4
2
KOKUUW
4
ALEXCSYIEX
9
FQHJANHXDXOOURWN
1
XIPXBTTIF
SAMPLE OUTPUT
IMISSU
WHATYOUEAT
WHYAREYOUOFFLINE
WHOWASSHE
|
for i in range(input()):
k=input()
st=[]
s=raw_input()
for j in range(len(s)):
l=ord(s[j])-k
if l<ord('A'):
l=l+26
st.append(chr(l))
print "".join(st)
|
Solve the mystery.
Input:
String which consists of words(all the characters of any word are lower case letters) and punctuation marks(consists of {'.' , ',' , '?' , '!'}). Also every input string consists of one '*' in it.
It is guaranteed that strings doesn't start or end with space(' ') and only one answer exists for each case.
Output:
Lower case letter.
Constrains:
1 ≤ t ≤ 1000
2 ≤ length of string(n) ≤ 100
Problem Setter : Vinay Kumar
SAMPLE INPUT
7
k! cats s*ack.
ah, s*tan sees natasha!
aibohphobi*
al lets della call ed ste*la.
amy, must i jujitsu *y ma?
aerata pat a*ea.
lollipop i * lol.
SAMPLE OUTPUT
t
a
a
l
m
r
l
|
N=input();
for k in range(0,N):
st=raw_input()
str=""
ct=0;
for i in range(0,len(st)):
if(st[i].isalnum()==1)or st[i]=='*':
str=str+st[i];
#print str
ct=len(str)-1;
c=""
for i in range(0,len(str)):
if(str[i]=='*'):
c=str[ct];
break;
ct=ct-1;
print c;
|
Julia has a sack full of red and yellow balls and wants to arrange them in a particular order as
defined below.
Let us consider two definitions -
Chroma-regularity - maximum number of objects of the same color that appear consecutively.
Min-Arrangement - An arrangement of the objects with minimum Chroma Regularity possible.
Given a sack full of only red and yellow balls find the required min-arrangement.
(Input – x and y one after the other and -1 or 0 to end
Output – one single integer)
SAMPLE INPUT
10
10
SAMPLE OUTPUT
1
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
#print 'Hello World!'
r=input()
s=input()
m=min(r,s)
n=max(r,s)
if m==n or s==1:
print "1"
else:
while m>0:
n=n/2+1
m-=1
print n
|
Bob gives you a list of N strings and a task to solve. The task is to remove all the duplicate strings from the list and print the resulting list of strings in a sorted order.
Input:
The first line contains an integer N. Then next N lines contain a string Si.
Output:
Print the sorted list.
Constraints:
1 ≤ |N| ≤ 5000
1 ≤ |Si| ≤ 100
SAMPLE INPUT
16
nandu
kanth
kalyan
dhiraj
kanth
kalyan
baala
kt
baala
jayanth
sampu
baala
kanth
kalyan
baala
kt
SAMPLE OUTPUT
baala
dhiraj
jayanth
kalyan
kanth
kt
nandu
sampu
|
n=input()
a=set()
for i in range(n):
str=raw_input()
a.add(str)
for i in sorted(a):
print i
|
Mr. Osama is a maths enthusiast. Numbers and equations never fails to amaze him. Recently he started exploring a weird problem. The explanation of the problem he is working on, is given below.
He takes the equation,
ax1+bx2+cx3+.... = 1, for some integers x1,x2,x3,...
He likes to analyze the properties of this equation. Given a set of values a,b,c,... can we find whether the given set of integers complies with the above equation for some set of integers x1,x2,x3... ?
Osama being a genius, devised a method to solve this problem. Now he challenges you. Given a set of positive integers (a,b,c,...) you have to say whether it can solve the above equation for some integers (x1,x2,x3,...).
First line of the input contains T, the total number of testcases to be processed. Then T sets of data follow.
Each set of data consists two lines. First line contains N, followed by N space separated positive integers in the next line, the set of integers to be processed.
1 ≤ T ≤ 10
1 ≤ N ≤ 100
1 ≤ positive integers in given set ≤ 10000000
Output a string for each testcase in a new line. Print YES if it can solve the above given equation for some set of integers (x1,x2,x3,...) . Or else Print NO.
SAMPLE INPUT
2
4
6 27 4 5
4
2 4 6 8
SAMPLE OUTPUT
YES
NO
Explanation
Sample input has two testcases.
First testcase has 4 numbers in the set. (6,27,4,5).
60 + 27(-2) + 40 + 511 = -54+55 = 1 ,thus print YES.
In second testcase, we cant form any combination of integers to solve the equation, thus print NO.
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
#print 'Hello World!'
from fractions import gcd
t=input()
while t>0:
t-=1
n=input()
l=[int(i) for i in raw_input().split()]
if reduce(gcd,l)==1:
print "YES"
else:
print"NO"
|
Rohan is programmer. He designed a game called X-Game. In this game, there are N number of soldiers, represented in terms of their powers. The algorithm of this game arranges all soldiers in all possible different groups.
Every group will fight among the soldiers of the same group and after the fight ends, the remaining power of all the groups will be added and that will be the final score of the player.
NOTE: The fight will performs the XOR operation between the power of the soldiers. Every group is unique.
INPUT:
An integer T, denoting the number of test-cases.
For each test-case contains two lines, first line will contains an integer N followed by second line containing N integers separated by a single space.
OUTPUT:
T lines, i th line containing the output of the i th testcase.
Constraints:
1 ≤ T ≤ 5
1 ≤ N ≤ 10^5
0 ≤ A[i] ≤ 10^9
SAMPLE INPUT
1
3
1 2 3
SAMPLE OUTPUT
12
|
mod = 10**9+7
for _ in xrange(input()):
n = input()
lst = map(int, raw_input().split())
ans = 0
for i in lst:
ans |= i
print (((2**(n-1)) % mod) * (ans % mod)) % mod
|
Given are an integer K and integers a_1,\dots, a_K. Determine whether a sequence P satisfying below exists. If it exists, find the lexicographically smallest such sequence.
* Every term in P is an integer between 1 and K (inclusive).
* For each i=1,\dots, K, P contains a_i occurrences of i.
* For each term in P, there is a contiguous subsequence of length K that contains that term and is a permutation of 1,\dots, K.
Constraints
* 1 \leq K \leq 100
* 1 \leq a_i \leq 1000 \quad (1\leq i\leq K)
* a_1 + \dots + a_K\leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
K
a_1 a_2 \dots a_K
Output
If there is no sequence satisfying the conditions, print `-1`. Otherwise, print the lexicographically smallest sequence satisfying the conditions.
Examples
Input
3
2 4 3
Output
2 1 3 2 2 3 1 2 3
Input
4
3 2 3 2
Output
1 2 3 4 1 3 1 2 4 3
Input
5
3 1 4 1 5
Output
-1
|
#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
const int K=105,N=1005;
int k,n;
int a[K];
vector<int>merge(const vector<int>&a,const vector<int>&b)
{
vector<int>res;
size_t i=0,j=0;
while(i<a.size()&&j<b.size())
{
if(a[i]<b[j]) res.push_back(a[i]),i++;
else res.push_back(b[j]),j++;
}
while(i<a.size())
res.push_back(a[i]),i++;
while(j<b.size())
res.push_back(b[j]),j++;
return res;
}
int ans[N],tot;
int b[K];
bool pos[K];
vector<int>add(int len)
{
for(int i=1;i<=k;i++)
pos[i]=false,b[i]=a[i];
vector<int>pre;
for(int i=tot,j=1;i>=1&&j<=k-len;i--,j++)
pre.push_back(ans[i]);
for(int u:pre)
pos[u]=true;
for(int i=1;i<=k;i++)
if(!pos[i]) b[i]--;
for(int i=1;i<=k;i++)
if(b[i]<0) return {k+1};
int Min=*min_element(b+1,b+k+1),Max=*max_element(b+1,b+k+1);
if(Min*2>=Max)
{
vector<int>res;
for(int i=1;i<=k;i++)
if(!pos[i]) res.push_back(i);
return res;
}
else if(Min*2+1==Max)
{
vector<int>x,y;
for(int i=1;i<=k;i++)
if(!pos[i]&&b[i]==Max) x.push_back(i);
for(int i=1;i<=k;i++)
if(!pos[i]&&b[i]==Min) x.push_back(i);
for(int i=1;i<=k;i++)
if(!pos[i]&&b[i]!=Min&&b[i]!=Max) y.push_back(i);
vector<int>res=merge(x,y);
pre.insert(pre.end(),res.begin(),res.end());
int L=0,R=(int)(pre.size())-1;
for(int i=0;i<pre.size();i++)
{
if(b[pre[i]]==Max) L=max(L,i);
if(b[pre[i]]==Min) R=min(R,i);
}
if(L<R) return res;
else return {k+1};
}
else return {k+1};
}
void solve()
{
vector<int>res={k+1};
for(int len=1;len<=k&&tot+len<=n;len++)
{
int d=k-len;
if(tot-d>=0)
{
vector<int>now=add(len);
res=min(res,now);
}
}
for(int u:res)
{
ans[++tot]=u;
a[u]--;
printf("%d ",u);
}
return;
}
int main()
{
scanf("%d",&k);
for(int i=1;i<=k;i++)
scanf("%d",&a[i]),n+=a[i];
int Min=*min_element(a+1,a+k+1),Max=*max_element(a+1,a+k+1);
if(2*Min+1<=Max)
{
printf("-1");
return 0;
}
while(tot<n)
solve();
return 0;
}
|
Akari has n kinds of flowers, one of each kind.
She is going to choose one or more of these flowers to make a bouquet.
However, she hates two numbers a and b, so the number of flowers in the bouquet cannot be a or b.
How many different bouquets are there that Akari can make?
Find the count modulo (10^9 + 7).
Here, two bouquets are considered different when there is a flower that is used in one of the bouquets but not in the other bouquet.
Constraints
* All values in input are integers.
* 2 \leq n \leq 10^9
* 1 \leq a < b \leq \textrm{min}(n, 2 \times 10^5)
Input
Input is given from Standard Input in the following format:
n a b
Output
Print the number of bouquets that Akari can make, modulo (10^9 + 7). (If there are no such bouquets, print `0`.)
Examples
Input
4 1 3
Output
7
Input
1000000000 141421 173205
Output
34076506
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ar array
const int M=1e9+7;
int n, a, b;
ll iv[200001];
ll nck(int n, int k) {
ll ans=1;
for(int i=1; i<=k; ++i)
ans=ans*(n-i+1)%M*iv[i]%M;
return ans;
}
ll powM(ll b, int p) {
ll r=1;
for(; p; b=b*b%M, p/=2)
if(p&1)
r=r*b%M;
return r;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
iv[1]=1;
for(int i=2; i<=200000; ++i)
iv[i]=M-M/i*iv[M%i]%M;
cin >> n >> a >> b;
ll ans=powM(2, n);
cout << (ans+2*M-nck(n, a)-nck(n, b)+M-1)%M;
}
|
We have a square grid with H rows and W columns. Snuke wants to write 0 or 1 in each of the squares. Here, all of the following conditions have to be satisfied:
* For every row, the smaller of the following is A: the number of 0s contained in the row, and the number of 1s contained in the row. (If these two numbers are equal, “the smaller” should be read as “either”.)
* For every column, the smaller of the following is B: the number of 0s contained in the column, and the number of 1s contained in the column.
Determine if these conditions can be satisfied by writing 0 or 1 in each of the squares. If the answer is yes, show one way to fill the squares so that the conditions are satisfied.
Constraints
* 1 \leq H,W \leq 1000
* 0 \leq A
* 2 \times A \leq W
* 0 \leq B
* 2 \times B \leq H
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H W A B
Output
If the conditions cannot be satisfied by writing 0 or 1 in each of the squares, print -1.
If the conditions can be satisfied, print one way to fill the squares so that the conditions are satisfied, in the following format:
s_{11}s_{12}\cdots s_{1W}
s_{21}s_{22}\cdots s_{2W}
\vdots
s_{H1}s_{H2}\cdots s_{HW}
Here s_{ij} is the digit written in the square at the i-th row from the top and the j-th column from the left in the grid.
If multiple solutions exist, printing any of them will be accepted.
Examples
Input
3 3 1 1
Output
100
010
001
Input
1 5 2 0
Output
01010
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a, b;
scanf("%d%d%d%d", &n, &m, &a, &b);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if ((i <= b && j <= a) || (i > b && j > a)) putchar('1');
else putchar('0');
}
putchar('\n');
}
return 0;
}
|
You have N cards. On the i-th card, an integer A_i is written.
For each j = 1, 2, ..., M in this order, you will perform the following operation once:
Operation: Choose at most B_j cards (possibly zero). Replace the integer written on each chosen card with C_j.
Find the maximum possible sum of the integers written on the N cards after the M operations.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i, C_i \leq 10^9
* 1 \leq B_i \leq N
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
B_1 C_1
B_2 C_2
\vdots
B_M C_M
Output
Print the maximum possible sum of the integers written on the N cards after the M operations.
Examples
Input
3 2
5 1 4
2 3
1 5
Output
14
Input
10 3
1 8 5 7 100 4 52 33 13 5
3 10
4 30
1 4
Output
338
Input
3 2
100 100 100
3 99
3 99
Output
300
Input
11 3
1 1 1 1 1 1 1 1 1 1 1
3 1000000000
4 1000000000
3 1000000000
Output
10000000001
|
N,M=map(int,input().split())
L=[(1,a) for a in map(int,input().split())]
for _ in range(M):
L.append(tuple(map(int,input().split())))
L=sorted(L,key=lambda x: x[1],reverse=True)
ans,k=0,0
for n,a in L:
if n+k>=N:
ans+=a*(N-k)
break
else:
ans+=a*n
k+=n
print(ans)
|
Let N be a positive integer. You are given a string s of length N - 1, consisting of `<` and `>`.
Find the number of permutations (p_1, p_2, \ldots, p_N) of (1, 2, \ldots, N) that satisfy the following condition, modulo 10^9 + 7:
* For each i (1 \leq i \leq N - 1), p_i < p_{i + 1} if the i-th character in s is `<`, and p_i > p_{i + 1} if the i-th character in s is `>`.
Constraints
* N is an integer.
* 2 \leq N \leq 3000
* s is a string of length N - 1.
* s consists of `<` and `>`.
Input
Input is given from Standard Input in the following format:
N
s
Output
Print the number of permutations that satisfy the condition, modulo 10^9 + 7.
Examples
Input
4
<><
Output
5
Input
5
<<<<
Output
1
Input
20
>>>><>>><>><>>><<>>
Output
217136290
|
/*Author: Satyajeet Singh, Delhi Technological University*/
import java.io.*;
import java.util.*;
import java.text.*;
import java.lang.*;
import java.math.*;
public class Main{
/*********************************************Constants******************************************/
static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
static long mod=(long)1e9+7;
static long mod1=998244353;
static boolean sieve[];
static ArrayList<Integer> primes;
static long factorial[],invFactorial[];
static ArrayList<Pair> graph[];
static int pptr=0;
static String st[];
/****************************************Solutions Begins***************************************/
public static void main(String[] args) throws Exception{
nl();
int n=pi();
nl();
String input=st[0];
long dp[][]=new long[n+1][n+1];
dp[1][1]=1;
for(int len=2;len<=n;len++){
for(int i=1;i<=len-1;i++){
dp[len-1][i]+=dp[len-1][i-1];
if(dp[len-1][i]>=mod)dp[len-1][i]-=mod;
}
for(int a=1;a<=len;a++){
int l=0,r=0;
if(input.charAt(len-2)=='<'){
l=1;
r=a-1;
}
else{
l=a;
r=len-1;
}
long oo=(dp[len-1][r]-dp[len-1][l-1]+mod);
if(oo>=mod)oo-=mod;
dp[len][a]+=oo;
if(dp[len][a]>=mod)dp[len][a]-=mod;
// for(int b=1;b<=len-1;b++){
// int p=b;
// if(p>=a)p++;
// if((p<a)==(input.charAt(len-2)=='<')){
// dp[len][a]+=dp[len-1][b];
// if(dp[len][a]>=mod)dp[len][a]-=mod;
// }
// }
}
}
// debug(dp[2][2]);
long ans=0;
for(int i=1;i<=n;i++){
ans+=dp[n][i];
// debug(dp[2][i]);
if(ans>=mod)ans-=mod;
}
out.println(ans);
/****************************************Solutions Ends**************************************************/
out.flush();
out.close();
}
/****************************************Template Begins************************************************/
static void nl() throws Exception{
pptr=0;
st=br.readLine().split(" ");
}
static void nls() throws Exception{
pptr=0;
st=br.readLine().split("");
}
static int pi(){
return Integer.parseInt(st[pptr++]);
}
static long pl(){
return Long.parseLong(st[pptr++]);
}
static double pd(){
return Double.parseDouble(st[pptr++]);
}
/***************************************Precision Printing**********************************************/
static void printPrecision(double d){
DecimalFormat ft = new DecimalFormat("0.000000000000000000000");
out.print(ft.format(d));
}
/**************************************Bit Manipulation**************************************************/
static void printMask(long mask){
System.out.println(Long.toBinaryString(mask));
}
static long countBit(long mask){
long ans=0;
while(mask!=0){
if(mask%2==1){
ans++;
}
mask/=2;
}
return ans;
}
/******************************************Graph*********************************************************/
static void Makegraph(int n){
graph=new ArrayList[n];
for(int i=0;i<n;i++){
graph[i]=new ArrayList<>();
}
}
static void addEdge(int a,int b){
graph[a].add(new Pair(b,1));
}
static void addEdge(int a,int b,int c){
graph[a].add(new Pair(b,c));
}
/*********************************************PAIR********************************************************/
static class Pair implements Comparable<Pair> {
int u;
int v;
int index=-1;
public Pair(int u, int v) {
this.u = u;
this.v = v;
}
public int hashCode() {
int hu = (int) (u ^ (u >>> 32));
int hv = (int) (v ^ (v >>> 32));
return 31 * hu + hv;
}
public boolean equals(Object o) {
Pair other = (Pair) o;
return u == other.u && v == other.v;
}
public int compareTo(Pair other) {
if(index!=other.index)
return Long.compare(index, other.index);
return Long.compare(v, other.v)!=0?Long.compare(v, other.v):Long.compare(u, other.u);
}
public String toString() {
return "[u=" + u + ", v=" + v + "]";
}
}
/******************************************Long Pair*******************************************************/
static class Pairl implements Comparable<Pairl> {
long u;
long v;
int index=-1;
public Pairl(long u, long v) {
this.u = u;
this.v = v;
}
public int hashCode() {
int hu = (int) (u ^ (u >>> 32));
int hv = (int) (v ^ (v >>> 32));
return 31 * hu + hv;
}
public boolean equals(Object o) {
Pairl other = (Pairl) o;
return u == other.u && v == other.v;
}
public int compareTo(Pairl other) {
if(index!=other.index)
return Long.compare(index, other.index);
return Long.compare(v, other.v)!=0?Long.compare(v, other.v):Long.compare(u, other.u);
}
public String toString() {
return "[u=" + u + ", v=" + v + "]";
}
}
/*****************************************DEBUG***********************************************************/
public static void debug(Object... o){
System.out.println(Arrays.deepToString(o));
}
/************************************MODULAR EXPONENTIATION***********************************************/
static long modulo(long a,long b,long c){
long x=1;
long y=a%c;
while(b > 0){
if(b%2 == 1){
x=(x*y)%c;
}
y = (y*y)%c; // squaring the base
b /= 2;
}
return x%c;
}
/********************************************GCD**********************************************************/
static long gcd(long x, long y){
if(x==0)
return y;
if(y==0)
return x;
long r=0, a, b;
a = (x > y) ? x : y; // a is greater number
b = (x < y) ? x : y; // b is smaller number
r = b;
while(a % b != 0){
r = a % b;
a = b;
b = r;
}
return r;
}
/******************************************SIEVE**********************************************************/
static void sieveMake(int n){
sieve=new boolean[n];
Arrays.fill(sieve,true);
sieve[0]=false;
sieve[1]=false;
for(int i=2;i*i<n;i++){
if(sieve[i]){
for(int j=i*i;j<n;j+=i){
sieve[j]=false;
}
}
}
primes=new ArrayList<Integer>();
for(int i=0;i<n;i++){
if(sieve[i]){
primes.add(i);
}
}
}
/********************************************End***********************************************************/
}
|
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but after the 999-th round `ABC999`, a problem occurred: how the future rounds should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Constraints
* 1 \leq N \leq 1998
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Examples
Input
999
Output
ABC
Input
1000
Output
ABD
Input
1481
Output
ABD
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int a;
a = scan.nextInt();
if(a <= 999)
System.out.println("ABC");
else
System.out.println("ABD");
}
}
|
You are given a string S consisting of lowercase English letters. Determine whether we can turn S into a palindrome by repeating the operation of swapping two adjacent characters. If it is possible, find the minimum required number of operations.
Constraints
* 1 \leq |S| \leq 2 × 10^5
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
Output
If we cannot turn S into a palindrome, print `-1`. Otherwise, print the minimum required number of operations.
Examples
Input
eel
Output
1
Input
ataatmma
Output
4
Input
snuke
Output
-1
|
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#define LL long long
using namespace std;
char s[200010];
int n,last[30],pos[200010],tr[200010],num[30];
void change(int k,int c) {for(int i=k;i<=n;i+=i&-i) tr[i]+=c;}
int get(int k) {int ans=0;for(int i=k;i>=1;i-=i&-i) ans+=tr[i];return ans;}
bool vis[200010];
int main()
{
scanf("%s",s+1);
n=strlen(s+1);
for(int i=1;i<=n;i++)
{
int c=s[i]-'a';num[c]++;
pos[i]=last[c];last[c]=i;
}
int tot=0;
for(int i=0;i<26;i++) tot+=(num[i]&1);
if(tot>1) return puts("-1"),0;
memset(vis,false,sizeof(vis));
LL ans=0;
for(int i=1;i<=n;i++) change(i,1);
for(int i=1;i<=n;i++) if(!vis[i])
{
int c=s[i]-'a';
int j=last[c];last[c]=pos[j];
if(i==j) continue;
ans+=get(i-1);ans+=(get(n)-get(j));
change(i,-1);change(j,-1);
vis[j]=true;
//printf("%d %d %d %lld\n",i,j,get(n),ans);
}
printf("%lld",ans);
}
|
We have a sequence of length N consisting of non-negative integers. Consider performing the following operation on this sequence until the largest element in this sequence becomes N-1 or smaller.
* Determine the largest element in the sequence (if there is more than one, choose one). Decrease the value of this element by N, and increase each of the other elements by 1.
It can be proved that the largest element in the sequence becomes N-1 or smaller after a finite number of operations.
You are given an integer K. Find an integer sequence a_i such that the number of times we will perform the above operation is exactly K. It can be shown that there is always such a sequence under the constraints on input and output in this problem.
Constraints
* 0 ≤ K ≤ 50 \times 10^{16}
Input
Input is given from Standard Input in the following format:
K
Output
Print a solution in the following format:
N
a_1 a_2 ... a_N
Here, 2 ≤ N ≤ 50 and 0 ≤ a_i ≤ 10^{16} + 1000 must hold.
Examples
Input
0
Output
4
3 3 3 3
Input
1
Output
3
1 0 3
Input
2
Output
2
2 2
Input
3
Output
7
27 0 0 0 0 0 0
Input
1234567894848
Output
10
1000 193 256 777 0 1 1192 1234567891011 48 425
|
#include<iostream>
using namespace std;
int main(){
int i,l;
long long m,K,a[50];
cin >> K;
l = K%50;
m = K/50;
cout << 50 << endl;
if(K<=50){
for(i=0;i<K;i++){
a[i] = 50;
}
for(i=K;i<50;i++){
a[i] = 0;
}
}else{
for(i=0;i<l;i++){
a[i] = m+50;
}
for(i=l;i<50;i++){
a[i] = 49 - l + m ;
}
}
for(i=0;i<50;i++){
cout << a[i] << " " ;
}
cout << endl;
}
|
You are given an image A composed of N rows and N columns of pixels, and a template image B composed of M rows and M columns of pixels.
A pixel is the smallest element of an image, and in this problem it is a square of size 1×1.
Also, the given images are binary images, and the color of each pixel is either white or black.
In the input, every pixel is represented by a character: `.` corresponds to a white pixel, and `#` corresponds to a black pixel.
The image A is given as N strings A_1,...,A_N.
The j-th character in the string A_i corresponds to the pixel at the i-th row and j-th column of the image A (1≦i,j≦N).
Similarly, the template image B is given as M strings B_1,...,B_M.
The j-th character in the string B_i corresponds to the pixel at the i-th row and j-th column of the template image B (1≦i,j≦M).
Determine whether the template image B is contained in the image A when only parallel shifts can be applied to the images.
Constraints
* 1≦M≦N≦50
* A_i is a string of length N consisting of `#` and `.`.
* B_i is a string of length M consisting of `#` and `.`.
Input
The input is given from Standard Input in the following format:
N M
A_1
A_2
:
A_N
B_1
B_2
:
B_M
Output
Print `Yes` if the template image B is contained in the image A. Print `No` otherwise.
Examples
Input
3 2
#.#
.#.
#.#
#.
.#
Output
Yes
Input
3 2
.#
.#.
.#
.
.#
Output
Yes
Input
4 1
....
....
....
....
Output
No
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair <double,double> P;
int main() {
int n,m;
cin>>n>>m;
string a[55],b[55];
rep(i,n) cin>>a[i];
rep(i,m) cin>>b[i];
rep(i,n) {
rep(j,n) {
if (i+m-1>n-1) continue;
if (j+m-1>n-1) continue;
bool flag=true;
rep(k,m) {
if (a[i+k].substr(j,m)!=b[k].substr(0,m))
flag=false;
}
if (flag) {
puts("Yes");
return 0;
}
}
}
puts("No");
return 0;
}
|
On an xy plane, in an area satisfying 0 ≤ x ≤ W, 0 ≤ y ≤ H, there is one house at each and every point where both x and y are integers.
There are unpaved roads between every pair of points for which either the x coordinates are equal and the difference between the y coordinates is 1, or the y coordinates are equal and the difference between the x coordinates is 1.
The cost of paving a road between houses on coordinates (i,j) and (i+1,j) is p_i for any value of j, while the cost of paving a road between houses on coordinates (i,j) and (i,j+1) is q_j for any value of i.
Mr. Takahashi wants to pave some of these roads and be able to travel between any two houses on paved roads only. Find the solution with the minimum total cost.
Constraints
* 1 ≦ W,H ≦ 10^5
* 1 ≦ p_i ≦ 10^8(0 ≦ i ≦ W-1)
* 1 ≦ q_j ≦ 10^8(0 ≦ j ≦ H-1)
* p_i (0 ≦ i ≦ W−1) is an integer.
* q_j (0 ≦ j ≦ H−1) is an integer.
Input
Inputs are provided from Standard Input in the following form.
W H
p_0
:
p_{W-1}
q_0
:
q_{H-1}
Output
Output an integer representing the minimum total cost.
Examples
Input
2 2
3
5
2
7
Output
29
Input
4 3
2
4
8
1
2
9
3
Output
60
|
#!/usr/bin/env python3
import sys
try: from typing import Any, Union, List, Tuple, Dict
except ImportError: pass
sys.setrecursionlimit(10**6)
def debug(*args): print(*args, file=sys.stderr)
def exit(): sys.exit(0)
W, H = map(int, input().split())
p = []
for i in range(W):
p.append(int(input()))
q = []
for j in range(H):
q.append(int(input()))
a = []
for i in range(W):
a.append(("p", i, p[i]))
for j in range(H):
a.append(("q", j, q[j]))
a.sort(key=lambda x: x[2])
p_used = 0
q_used = 0
count = 0
cost = 0
i = 0
while True:
now = a[i]
if now[0] == "p":
now_count = H+1 - q_used
if count + now_count > (W+1)*(H+1) - 1:
now_count = (W+1)*(H+1) - 1 - count
count += now_count
cost += now[2] * now_count
p_used += 1
else:
now_count = W+1 - p_used
if count + now_count > (W+1)*(H+1) - 1:
now_count = (W+1)*(H+1) - 1 - count
count += now_count
cost += now[2] * now_count
q_used += 1
if count == (W+1)*(H+1) - 1:
break
i += 1
debug(count)
print(cost)
|
The time is 2020. There is data that saves the qualifying results of PC Koshien 2020. This data stores the reference number and the number of correct answers assigned to each team. Here, the ranking is determined by the number of correct answers, and the ranking is given in descending order of the number of correct answers, such as 1st, 2nd, and so on.
Enter the qualifying result data and reference number from the keyboard, and create a program that outputs the ranking of the team with that number.
Note
In the data of the input example, if the teams are arranged in order of the number of correct answers:
3,30
1,20
2,20
6,20
4,10
5,10
It will be. Here, in order to determine the ranking based on the number of correct answers, the 30-question correct answer team is ranked 1st, the 20-question correct answer team is ranked 2nd, and the 10-question correct answer team is ranked 3rd. Please note that this is different from the usual ranking with the correct team in 5th place).
Input
The input data consists of two parts. The first half is the qualifying result data, and the second half is the inquiry of the team number for which you want to know the ranking. The format of the qualifying result data is as follows.
p1, s1
p2, s2
...
...
0,0
pi (1 ≤ pi ≤ 100) and si (0 ≤ si ≤ 30) are integers representing the reference number and the number of correct answers for the i-th team, respectively. It is assumed that the input of this data is completed when both the reference number and the number of correct answers are 0.
Then multiple inquiries in the second half are given. The inquiry format is as follows.
q1
q2
::
Each query is given the reference number qi (1 ≤ qi ≤ 30) on one line. Please process this until the end of the input. The number of inquiries does not exceed 100.
Output
For each inquiry, print the team ranking on one line.
Example
Input
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
Output
2
2
3
3
|
def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
teams = [0 for i in range(101)]
points = [False for i in range(31)]
while True:
a,b = [int(i) for i in input().split(",")]
if a == 0 and b == 0:
break
teams[a] = b
points[b] = True
N = list(get_input())
for l in range(len(N)):
q = int(N[l])
p = teams[q]
ans = 0
for i in range(30,-1,-1):
if points[i]:
ans += 1
if i == p:
break
print(ans)
|
There are various parking lots such as three-dimensional type and tower type in the city to improve the utilization efficiency of the parking lot. In some parking lots, a "two-stage parking device" as shown in the figure is installed in one parking space to secure a parking space for two cars. This two-stage parking device allows one to be placed on an elevating pallet (a flat iron plate on which a car is placed) and parked in the upper tier, and the other to be parked in the lower tier.
In a parking lot that uses such a two-stage parking device, it is necessary to take out the car parked in the lower tier and dismiss it each time to put in and out the car in the upper tier, so be sure to manage it. Keeps the key to the parked car and puts it in and out as needed.
| <image>
--- | ---
Tsuruga Parking Lot is also one of the parking lots equipped with such a two-stage parking device, but due to lack of manpower, the person who cannot drive the car has become the manager. Therefore, once the car was parked, it could not be moved until the customer returned, and the car in the upper tier could not be put out until the owner of the car in the lower tier returned.
Create a program that meets the rules of the Tsuruga parking lot to help the caretaker who has to handle the cars that come to park one after another.
Tsuruga parking lot facilities
* There is one or more parking spaces, all equipped with a two-stage parking device.
* Each parking space is numbered starting from 1.
* Initially, it is assumed that no car is parked in the parking lot.
Tsuruga parking lot adopts the following rules.
When to stop the car
* The caretaker will be informed of the parking time of the car to be parked.
* We will park first in the parking space where no car is parked.
* If there is no parking space where no car is parked, park in an empty parking space. However, if there are multiple such parking spaces, follow the procedure below to park.
1. If the remaining parking time of a parked car is longer than the parking time of the car you are trying to park, park in the parking space with the smallest difference.
2. If the remaining parking time of any parked car is less than the parking time of the car you are trying to park, park in the parking space with the smallest difference.
* If the car is full (no parking space available), the car you are trying to park will wait in turn until the parking space is available. As soon as it becomes available, we will park in order from the first car we were waiting for.
* Under each condition, if there are multiple applicable parking spaces, the parking space number will be the smallest. In addition, if there are cars leaving at the same time, parking will start after all the cars leaving at the same time, and as long as there are cars waiting, the cars that can be parked will be parked at the same time.
When the car leaves
* Cars that have passed the parking time notified by the manager will be shipped.
* If there are cars in multiple parking spaces that have passed the parking time at the same time, the car with the smallest parking space number will be shipped first.
* If the parking time of the car parked in the upper row has expired, you will have to wait until the car in the lower row leaves the garage. The upper car will be delivered at the same time after the lower car is delivered.
The figure below shows an example of how to park at Tsuruga Parking Lot. In this example, the number of parking spaces is 3, and cars B to E are already parked. Consider that car A, which has a parking time of 70 minutes, arrives there. You cannot park because two cars are already parked in parking space 3, and you will have to park in either parking space 1 or parking space 2 that is still vacant. Car B parked in parking space 1 has 50 minutes remaining and car C parked in parking space 2 has 22 minutes remaining, both of which are less than car A's parking time, so car A's parking Park in parking space 1 where car B, which has a smaller time difference, is parked. As a result, car B, which was parked earlier, will be in the upper row.
<image>
Create a program that inputs the number of parking spaces m, the number of cars parked n, and the parking time t of each car, and outputs the car reference numbers in the order in which they come out of the parking lot. However, cars are assigned an integer reference number starting with 1 in the order of input, and cars will come to park one by one every 10 minutes in the order of the reference number.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
m n
t1
t2
::
tn
The first line gives the number of two-stage parking devices m (1 ≤ m ≤ 10) and the number of cars parked n (1 ≤ n ≤ 100). The next n lines are given the parking time ti (1 ≤ ti ≤ 120) for the i-th car.
The number of datasets does not exceed 20.
Output
The reference number of the car is output to one line in the order of coming out of the parking lot for each data set. Please output the reference numbers separated by blanks.
Example
Input
3 5
90
52
82
84
70
2 4
10
30
40
60
0 0
Output
2 5 1 4 3
1 2 4 3
|
#include <cstdio>
#include <vector>
#include <queue>
#include <algorithm>
#include <cstring>
#include <functional>
using namespace std;
struct data{
int t,id,id_park,type;
data(){}
data(int tt,int ii,int dd,int ttt){
t=tt;
id=ii;
id_park=dd;
type=ttt;
}
bool operator<(const data &d1)const{
if(t==d1.t){
if(type!=d1.type)return type<d1.type;
if(type==0)return id>d1.id;
return id_park>d1.id_park;
}
return t>d1.t;
}
};
int m,n;
int t[120];
int res[120];
int park[11][2];
data park_car(data x){
data res=x;
res.type=-1;
res.t+=t[x.id];
for(int i=0;i<m;i++){
if(park[i][1]==-1){
res.id_park=i*2+1;
res.type=1;
return res;
}
}
int id=-1;
for(int i=0;i<m;i++){
if(park[i][0]==-1){
if(park[i][1]>=res.t){
if(id==-1)id=i;
else if(park[id][1]>park[i][1])id=i;
}
}
}
if(id!=-1){
res.id_park=id*2;
res.type=1;
return res;
}
for(int i=0;i<m;i++){
if(park[i][0]==-1){
if(id==-1)id=i;
else if(park[id][1]<park[i][1])id=i;
}
}
if(id!=-1){
res.id_park=id*2;
res.type=1;
}
return res;
}
int main(void){
while(1){
scanf("%d%d",&m,&n);
if(m+n==0)break;
priority_queue<data> que;
for(int i=0;i<n;i++){
scanf("%d",&t[i]);
que.push(data(i*10,i,-1,0));
}
memset(park,-1,sizeof(park));
int cnt=0;
while(que.size()){
data q=que.top();
que.pop();
if(q.type==0){
data next=park_car(q);
if(next.type==-1){
q.t++;
que.push(q);
}else{
park[next.id_park/2][next.id_park%2]=next.t;
que.push(next);
}
}else{
if(q.id_park%2==1 && park[q.id_park/2][0]!=-1){
q.t++;
que.push(q);
}else{
res[cnt++]=q.id;
park[q.id_park/2][q.id_park%2]=-1;
}
}
}
for(int i=0;i<n;i++){
printf("%d%c",res[i]+1,i==n-1?'\n':' ');
}
}
return 0;
}
|
Nobuo-kun and Shizuo-kun are playing a game of competing for territories on a rectangular island. As shown in Fig. 1 below, the entire island is made up of square compartments divided in a grid pattern, and the profits and losses resulting from these are indicated by integers.
<image>
In this game, move one piece to determine the boundaries of the territory. At the beginning of the game, the piece is at the northwestern end of the island (Fig. ①). The trajectory of the piece when moving this piece to the southeastern end of the island becomes the boundary of the territory. The two players move the pieces alternately. Pieces can only be moved to the grid point next to the south or the grid point next to the east (Fig. 2). When the piece reaches the edge of the island, move it in the south or east direction. The game is over when the piece reaches the southeastern end.
The area on the northeast side of the boundary after the game is the area of the first player, and the area on the southwest side is the area of the second player (Fig. ③). The sum of the profits and losses generated from the parcels contained within each player's territory is that player's core. Both of them are quite accustomed to the game and move the pieces accurately so that the value obtained by subtracting the opponent's score from their own score is the largest in the end.
Create a program that calculates the outcome at the end of the game given the size of the island and the gains and losses that result from each parcel. The result is the absolute value of the difference between the scores of Nobuo-kun and Shizuo-kun.
Input
The input is given in the following format.
W H
s1,1 s1,2 ... s1, W
s2,1 s2,2 ... s2, W
::
sH, 1 sH, 2 ... sH, W
The first line gives the number of east-west and north-south sections contained in the island W, H (1 ≤ W, H ≤ 1000). The following row H is given the gains and losses si, j (-1000 ≤ si, j ≤ 1000) that arise from the compartments in row i and column j. However, the direction in which the value of i increases is south, and the direction in which the value of j increases is east.
Output
The absolute value of the difference between the scores of Nobuo-kun and Shizuo-kun is output in one line.
Examples
Input
2 1
-2 1
Output
1
Input
2 2
2 -3
3 -1
Output
3
Input
5 4
5 3 2 -5 2
2 -4 2 8 -4
2 3 -7 6 7
3 -4 10 -3 -3
Output
5
|
#include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = a; i <= (int) b; ++i)
#define ii pair <int, int>
using namespace std;
const int N = 1e3 + 3;
int m, n, a[N][N], f[N][N][2], vis[N][N][2];
void init() {
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
//freopen("main.inp","r",stdin);
//freopen("main.out","w",stdout);
}
int get(int xo, int yo, int xi, int yi) {
return a[xi][yi] + a[xo - 1][yo - 1] - a[xi][yo - 1] - a[xo - 1][yi];
}
int dp(int i, int j, int id) {
int &shc = f[i][j][id], &foo = vis[i][j][id];
if (foo) return shc;
if (i == m || j == n) return shc = 0;
shc = INT_MIN; foo = 1;
if (id == 0) {
if (i < m && j < n) {
shc = max(shc, get(i + 1, j + 1, i + 1, n) - dp(i + 1, j, 1));
shc = max(shc, - get(i + 1, j + 1, m, j + 1) - dp(i, j + 1, 1));
}
}
else {
if (i < m && j < n) {
shc = max(shc, - get(i + 1, j + 1, i + 1, n) - dp(i + 1, j, 0));
shc = max(shc, get(i + 1, j + 1, m, j + 1) - dp(i, j + 1, 0));
}
}
return shc;
}
void solve() {
cin >> n >> m;
FOR(i, 1, m) FOR(j, 1, n) {
int x; cin >> x;
a[i][j] = a[i][j - 1] + a[i - 1][j] - a[i - 1][j - 1] + x;
}
cout << abs(dp(0, 0, 0)) << '\n';
}
int main() {
init(); solve();
}
|
problem
N students from JOI High School are lined up in a row from east to west. The i-th student from the western end of the column is student i. Each student has a bib with one integer. Initially, the integer Ai is written on the number of student i.
There are M batons, and the batons are numbered from 1 to M. For k = 1, 2, ..., M, perform the following operations. The operation related to baton k (2 ≤ k ≤ M) is performed after the operation related to baton k -1 is completed.
1. The teacher gives the baton k to student 1.
2. Students who receive the baton pass the baton according to the following rules.
* Rule: Suppose student i receives the baton k.
* 1 ≤ i ≤ N-1: When the remainder of the integer of the number of student i divided by k is greater than the remainder of the integer of the number of student i + 1 divided by k, student i and student i + 1 exchanges the number, and student i passes the baton to student i + 1. Otherwise, student i passes the baton to student i + 1 without changing the bib.
* When i = N: Student N passes the baton to the teacher.
3. When the teacher receives the baton k from student N, the operation related to the baton k is finished.
Given the integer and the number of batons M that were originally written in the student number, write a program to find the integer of each student's number after the teacher receives the baton M from student N.
input
The input consists of 1 + N lines.
The integers N and M (1 ≤ N ≤ 100, 1 ≤ M ≤ 100) are written on the first line, separated by blanks, and represent the number of students and the number of batons, respectively.
The integer Ai (1 ≤ Ai ≤ 1000) is written on the i-th line (1 ≤ i ≤ N) of the following N lines, and represents the integer Ai first written on the number of student i.
output
The output consists of N lines. On line i (1 ≤ i ≤ N), output the integer of the number of student i after the teacher receives the baton M from student N.
Input / output example
Input example 1
6 4
3
2
8
3
1
Five
Output example 1
2
3
1
8
Five
3
Input example 2
10 6
1
2
3
Four
Five
6
7
8
9
Ten
Output example 2
6
1
2
3
Ten
Four
8
7
9
Five
Input / output example 1 has 6 students. Initially, the student numbers are 3, 2, 8, 3, 1, and 5, in that order. There are four batons.
* At the end of the operation related to baton 1, the student numbers are 3, 2, 8, 3, 1, and 5, respectively.
* At the end of the operation related to baton 2, the student numbers are 2, 8, 3, 3, 1, and 5, respectively.
* At the end of the operation related to baton 3, the student numbers are 2, 3, 3, 1, 8, and 5, respectively.
* At the end of the operation related to baton 4, the student numbers are 2, 3, 1, 8, 5, and 3 in order.
Creative Commons License
Information Olympics Japan Committee work "15th Japan Information Olympics JOI 2015/2016 Qualifying Competition Tasks"
Example
Input
6 4
3
2
8
3
1
5
Output
2
3
1
8
5
3
|
#include<iostream>
#include<string>
#include<algorithm>
#include<cmath>
using namespace std;
int main(void) {
int n, m, a; cin >> n >> m;
int test[101] = { 0 };
for (int h = 0; h < n; h++) {
cin >> a;
test[h] = a;
}
for (int h = 1; h <= m; h++) {
for (int i = 0; i < n; i++) {
if (i != n - 1 && test[i] % h > test[i + 1] % h) {
int uio = test[i];
test[i] = test[i + 1];
test[i + 1] = uio;
}
}
}
for (int h = 0; h < n; h++) {
cout << test[h] << endl;
}
}
|
Your job is to find out the secret number hidden in a matrix, each of whose element is a digit ('0'-'9') or a letter ('A'-'Z'). You can see an example matrix in Figure 1.
<image>
Figure 1: A Matrix
The secret number and other non-secret ones are coded in a matrix as sequences of digits in a decimal format. You should only consider sequences of digits D1 D2 ... Dn such that Dk+1 (1 <= k < n) is either right next to or immediately below Dk in the matrix. The secret you are seeking is the largest number coded in this manner.
Four coded numbers in the matrix in Figure 1, i.e., 908820, 23140037, 23900037, and 9930, are depicted in Figure 2. As you may see, in general, two or more coded numbers may share a common subsequence. In this case, the secret number is 23900037, which is the largest among the set of all coded numbers in the matrix.
<image>
Figure 2: Coded Numbers
In contrast, the sequences illustrated in Figure 3 should be excluded: 908A2 includes a letter; the fifth digit of 23149930 is above the fourth; the third digit of 90037 is below right of the second.
<image>
Figure 3: Inappropriate Sequences
Write a program to figure out the secret number from a given matrix.
Input
The input consists of multiple data sets, each data set representing a matrix. The format of each data set is as follows.
> W H
> C11C12 ... C1W
> C21C22 ... C2W
> ...
> CH1CH2 ... CHW
>
In the first line of a data set, two positive integers W and H are given. W indicates the width (the number of columns) of the matrix, and H indicates the height (the number of rows) of the matrix. W+H is less than or equal to 70.
H lines follow the first line, each of which corresponds to a row of the matrix in top to bottom order. The i-th row consists of W characters Ci1Ci2 ... CiW in left to right order. You may assume that the matrix includes at least one non-zero digit.
Following the last data set, two zeros in a line indicate the end of the input.
Output
For each data set, print the secret number on a line. Leading zeros should be suppressed.
Example
Input
7 4
9R2A993
0E314A0
8A900DE
820R037
6 7
JH03HE
ID7722
0DA1AH
30C9G5
99971A
CA7EAI
AHLBEM
20 2
A1234567891234CBDEGH
BDEDF908034265091499
0 0
Output
23900037
771971
12345908034265091499
|
#include "bits/stdc++.h"
using namespace std;
inline int comp(string& s, string &t)
{
if (s.size() < t.size()) return 1;
if (s.size() > t.size()) return 0;
for (int i = 0; i < s.size(); i++)
{
if (s[i] < t[i]) return 1;
if (s[i] > t[i]) return 0;
}
return 0;
}
void solve(void)
{
int w, h;
while(cin >> w >> h)
{
if (!w && !h) break;
vector<string> g(h), dp(w);
for (string& s : g) cin >> s;
string ans = "";
for (int i = 0; i < h; i++)
{
vector<string> nx(w);
for (int j = 0; j < w; j++)
{
if ('0' > g[i][j] || '9' < g[i][j])
continue;
string s = "", t = "";
if (i)
s = dp[j];
if (j)
t = nx[j - 1];
if (s.empty() && t.empty() && g[i][j] == '0') continue;
nx[j] = (comp(s, t) ? t : s) + g[i][j];
if (comp(ans, nx[j]))
ans = nx[j];
}
swap(dp, nx);
}
bool f = 1;
for (char c : ans)
{
if (c == '0' && f) continue;
cout << c;
f = 0;
}
if (f) cout << 0;
cout << '\n';
}
}
int main()
{
solve();
//cout << "yui(*-v・)yui" << endl;
return 0;
}
|
After counting so many stars in the sky in his childhood, Isaac, now an astronomer and a mathematician, uses a big astronomical telescope and lets his image processing program count stars. The hardest part of the program is to judge if a shining object in the sky is really a star. As a mathematician, the only way he knows is to apply a mathematical definition of stars.
The mathematical defiition of a star shape is as follows: A planar shape F is star-shaped if and only if there is a point C ∈ F such that, for any point P ∈ F, the line segment CP is contained in F. Such a point C is called a center of F. To get accustomed to the definition, let's see some examples below.
<image>
Figure 2: Star shapes (the first row) and non-star shapes (the second row)
The firrst two are what you would normally call stars. According to the above definition, however, all shapes in the first row are star-shaped. The two in the second row are not. For each star shape, a center is indicated with a dot. Note that a star shape in general has infinitely many centers. For example, for the third quadrangular shape, all points in it are centers.
Your job is to write a program that tells whether a given polygonal shape is star-shaped or not.
Input
The input is a sequence of datasets followed by a line containing a single zero. Each dataset specifies a polygon, and is formatted as follows.
n
x1 y1
x2 y2
...
xn yn
The first line is the number of vertices, n, which satisfies 4 ≤ n ≤ 50. Subsequent n lines are the x- and y-coordinates of the n vertices. They are integers and satisfy 0 ≤ xi ≤ 10000 and 0 ≤ yi ≤ 10000 (i = 1, ..., n). Line segments (xi, yi)-(xi+1, yi+1) (i = 1, ..., n - 1) and the line segment (xn, yn)-(x1, y1) form the border of the polygon in the counterclockwise order. That is, these line segments see the inside of the polygon in the left of their directions.
You may assume that the polygon is simple, that is, its border never crosses or touches itself. You may also assume that no three edges of the polygon meet at a single point even when they are infinitely extended.
Output
For each dataset, output "1" if the polygon is star-shaped and "0" otherwise. Each number must be in a separate line and the line should not contain any other characters.
Example
Input
6
66 13
96 61
76 98
13 94
4 0
45 68
8
27 21
55 14
93 12
56 95
15 48
38 46
51 65
64 31
0
Output
1
0
|
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <stack>
#include <utility>
#include <complex>
#include <vector>
#define loop(i,a,b) for(int i=(a);i<int(b);i++)
#define rep(i,b) loop(i,0,b)
using namespace std;
const double EPS = 1e-8;
const double INF = 1e12;
typedef complex<double> P;
namespace std {
bool operator < (const P& a, const P& b) {
return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
}
}
double cross(const P& a, const P& b) {
return imag(conj(a)*b);
}
double dot(const P& a, const P& b) {
return real(conj(a)*b);
}
struct L : public vector<P> {
L(const P &a, const P &b) {
push_back(a); push_back(b);
}
};
typedef vector<P> G;
struct C {
P p; double r;
C(const P &p, double r) : p(p), r(r) { }
};
int ccw(P a, P b, P c) {
b -= a; c -= a;
if (cross(b, c) > 0) return +1; // counter clockwise
if (cross(b, c) < 0) return -1; // clockwise
if (dot(b, c) < 0) return +2; // c--a--b on line
if (norm(b) < norm(c)) return -2; // a--b--c on line
return 0;
}
bool intersectLL(const L &l, const L &m) {
return abs(cross(l[1]-l[0], m[1]-m[0])) > EPS || // non-parallel
abs(cross(l[1]-l[0], m[0]-l[0])) < EPS; // same line
}
bool intersectLS(const L &l, const L &s) {
return cross(l[1]-l[0], s[0]-l[0])* // s[0] is left of l
cross(l[1]-l[0], s[1]-l[0]) < EPS; // s[1] is right of l
}
bool intersectLP(const L &l, const P &p) {
return abs(cross(l[1]-p, l[0]-p)) < EPS;
}
bool intersectSS(const L &s, const L &t) {
return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
}
bool intersectSP(const L &s, const P &p) {
return abs(s[0]-p)+abs(s[1]-p)-abs(s[1]-s[0]) < EPS; // triangle inequality
}
P projection(const L &l, const P &p) {
double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
return l[0] + t*(l[0]-l[1]);
}
P reflection(const L &l, const P &p) {
return p + 2. * (projection(l, p) - p);
}
double distanceLP(const L &l, const P &p) {
return abs(p - projection(l, p));
}
double distanceLL(const L &l, const L &m) {
return intersectLL(l, m) ? 0 : distanceLP(l, m[0]);
}
double distanceLS(const L &l, const L &s) {
if (intersectLS(l, s)) return 0;
return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
double distanceSP(const L &s, const P &p) {
const P r = projection(s, p);
if (intersectSP(s, r)) return abs(r - p);
return min(abs(s[0] - p), abs(s[1] - p));
}
double distanceSS(const L &s, const L &t) {
if (intersectSS(s, t)) return 0;
return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
P crosspoint(const L &l, const L &m) {
double A = cross(l[1] - l[0], m[1] - m[0]);
double B = cross(l[1] - l[0], l[1] - m[0]);
if (abs(A) < EPS && abs(B) < EPS) return m[0]; // same line
if (abs(A) < EPS) throw;
return m[0] + B / A * (m[1] - m[0]);
}
#define curr(P, i) P[i]
#define next(P, i) P[(i+1)%P.size()]
G convex_cut(const G& Pol, const L& l) {
G Q;
for (int i = 0; i < Pol.size(); ++i) {
P A = curr(Pol, i), B = next(Pol, i);
if (ccw(l[0], l[1], A) != -1) Q.push_back(A);
if (ccw(l[0], l[1], A)*ccw(l[0], l[1], B) < 0)
Q.push_back(crosspoint(L(A, B), l));
}
return Q;
}
int main(){
int n;
while(cin>>n && n){
G pol(n);
rep(i,n){
double x,y;
cin>>x>>y;
pol[i]=P(x,y);
}
G cand(4);
rep(i,4){
cand[i]=polar(INF,acos(-1)/2*i);
}
rep(i,n){
L l(pol[i],pol[(i+1)%n]);
cand = convex_cut(cand,l);
}
cout << min<int>(cand.size(),1) << endl;
}
}
|
Sixth Sense
Ms. Future is gifted with precognition. Naturally, she is excellent at some card games since she can correctly foresee every player's actions, except her own. Today, she accepted a challenge from a reckless gambler Mr. Past. They agreed to play a simple two-player trick-taking card game.
Cards for the game have a number printed on one side, leaving the other side blank making indistinguishable from other cards.
A game starts with the same number, say $n$, of cards being handed out to both players, without revealing the printed number to the opponent.
A game consists of $n$ tricks. In each trick, both players pull one card out of her/his hand. The player pulling out the card with the larger number takes this trick. Because Ms. Future is extremely good at this game, they have agreed to give tricks to Mr. Past when both pull out cards with the same number. Once a card is used, it can never be used later in the same game. The game continues until all the cards in the hands are used up. The objective of the game is to take as many tricks as possible.
Your mission of this problem is to help Ms. Future by providing a computer program to determine the best playing order of the cards in her hand. Since she has the sixth sense, your program can utilize information that is not available to ordinary people before the game.
Input
The input consists of a single test case of the following format.
$n$
$p_1$ ... $p_n$
$f_1$ ... $f_n$
$n$ in the first line is the number of tricks, which is an integer between 2 and 5000, inclusive. The second line represents the Mr. Past's playing order of the cards in his hand. In the $i$-th trick, he will pull out a card with the number $p_i$ ($1 \leq i \leq n$). The third line represents the Ms. Future's hand. $f_i$ ($1 \leq i \leq n$) is the number that she will see on the $i$-th received card from the dealer. Every number in the second or third line is an integer between 1 and 10 000, inclusive. These lines may have duplicate numbers.
Output
The output should be a single line containing $n$ integers $a_1 ... a_n$ separated by a space, where $a_i$ ($1 \leq i \leq n$) is the number on the card she should play at the $i$-th trick for maximizing the number of taken tricks. If there are two or more such sequences of numbers, output the lexicographically greatest one among them.
Sample Input 1
5
1 2 3 4 5
1 2 3 4 5
Sample Output 1
2 3 4 5 1
Sample Input 2
5
3 4 5 6 7
1 3 5 7 9
Sample Output 2
9 5 7 3 1
Sample Input 3
5
3 2 2 1 1
1 1 2 2 3
Sample Output 3
1 3 1 2 2
Sample Input 4
5
3 4 10 4 9
2 7 3 6 9
Sample Output 4
9 7 3 6 2
Example
Input
5
1 2 3 4 5
1 2 3 4 5
Output
2 3 4 5 1
|
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define NUM 10005
int N;
int P[5005],F[5005];
vector<int> V;
int P_table[NUM],F_table[NUM];
int P_TMP[NUM],F_TMP[NUM];
int calc(){
for(int i = 0; i < NUM; i++){
P_TMP[i] = P_table[i];
F_TMP[i] = F_table[i];
}
int P_num = 1,F_num = 2;
int ret = 0;
while(true){
while(P_num < NUM && P_TMP[P_num] == 0)P_num++;
while(F_num < NUM && (P_num >= F_num || F_TMP[F_num] == 0))F_num++;
if(F_num == NUM)break;
while(F_TMP[F_num] > 0 && P_TMP[P_num] > 0){
F_TMP[F_num]--;
P_TMP[P_num]--;
ret++;
}
}
return ret;
}
int main(){
for(int i = 0; i < NUM; i++){
P_table[i] = 0;
F_table[i] = 0;
}
scanf("%d",&N);
for(int i = 0; i < N; i++){
scanf("%d",&P[i]);
P_table[P[i]] += 1;
}
for(int i = 0; i < N; i++){
scanf("%d",&F[i]);
F_table[F[i]] += 1;
V.push_back(F[i]);
}
int max_num = calc();
sort(V.begin(),V.end());
queue<int> ANS;
int num_larger = 0;
int left,right,mid,this_value,tmp_larger,index;
for(int i = 0; i < N; i++){
this_value = -1;
left = 0,right = V.size()-1,mid = (left+right)/2;
while(left <= right){
F_table[V[mid]] -= 1;
P_table[P[i]] -= 1;
tmp_larger = calc();
F_table[V[mid]] += 1;
P_table[P[i]] += 1;
if(V[mid] <= P[i]){
if(num_larger+tmp_larger == max_num){
this_value = V[mid];
index = mid;
left = mid+1;
}else{
if(V[V.size()-1] <= P[i]){
right = mid-1;
}else{
left = mid+1;
}
}
}else{
if(num_larger+tmp_larger+1 == max_num){
this_value = V[mid];
index = mid;
left = mid+1;
}else{
right = mid-1;
}
}
mid = (left+right)/2;
}
ANS.push(this_value);
if(this_value > P[i]){
num_larger++;
}
F_table[this_value] -= 1;
P_table[P[i]] -= 1;
V.erase(V.begin()+index);
}
printf("%d",ANS.front());
ANS.pop();
while(!ANS.empty()){
printf(" %d",ANS.front());
ANS.pop();
}
printf("\n");
return 0;
}
|
Origami, or the art of folding paper
Master Grus is a famous origami (paper folding) artist, who is enthusiastic about exploring the possibility of origami art. For future creation, he is now planning fundamental experiments to establish the general theory of origami.
One rectangular piece of paper is used in each of his experiments. He folds it horizontally and/or vertically several times and then punches through holes in the folded paper.
The following figure illustrates the folding process of a simple experiment, which corresponds to the third dataset of the Sample Input below. Folding the 10 × 8 rectangular piece of paper shown at top left three times results in the 6 × 6 square shape shown at bottom left. In the figure, dashed lines indicate the locations to fold the paper and round arrows indicate the directions of folding. Grid lines are shown as solid lines to tell the sizes of rectangular shapes and the exact locations of folding. Color densities represent the numbers of overlapping layers. Punching through holes at A and B in the folded paper makes nine holes in the paper, eight at A and another at B.
<image>
Your mission in this problem is to write a computer program to count the number of holes in the paper, given the information on a rectangular piece of paper and folding and punching instructions.
Input
The input consists of at most 1000 datasets, each in the following format.
> n m t p
> d1 c1
> ...
> dt ct
> x1 y1
> ...
> xp yp
>
n and m are the width and the height, respectively, of a rectangular piece of paper. They are positive integers at most 32. t and p are the numbers of folding and punching instructions, respectively. They are positive integers at most 20. The pair of di and ci gives the i-th folding instruction as follows:
* di is either 1 or 2.
* ci is a positive integer.
* If di is 1, the left-hand side of the vertical folding line that passes at ci right to the left boundary is folded onto the right-hand side.
* If di is 2, the lower side of the horizontal folding line that passes at ci above the lower boundary is folded onto the upper side.
After performing the first i−1 folding instructions, if di is 1, the width of the shape is greater than ci. Otherwise the height is greater than ci. (xi + 1/2, yi + 1/2) gives the coordinates of the point where the i-th punching instruction is performed. The origin (0, 0) is at the bottom left of the finally obtained shape. xi and yi are both non-negative integers and they are less than the width and the height, respectively, of the shape. You can assume that no two punching instructions punch holes at the same location.
The end of the input is indicated by a line containing four zeros.
Output
For each dataset, output p lines, the i-th of which contains the number of holes punched in the paper by the i-th punching instruction.
Sample Input
2 1 1 1
1 1
0 0
1 3 2 1
2 1
2 1
0 0
10 8 3 2
2 2
1 3
1 1
0 1
3 4
3 3 3 2
1 2
2 1
1 1
0 1
0 0
0 0 0 0
Output for the Sample Input
2
3
8
1
3
6
Example
Input
2 1 1 1
1 1
0 0
1 3 2 1
2 1
2 1
0 0
10 8 3 2
2 2
1 3
1 1
0 1
3 4
3 3 3 2
1 2
2 1
1 1
0 1
0 0
0 0 0 0
Output
2
3
8
1
3
6
|
#include <iostream>
#include <string>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <unordered_map>
#include <map>
#include <set>
#include <algorithm>
#include <queue>
#include <stack>
#include <functional>
#include <bitset>
#include <assert.h>
#include <unordered_map>
#include <fstream>
#include <ctime>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef pair<ll,ll> P;
typedef pair<int,int> pii;
typedef vector<P> vpl;
typedef tuple<ll,ll,ll> tapu;
#define rep(i,n) for(int i=0; i<(n); i++)
#define REP(i,a,b) for(int i=(a); i<(b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int inf = 1<<30;
const ll linf = 1LL<<62;
const int MAX = 510000;
ll dy[8] = {1,-1,0,0,1,-1,1,-1};
ll dx[8] = {0,0,1,-1,1,-1,-1,1};
const double pi = acos(-1);
const double eps = 1e-7;
template<typename T1,typename T2> inline bool chmin(T1 &a,T2 b){
if(a>b){
a = b; return true;
}
else return false;
}
template<typename T1,typename T2> inline bool chmax(T1 &a,T2 b){
if(a<b){
a = b; return true;
}
else return false;
}
template<typename T> inline void print(T &a){
rep(i,a.size()) cout << a[i] << " ";
cout << "\n";
}
template<typename T1,typename T2> inline void print2(T1 a, T2 b){cout << a << " " << b << "\n";}
template<typename T1,typename T2,typename T3> inline void print3(T1 a, T2 b, T3 c){
cout << a << " " << b << " " << c << "\n";
}
ll pcount(ll x) {return __builtin_popcountll(x);}
const int mod = 1e9 + 7;
//const int mod = 998244353;
int a[800][800];
int main(){
while(1){
ll w,h,t,p; cin >> w >> h >> t >> p;
if(w+h+t+p == 0) break;
rep(i,h) rep(j,w) a[i][j] = 1;
int l = 0, u = 0;
rep(z,t){
int d,c; cin >> d >> c;
if(d == 2){
for(int i=u; i<u+c; i++){
REP(j,l,w+l){
a[2*u+2*c-1-i][j] += a[i][j];
a[i][j] = 0;
}
}
u += c;
}else{
for(int j=l; j<l+c; j++){
REP(i,u,h+u){
a[i][2*l+2*c-1-j] += a[i][j];
a[i][j] = 0;
}
}
l += c;
}
}
rep(i,p){
int x,y; cin >> x >> y;
cout << a[y+u][x+l] << "\n";
}
REP(i,u,u+h) REP(j,l,l+w) a[i][j] = 0;
}
}
|
You are hired by the ∀I¶אΞ℘, an extraterrestrial intelligence, as a programmer of their typesetting system. Your task today is to design an algorithm for text justification.
Text justification is to equalize the line widths as much as possible by inserting line breaks at appropriate posi- tions, given a word sequence called a paragraph and the width of the paper. Since you have not developed an automatic hyphenation algorithm yet, you cannot break a line in the middle of a word. And since their language does not put spaces between words, you do not need to consider about spacing.
To measure how well the text is justified in one configuration (i.e., a set of lines generated by inserting line breaks to a paragraph), you have defined its cost as follows:
* The total cost of a paragraph is the sum of the cost of each line.
* The cost for the last line is defined as max(0, s - w).
* The cost for other lines are given by |s - w|.
where s is the sum of the widths of the words in the line, and w is the width of the paper.
Please design the algorithm which takes a paragraph and calculates the configuration of the minimum cost.
Input
The input consists of multiple test cases.
The first line of each test case contains two positive integers n and w (0 ≤ n ≤ 1000 and 0 ≤ w ≤ 1,000,000). n is the length of paragraph and w is the width of the used paper. Each of the following n lines contains one positive integer ai which indicates the width of the i-th word in the paragraph. Here it is guaranteed that 0 ≤ ai ≤ w.
The input terminates with the line containing two zeros. This is not a part of any test case and should not be processed.
Output
For each test case, print the case number and the minimum cost for the paragraph.
Example
Input
4 10
8
6
9
1
4 7
1
2
3
4
0 0
Output
Case 1: 4
Case 2: 1
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MAX 1024
#define INF LLONG_MAX/4
ll N, W;
ll memo[MAX];
vector<ll> a;
ll solve(int n)
{
if (n == N) return 0;
ll &res = memo[n];
if (res != -1) return res;
res = INF;
ll sum = 0;
for (int i = n; i < N; i++) {
sum += a[i];
res = min(res, solve(i+1) + abs(sum - W));
}
res = min(res, solve(N) + max(0LL, sum - W));
return res;
}
int main()
{
int T = 1;
while (cin >> N >> W, N) {
a.resize(N);
for (int i = 0; i < N; i++) {
cin >> a[i];
}
memset(memo, -1, sizeof(memo));
cout << "Case " << T++ << ": " << solve(0) << endl;
}
return 0;
}
|
Training is indispensable for achieving good results at ICPC. Rabbit wants to win at ICPC, so he decided to practice today as well.
Today's practice is to improve the ability to read messages hidden from sentences by searching for palindromes in strings. There may be many palindromes, so I'd like to count the number while searching.
Given two strings S and T, we want to find the number of pairs of integers (i, j, k, l) that satisfy the following:
* 1 ≤ i ≤ j ≤ (length of S).
* 1 ≤ k ≤ l ≤ (length of T).
* The substrings extracted from the i-th to j-th characters of S are the same as the substrings extracted from the k-th to l-th characters of T, and these are palindromes (even when read from the left). It is a character string that is the same even when read from the right).
Input
S
T
Both the strings S and T have a length of 1 or more and 50,000 or less, and consist of uppercase letters.
Output
Output the number of pairs of integers (i, j, k, l) that satisfy the condition on one line.
Examples
Input
ICPC
CPCPC
Output
10
Input
BABBAB
ABBA
Output
14
Input
MYON
USAGI
Output
0
|
#include <cstdio>
#include <iostream>
#include <queue>
#include <set>
using namespace std;
template<typename C, typename C::value_type low, typename C::value_type high>
class PalindromeTree{
const static int m = high - low + 1;
typedef typename C::value_type T;
struct node{
int next[m];
int len;
int sufflink;
};
const C s;
int len;
int num;
void initTree(){
num = 2; suff = 2;
tree[1].len = -1; tree[1].sufflink = 1;
tree[2].len = 0; tree[2].sufflink = 1;
}
public:
vector<node> tree;
int suff;
bool addLetter(int pos){
int cur = suff;
int curLen = 0;
const int let = s[pos] - low;
while(true){
curLen = tree[cur].len;
if(pos - 1 - curLen >= 0 && s[pos - 1 - curLen] == s[pos]) break;
cur = tree[cur].sufflink;
}
if(tree[cur].next[let]){
suff = tree[cur].next[let];
return false;
}
num++;
suff = num;
tree[num].len = tree[cur].len + 2;
tree[cur].next[let] = num;
if(tree[num].len == 1){
tree[num].sufflink = 2;
return true;
}
while(true){
cur = tree[cur].sufflink;
curLen = tree[cur].len;
if(pos - 1 - curLen >= 0 && s[pos - 1 - curLen] == s[pos]){
tree[num].sufflink = tree[cur].next[let];
break;
}
}
return true;
}
PalindromeTree(const C &s)
: s(s), len(s.size()), tree(s.size() + 3){
initTree();
}
void build(){
for(int i = 0; i < len; i++){
addLetter(i);
}
}
static long long countSamePalindrome(const C &s, const C &t, const C &sp){
long long ans = 0;
const C sum = s + sp + t;
PalindromeTree tree(sum);
vector<long long> scnt(sum.size() + 3);
vector<long long> tcnt(sum.size() + 3);
for(int i = 0; i < (int)sum.size(); i++){
tree.addLetter(i);
int pos = tree.suff;
const node &nd = tree.tree[pos];
if(i - nd.len + 1 < (int)s.size()){
scnt[pos]++;
}else if(i - nd.len + 1 >= (int)(s.size() + sp.size())){
tcnt[pos]++;
}
}
for(int i = 0; i < 2; i++){
vector<long long> &v = i == 0 ? scnt : tcnt;
vector<int> ref(v.size());
for(int j = 3; j < (int)v.size(); j++){
if(v[j] > 0 && tree.tree[j].sufflink >= 3){
ref[tree.tree[j].sufflink]++;
}
}
queue<int> q;
for(int j = 3; j < (int)v.size(); j++){
if(v[j] > 0 && ref[j] == 0) q.push(j);
}
while(q.size()){
const int pos = q.front(); q.pop();
const int suff = tree.tree[pos].sufflink;
if(suff >= 3){
v[suff] += v[pos];
ref[suff]--;
if(ref[suff] == 0) q.push(suff);
}
}
}
for(int i = 3; i < (int)scnt.size(); i++){
ans += scnt[i] * tcnt[i];
}
return ans;
}
};
typedef PalindromeTree<string, 'a', 'z'> SPalindromeTree;
char buff[50000 + 10];
string getStr(){
scanf("%s", buff);
return buff;
}
int main(){
const string s = getStr();
const string t = getStr();
typedef PalindromeTree<string, 'A' - 2, 'Z'> SPalindromeTree;
printf("%lld\n", SPalindromeTree::countSamePalindrome(s, t, "@?"));
return 0;
}
|
You are playing a solitaire puzzle called "Connect", which uses several letter tiles.
There are R × C empty cells. For each i (1 ≤ i ≤ R), you must put a string si (1 ≤ |si| ≤ C) in the i-th row of the table, without changing the letter order. In other words, you choose an integer sequence {aj} such that 1 ≤ a1 < a2 < ... < a|si| ≤ C , and put the j-th character of the string si in the aj-th column (1 ≤ j ≤ |si|).
For example, when C = 8 and si = "ICPC", you can put si like followings.
I_C_P_C_
ICPC____
_IC___PC
'_' represents an empty cell.
For each non-empty cell x, you get a point equal to the number of adjacent cells which have the same character as x. Two cells are adjacent if they share an edge.
Calculate the maximum total point you can get.
Input
The first line contains two integers R and C (1 ≤ R ≤ 128, 1 ≤ C ≤ 16).
Then R lines follow, each of which contains si (1 ≤ |si| ≤ C). All characters of si are uppercase letters.
Output
Output the maximum total point in a line.
Examples
Input
2 4
ACM
ICPC
Output
2
Input
2 9
PROBLEMF
CONNECT
Output
6
Input
4 16
INTERNATIONAL
COLLEGIATE
PROGRAMMING
CONTEST
Output
18
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;
const int MAX_R = 128;
const int MAX_C = 16+1;
const int BIT = 1<<MAX_C;
int r, c;
string s[MAX_R];
int dp[2][BIT];
int main() {
while(1) {
if(cin >> r >> c) ; else break;
for(int i = 0; i < r; ++i) cin >> s[i];
int p = 0;
fill(dp[0], dp[2], -1);
for(int k = 0; k < (1<<c); ++k) {
if(__builtin_popcount(k) != s[0].size()) continue;
string tmp = "";
for(int i = 0, a = 0; i < c; ++i) {
if(k&(1<<i)) tmp += s[0][a++];
else tmp += '.';
}
dp[p][k] = 0;
for(int i = 1; i < tmp.size(); ++i) {
if(tmp[i] != '.' && tmp[i-1] == tmp[i]) {
dp[p][k] += 2;
}
}
}
for(int i = 1; i < r; ++i) {
for(int j = 0; j < c; ++j) {
int q = 1-p;
for(int k = 0; k < (1<<c); ++k) dp[q][k] = -1;
for(int k = 0; k < (1<<c); ++k) {
if(dp[p][k] == -1) continue;
int Lu = c - j;
char u, l;
int use;
u = l = '.';
for(int t = Lu-1, a = (int)s[i-1].size()-1; t >= 0; --t) {
if(k&(1<<t)) u = s[i-1][a--];
else u = '.';
}
use = 0;
for(int t = Lu; t < c; ++t) {
if(k&(1<<t)) l = s[i][use++];
else l = '.';
}
if(use + (c-j) < s[i].size()) continue;
// space
{
int nk = k/2;
if(j+1 == c && __builtin_popcount(nk) != s[i].size()); else {
dp[q][nk] = max(dp[q][nk], dp[p][k]);
}
}
// char
if(use < s[i].size()) {
int nk = k/2 + (1<<(c-1));
int add = 0;
add += (s[i][use] == u) * 2;
add += (s[i][use] == l) * 2;
if(j+1 == c && __builtin_popcount(nk) != s[i].size()); else {
dp[q][nk] = max(dp[q][nk], dp[p][k] + add);
}
}
}
p = q;
}
}
int res = 0;
for(int k = 0; k < (1<<c); ++k) {
res = max(res, dp[p][k]);
}
cout << res << endl;
}
return 0;
}
|
One day, Ikta, an elementary school student, received a piece of paper with mathematical formulas from his grandfather. Apparently, the grandfather will give you as much money as the answer to the formula. Ikta has only learned addition, subtraction, and multiplication, so only addition, subtraction, and multiplication are used in mathematical formulas. In normal calculation, multiplication must be calculated before addition and subtraction, but Ikta had a vague understanding of operator precedence, so for the time being, it is convenient to maximize the calculation result of the formula. I decided to consider a good priority.
Given the three binary operators + − × and a formula containing parentheses. Change the precedence of the three operators as you like and answer the calculation result when the formula is maximized.
However, note the following points.
* Operators are always left-associative. (Operators with the same precedence are always calculated from the left side of the formula.)
* Different operators may have the same precedence.
* Do not change the priority while calculating one formula.
Input
The input is given in the following format.
A formula consisting of numbers from 0 to 9 and the operators'+','-','*' and parentheses'(',')'
* To be precise, the input is in the format shown in BNF below.
> <expr> :: = (<expr>) | <number> | <expr> <op> <expr>
> <op> :: = + |-| *
<number> represents a non-negative integer.
Constraints
The input satisfies the following constraints.
* The formula is 200 characters or less.
* No matter what priority is set, it will not overflow as a result of calculation or in the middle of it as a 64-bit integer type.
Output
Output the maximum value obtained from the formula in one line.
Examples
Input
3-2*3
Output
3
Input
(5-3*4)*(0-2+1)
Output
21
Input
1-2+3-4+5-6*0
Output
3
Input
(1989967-3*1-211+4487)
Output
8511076028
|
#include <bits/stdc++.h>
using namespace std;
namespace {
typedef long long Long;
template<class T> ostream& operator<<(ostream& os, const vector<T>& vs) {
if (vs.empty()) return os << "[]";
os << "[" << vs[0];
for (int i = 1; i < vs.size(); i++) os << "," << vs[i];
return os << "]";
}
string s;
void input() {
cin >> s;
}
vector<string> ops; /* levelと演算子の対応. levelが大きいほど優先度が高い. */
Long number(const string& s, int& index) {
Long r = 0;
while (index < s.size() && isdigit(s[index])) {
r = r * 10 + (s[index] - '0');
index++;
}
return r;
}
bool check(char op, int level) {
// opが当該levelの演算子かどうかを返す
for (int i = 0; i < ops[level].size(); i++) {
if (op == ops[level][i]) return true;
}
return false;
}
Long calc(char op, Long a, Long b) {
if (op == '+') return a + b;
if (op == '-') return a - b;
if (op == '*') return a * b;
assert(0);
}
Long parse(const string& s, int& index, int level) {
if (level == 3) {
if (s[index] == '(') {
index++;
Long r = parse(s, index, 0);
assert(s[index] == ')');
index++;
return r;
}
return number(s, index);
}
Long r = parse(s, index, level + 1);
while (index < s.size() && check(s[index], level)) {
char op = s[index];
index++;
Long a = parse(s, index, level + 1);
r = calc(op, r, a);
}
return r;
}
const Long INF = LLONG_MIN;
void solve() {
// 各演算子のlevelに対して全探索.
string t = "+-*";
sort(t.begin(), t.end());
Long ans = -INF;
for (int a = 0; a < 3; a++) {
for (int b = 0; b < 3; b++) {
for (int c = 0; c < 3; c++) {
for (int i = 0; i < 4; i++) {
ops.clear(); ops.resize(3);
ops[a].push_back(t[0]);
ops[b].push_back(t[1]);
ops[c].push_back(t[2]);
int index = 0;
ans = max(ans, parse(s, index, 0));
}
}
}
}
cout << ans << endl;
}
}
int main() {
input(); solve();
return 0;
}
|
F: Miko Mi String-
story
Mikko Mikkomi ~! Everyone's idol, Miko Miko Tazawa! Today ~, with Mikoto ~, practice the string algorithm, let's do it ☆
Miko's special ~~ character making ~~ The slogan "MikoMikomi" becomes "MikoMikoMi" in Roman letters! In other words, if A = “Mi” and B = “Ko”, you can write in the form of ABABA! In this way, a character string that can be decomposed into the form of ABABA by properly determining A and B is called "Mikomi character string"! Miko is a popular person for everyone to become the name of a character string!
In order for everyone to use the Mikomi character string, I decided to make a program to judge whether the given character string is the Mikomi character string, but I can't write a program longer than Miko and FizzBuzz. !! So ~, for Miko ~, I want you to write a program that judges Mikomi character strings ☆
...... You said it's cold now! ??
problem
A character string S consisting of uppercase and lowercase letters is given. Here, if there are two non-empty strings A and B that can be written as S = ABABA, then S is said to be a "Mikomi string". At this time, uppercase and lowercase letters of the alphabet shall be distinguished as different characters. Create a program that determines whether a given string is a string.
Input format
The input consists of only one line including the character string S. It can be assumed that S satisfies the following conditions.
* 1 ≤ | S | ≤ 10 ^ 6. However, | S | represents the length of the character string S.
* S consists only of uppercase or lowercase alphabets.
Since the input may be very large, it is recommended to use a high-speed function to receive the input.
Output format
If S is a character string, output "Love AB!" For A and B that satisfy S = ABABA. However, if multiple pairs of A and B satisfy the condition, output the one with the smallest | AB |. If S is not a Mikomi string, output "mitomerarenaiWA".
Input example 1
NicoNicoNi
Output example 1
Love Nico!
Input example 2
Kashikoi Kawaii Elichika
Output example 2
mitomerarenaiWA
Input example 3
LiveLiveL
Output example 3
Love Live!
Input example 4
AizunyanPeroPero
Output example 4
mitomerarenaiWA
Input example 5
AAAAAAAAAAAAAA
Output example 5
Love AAAAA!
Example
Input
NicoNicoNi
Output
Love Nico!
|
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
struct FastIO{
FastIO(){
cin.tie(0);
ios::sync_with_stdio(0);
}
}fastio_beet;
struct RollingHash{
using ull = unsigned long long;
vector<ull> hash,p;
RollingHash(){}
RollingHash(const string &s,ull B=1000000007LL){
int n=s.size();
hash.assign(n+1,0);
p.assign(n+1,1);
for(int i=0;i<n;i++){
hash[i+1]=hash[i]*B+s[i];
p[i+1]=p[i]*B;
}
}
//S[l, r)
ull find(int l,int r){
return hash[r]-hash[l]*p[r-l];
}
};
//INSERT ABOVE HERE
signed main(){
string s;
cin>>s;
int n=s.size();
int ans=n+1;
RollingHash rh(s);
for(int a=1;a*3<n;a++){
if((n-a*3)&1) continue;
int b=(n-a*3)/2;
using ull = RollingHash::ull;
ull u=rh.find(0,a);
ull v=rh.find(a,a+b);
ull w=rh.find(a+b,a+b+a);
ull x=rh.find(a+b+a,a+b+a+b);
ull y=rh.find(a+b+a+b,a+b+a+b+a);
if(u==w&&w==y&&v==x) chmin(ans,a+b);
}
if(ans<=n) cout<<"Love "<<s.substr(0,ans)<<"!"<<endl;
else cout<<"mitomerarenaiWA"<<endl;
return 0;
}
|
problem
One day, Sosusa, who loves prime numbers, was playing with the pair $ (p, q) $, where $ p + q $ is a prime number. Suddenly, Sosusa wondered how many of these pairs were prime numbers with $ p $ and $ q $ both less than or equal to $ N $. Find the number on your behalf.
output
Output the number of pairs. Also, output a line break at the end.
Example
Input
3
Output
2
|
#include <bits/stdc++.h>
using namespace std;
/*
bool isPrime(int x)
{
test++;
if(x < 2)
return false;
if(x == 2)
return true;
if(x % 2 == 0)
return false;
for(int i = 3; i * i <= x; i += 2)
{
if(x % i == 0)
return false;
}
return true;
}
*/
vector<bool> prime(1e7 + 1, true);
void make_prime()
{
prime[0] = prime[1] = false;
for(int i = 2; i <= 1e7 + 10; i++)
{
if(prime[i])
{
for(int j = 2 * i; j <= 1e7 + 10; j += i)
prime[j] = false;
}
}
}
int main()
{
long n;
cin >> n;
int p = 2;
int cnt = 0;
make_prime();
for(int q = 3; q <= n; q++)
{
if(prime[q] && prime[p + q] == true)
cnt++;
}
cout << cnt * 2 << endl;
return 0;
}
|
Problem
You were asked by a company to create a program. The company has $ N $ jobs, and each job is numbered from $ 1 $ to $ N $. There are $ M_i $ prerequisite jobs $ X_ {i, j} $ in job $ i $, and work $ X_ {i, j} $ is performed before job $ X_ {i, j} $. And work $ i $ suffers a great loss.
So ask you to find the number of jobs you lost when you did all the jobs in the order that minimized the number of jobs you lost.
Constraints
The input satisfies the following conditions.
* $ 1 \ le N \ le 10 ^ 5 $
* $ 0 \ le M_i \ le N $
* Sum of $ M_i $ does not exceed $ 10 ^ 5 $
* $ 1 \ le X_ {i, j} \ le min (i + 1, N) $
Input
All inputs are given as integers in the following format:
$ N $
$ M_1 $ $ X_ {1,1} $ $ X_ {1,2} $ ... $ X_ {1, M_1} $
$ M_2 $ $ X_ {2,1} $ $ X_ {2,2} $ ... $ X_ {2, M_2} $
::
$ M_N $ $ X_ {N, 1} $ $ X_ {N, 2} $ ... $ X_ {N, M_N} $
The number of jobs $ N $ is given to the $ 1 $ line.
The following $ N $ line gives information on the prerequisite work. Information on work $ i $ is given on the $ i + 1 $ line, separated by blanks. $ M_i $ represents the number of jobs that are the premise of work $ i $, and $ X_ {i, j} $ is the number of jobs that are the premise of job $ i $.
Output
When all the jobs are done in the order that minimizes the number of jobs incurred, the number of jobs incurred at that time is output in one line.
Examples
Input
2
1 1
0
Output
1
Input
3
3 2 1 2
0
1 2
Output
1
Input
5
1 2
1 3
2 1 2
3 1 3 5
0
Output
1
|
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#include <complex>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <functional>
#include <cassert>
typedef long long ll;
using namespace std;
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;
#define mod 1000000007 //1e9+7(prime number)
#define INF 1000000000 //1e9
#define LLINF 2000000000000000000LL //2e18
#define SIZE 100010
/* Starry Sky Tree */
//0-index
struct StarrySkyTree{
typedef int Type;
int segn2;
vector<Type> data,s_data;
StarrySkyTree(int n){
for(segn2=1;segn2<n;segn2*=2);
data.assign(segn2*2,0);
s_data.assign(segn2*2,0);
}
//get maximum value of [a,b]
Type query(int a,int b,int l=0,int r=-1,int k=0){
if(r==-1) r+=segn2;
if(r<a || b<l) return -INF; //大きさに注意
if(a<=l && r<=b) return data[k] + s_data[k];
return max(query(a,b,l,(l+r)/2,k*2+1),query(a,b,(l+r)/2+1,r,k*2+2))+s_data[k];
}
//add x to [a,b]
Type add(int a,int b,Type x,int l=0,int r=-1,int k=0){
if(r==-1) r+=segn2;
if(a<=l && r<=b){
s_data[k]+=x;
}else if(a<=r && l<=b){
data[k] = max(add(a,b,x,l,(l+r)/2,k*2+1),add(a,b,x,(l+r)/2+1,r,k*2+2));
}
return data[k] + s_data[k];
}
};
bool hasnext[SIZE], hasown[SIZE];
int prevmax[SIZE];
int main(){
int n, m, x;
scanf("%d", &n);
for(int i=0;i<n;i++) prevmax[i] = -1;
for(int i=0;i<n;i++){
scanf("%d", &m);
for(int j=0;j<m;j++){
scanf("%d", &x);
x--;
hasnext[i] |= x == i+1;
hasown[i] |= x == i;
if(x < i) prevmax[i] = max(prevmax[i], x);
}
}
StarrySkyTree seg(n+1);
seg.add(1,n, -INF);
for(int i=0;i<n;i++){
if(!hasown[i] && !hasnext[i]){
seg.add(prevmax[i]+1, i, 1);
}
int res = seg.query(0,i);
seg.add(i+1, i+1, res - seg.query(i+1, i+1));
if(!hasown[i] && hasnext[i]){
seg.add(prevmax[i]+1, i, 1);
}
}
cout << n - seg.query(0,n) << endl;
return 0;
}
|
Write a program which performs the following operations to a binary search tree $T$ by adding delete operation to B: Binary Search Tree II.
* insert $k$: Insert a node containing $k$ as key into $T$.
* find $k$: Report whether $T$ has a node containing $k$.
* delete $k$: Delete a node containing $k$.
* print: Print the keys of the binary search tree by inorder tree walk and preorder tree walk respectively.
The operation delete $k$ for deleting a given node $z$ containing key $k$ from $T$ can be implemented by an algorithm which considers the following cases:
1. If $z$ has no children, we modify its parent $z.p$ to replace $z$ with NIL as its child (delete $z$).
2. If $z$ has only a single child, we "splice out" $z$ by making a new link between its child and its parent.
3. If $z$ has two children, we splice out $z$'s successor $y$ and replace $z$'s key with $y$'s key.
Constraints
* The number of operations $\leq 500,000$
* The number of print operations $\leq 10$.
* $-2,000,000,000 \leq key \leq 2,000,000,000$
* The height of the binary tree does not exceed 100 if you employ the above pseudo code.
* The keys in the binary search tree are all different.
Input
In the first line, the number of operations $m$ is given. In the following $m$ lines, operations represented by insert $k$, find $k$, delete $k$ or print are given.
Output
For each find $k$ operation, print "yes" if $T$ has a node containing $k$, "no" if not.
In addition, for each print operation, print a list of keys obtained by inorder tree walk and preorder tree walk in a line respectively. Put a space character before each key
Example
Input
18
insert 8
insert 2
insert 3
insert 7
insert 22
insert 1
find 1
find 2
find 3
find 4
find 5
find 6
find 7
find 8
print
delete 3
delete 7
print
Output
yes
yes
yes
no
no
no
yes
yes
1 2 3 7 8 22
8 2 1 3 7 22
1 2 8 22
8 2 1 22
|
import java.util.Scanner;
public class Main {
final boolean DEBUG = false;
class Node {
int key;
Node p, l, r;
Node(int key) {
this.key = key;
}
void insert(Node z) {
Node y = null;
Node x = this;
while (x != null) {
y = x;
if (z.key < x.key) x = x.l;
else x = x.r;
}
z.p = y;
if (z.key < y.key) y.l = z;
else y.r = z;
}
void delete(int key) {
Node z = this;
while (z != null) {
if (key == z.key) break;
if (key < z.key) z = z.l;
else z = z.r;
}
if(DEBUG) {
System.out.println("delete key: " + z.key);
}
Node y = z.p;
if (z.l == null && z.r == null)
if (y.l != null && y.l.key == z.key) y.l = null;
else y.r = null;
else if (z.l != null && z.r != null) {
Node pre = this.getNextInNode(z.key);
z.delete(pre.key);
z.key = pre.key;
} else {
if (z.l != null) {
if (y.l != null && y.l.key == z.key) y.l = z.l;
else y.r = z.l;
z.l.p = y;
} else {
if (y.l != null && y.l.key == z.key) y.l = z.r;
else y.r = z.r;
z.r.p = y;
}
}
}
boolean find(int key) {
Node x = this;
while (x != null) {
if (key == x.key)
return true;
else if (key < x.key)
x = x.l;
else
x = x.r;
}
return false;
}
void print() {
this.inorder();
System.out.println();
this.preorder();
System.out.println();
}
void preorder() {
System.out.print(" " + this.key);
if (this.l != null)
this.l.preorder();
if (this.r != null)
this.r.preorder();
}
void inorder() {
if (this.l != null)
this.l.inorder();
System.out.print(" " + this.key);
if (this.r != null)
this.r.inorder();
}
Node getNextInNode(int key) {
Node n = null;
if (this.l != null)
n = this.l.getNextInNode(key);
if (n != null)
return n;
if (this.key > key)
return this;
if (this.r != null)
n = this.r.getNextInNode(key);
if (n != null)
return n;
return n;
}
}
void run() {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
Node t = null;
for (int i = 0; i < n; i++) {
String inst = scan.next();
// set a root node
if (i == 0) {
int key = scan.nextInt();
t = new Node(key);
continue;
}
switch(inst) {
case "insert":
int key = scan.nextInt();
if (DEBUG)
System.out.println("insert: " + key);
t.insert(new Node(key));
break;
case "find":
int findKey = scan.nextInt();
if (DEBUG)
System.out.println("find: " + findKey);
System.out.println(t.find(findKey) ? "yes" : "no");
break;
case "delete":
int delKey = scan.nextInt();
if (DEBUG)
System.out.println("find: " + delKey);
t.delete(delKey);
break;
case "print":
if (DEBUG)
System.out.println("print");
t.print();
break;
}
}
}
public static void main(String[] args) {
new Main().run();
}
}
|
For a dynamic array $A = \\{a_0, a_1, ...\\}$ of integers, perform a sequence of the following operations:
* push($d$, $x$): Add element $x$ at the begining of $A$, if $d = 0$. Add element $x$ at the end of $A$, if $d = 1$.
* randomAccess($p$): Print element $a_p$.
* pop($d$): Delete the first element of $A$, if $d = 0$. Delete the last element of $A$, if $d = 1$.
$A$ is a 0-origin array and it is empty in the initial state.
Constraints
* $1 \leq q \leq 400,000$
* $0 \leq p < $ the size of $A$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $d$ $x$
or
1 $p$
or
2 $d$
where the first digits 0, 1 and 2 represent push, randomAccess and pop operations respectively.
randomAccess and pop operations will not be given for an empty array.
Output
For each randomAccess, print $a_p$ in a line.
Example
Input
11
0 0 1
0 0 2
0 1 3
1 0
1 1
1 2
2 0
2 1
0 0 4
1 0
1 1
Output
2
1
3
4
1
|
from collections import deque
class shinajina():
def push(A,que):
if que[1]==0:
A.appendleft(que[2])
elif que[1]==1:
A.append(que[2])
def randomaccess(A,que):
print(A[que[1]])
def pop(A,que):
if que[1]==0:
A.popleft()
elif que[1]==1:
A.pop()
def main():
q = int(input())
A = deque()
query = [list( map(int,input().split())) for i in range(q)]
for que in query:
if que[0]==0:
shinajina.push(A,que)
elif que[0]==1:
shinajina.randomaccess(A,que)
elif que[0]==2:
shinajina.pop(A,que)
if __name__ == '__main__':
main()
|
Problem Description
Two mathematicians Mr.X and Mr.Y are discussing about a problem. Mr.X says that the ans is a and Mr.Y says the ans is b(where a and b being string containing 0's and 1's). After arguing for a long time they find that Mr.X was giving the answer in binary code where as Mr.Y was giving the answer in Gray code. Mr.X wants to check if his ans matches with that of Mr.Y.
Help Mr.X find the gray code for his binary code.
Input
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
Each test case contains a single string a denoting the binary code
Output
For each test case, output a single line containing the Gray Code b.
Constraints
1 ≤ T ≤ 10000
1 ≤ |a| ≤ 1000
Example
Input:
3
100
011
10001
Output:
110
010
11001
|
for _ in range(input()):
s=raw_input()
g=''
g+=s[0]
for i in range(1,len(s)):
g+=str(int(s[i-1])^int(s[i]))
print g
|
Today, Chef woke up to find that he had no clean socks. Doing laundry is such a turn-off for Chef, that in such a situation, he always buys new socks instead of cleaning the old dirty ones. He arrived at the fashion store with money rupees in his pocket and started looking for socks. Everything looked good, but then Chef saw a new jacket which cost jacketCost rupees. The jacket was so nice that he could not stop himself from buying it.
Interestingly, the shop only stocks one kind of socks, enabling them to take the unsual route of selling single socks, instead of the more common way of selling in pairs. Each of the socks costs sockCost rupees.
Chef bought as many socks as he could with his remaining money. It's guaranteed that the shop has more socks than Chef can buy. But now, he is interested in the question: will there be a day when he will have only 1 clean sock, if he uses a pair of socks each day starting tommorow? If such an unlucky day exists, output "Unlucky Chef", otherwise output "Lucky Chef". Remember that Chef never cleans or reuses any socks used once.
Input
The first line of input contains three integers — jacketCost, sockCost, money — denoting the cost of a jacket, cost of a single sock, and the initial amount of money Chef has, respectively.
Output
In a single line, output "Unlucky Chef" if such a day exists. Otherwise, output "Lucky Chef".
Constraints
1 ≤ jacketCost ≤ money ≤ 10^9
1 ≤ sockCost ≤ 10^9
Example
Input:
1 2 3
Output:
Unlucky Chef
Input:
1 2 6
Output:
Lucky Chef
Subtasks
Subtask 1: jacketCost, money, sockCost ≤ 10^3. Points - 20
Subtask 2: Original constraints. Points - 80
Explanation
Test #1:
When Chef arrived at the shop, he had 3 rupees. After buying the jacket, he has 2 rupees left, enough to buy only 1 sock.
Test #2:
Chef had 6 rupees in the beginning. After buying the jacket, he has 5 rupees left, enough to buy a pair of socks for 4 rupees.
|
jacketCost, sockCost, money = map(int,raw_input().split())
if((money-jacketCost)//sockCost)%2==0:
print('Lucky Chef')
else:
print('Unlucky Chef')
|
The palindrome is a string that can be read the same way from left to right and from right to left. For example, strings "aaaaa", "1221", "bbaabb" are palindromes, however the string "chef" is not a palindrome because if we read it from right to left, we will obtain "fehc" that is not the same as "chef".
We call a string a "double string" if it has an even length and the first half of this string is equal to the second half of this string, for example "abab" is a double string because the first half "ab" is equal to the second half "ab", however the string "abba" is not a double string because the first half "ab" is not equal to the second half "ba". The empty string "" is a double string, and its length is 0.
Chef doesn't like palindromes, however he likes "double strings". He often likes to change the order of letters in some palindrome and sometimes to remove some symbols from it. Now he wonders: if a palindrome of length N is given, what is the maximal possible number of characters in a "double string"
that can be obtained by removing and changing the order of symbols in it?
Input
Several test cases are given.
The first line of the sample input contains an integer T - the number of test cases.
Then, T lines follow.
Each line consists of a single integer N - the length of a palindrome.
Output
For each test case output a single integer - answer to the problem.
Constraints
1<=T<=10000
1<=N<=1000000000
Example
Input:
2
2
4
Output:
2
4
|
T = int(raw_input())
for i in range(T):
N = int(raw_input())
if N%2 == 0:
print N
else:
print N-1
|
Today, as usual, Jerry comes up with a new puzzle for Tom. Jerry knows very well that Tom is well aware of the concepts of fibonacci series. So he intends to present the problem with a twist. By choosing any random integer Jerry asks Tom to tell whether the given number is a fibonacci number.
Input
The first line of the input contains an integer T denoting the number of test cases.
Next T lines which contain a random number N chosen by Jerry.
Output
For each input random integer you need to tell if the integer is fibo number or not. If the integer is fibo number output "is fibo" otherwise output "not fibo".
Constraints
1 ≤ T ≤ 20
1 ≤ N ≤ 1*10^9
Example
Input:
3
1
3
7
Output:
is fibo
is fibo
not fibo
|
a = [1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,1771128657,46368,75025,
121393,196418,317811,514229,832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817,39088169,
63245986,102334155,165580141,267914296,433494437,701408733]
t = int(raw_input())
while t:
t-=1
n = long(raw_input())
if n in a:
print 'is fibo'
else:
print 'not fibo'
|
John wanted to buy gifts for some k children in his apartments on christmas.
He goes to the shop and the shopkeeper shows him n gifts.
How many ways John can choose k gifts from n total gifts ?.
Since answer could be large print the answer mod 1000000007
NOTE : ordering of the gifts do not matter
Different order of same set of gifts are considered same and should not be counted as different
Input
The first line of the input contains an integer t, number of test cases
next t lines follow with each line containing two integers (n and k) separated by space.
Output
For each test case print the answer in a new line.
Constraints
0 < n <= 100000
1< k <= 100000
1 < t <= 100
Example
Input:
1
5 1
Output:
5
Explanation
Example case .you can chose any one of the five gifts.so 5 ways
|
def C(n, r):
if(n<r):
return 0
if(r==0):
return 1
if(r==1):
return n
if(r>n/2):
return C(n, n-r)
else:
res = 1
for i in xrange(0, r):
res*=(n-i)
res/=(i+1)
return res%1000000007
li=list()
for _ in xrange(int(raw_input())):
n, r = map(int, raw_input().split())
li.append(C(n, r))
for i in li:
print i
|
All bandits are afraid of Sheriff. Sheriff constantly fights crime, but when bandits lay low, he gets bored and starts to entertain himself.
This time Sheriff gathered all the bandits in his garden and ordered them to line up. After the whistle all bandits should change the order in which they stand.
Sheriff gave all the bandits numbers from 1 to N. For each place i he determined the unique position j. After whistling the bandit staying on position i should run to the j-th position. Sheriff loved seeing how the bandits move around, and he continued whistling until the evening. He finished the game only when he noticed that the bandits are in the same order in which they were standing originally.
Now the Sheriff asks the question: How many times has he whistled?
Input
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test case contains a single integer N denoting the number of bandits. The second line contains N space-separated integers A1, A2, ..., AN denoting that the bandit staying on position i should run to the Ai-th position after the whistle.
Output
For each test case, output a single line containing number of times the sheriff had to whistle, print it modulo 10^9 + 7.
Constraints
1 ≤ T ≤ 5
1 ≤ N ≤ 100000
All Ai are distinct numbers from 1 to N
Example
Input:
2
3
1 2 3
5
2 3 1 5 4
Output:
1
6
Explanation
Example case 2.
the bandits positions are:
0. 1 2 3 4 5
1. 3 1 2 5 4
2. 2 3 1 4 5
3. 1 2 3 5 4
4. 3 1 2 4 5
5. 2 3 1 5 4
6. 1 2 3 4 5.
|
def gcd(a, b):
"""
Compute the GCD of 2 numbers.
"""
while b:
a, b = b, a % b
return a
def _lcm(a, b):
"""
Compute the LCM of 2 numbers.
"""
return (a * b) / gcd(a, b)
def lcm(*args):
"""
Compute the LCM of arbitrary amount of numbers.
"""
return reduce(_lcm, args)
def garden_game():
# Get the number of test cases.
n = int(raw_input())
# Loop for the required testcases.
for _ in xrange(n):
# Get the number of bandits and the order.
bandits = int(raw_input())
order = map(lambda x: int(x) - 1, raw_input().split())
# The number of moves required. (unique)
moves = set()
# For detecting cycles.
cycles = [0] * bandits
curr_cycl = 0
for i in xrange(bandits):
# Already a part of a cycle which has been found earlier.
# Don't compute.
if cycles[i]:
continue
# Initialise the length of cycle (count), the current cycle
# the next position and make sure that i is a part of the
# current cycle.
count = 1
curr_cycl += 1
curr_pos = order[i]
cycles[i] = curr_cycl
# Loop until we reach a point which is a part of our current cycle.
while curr_cycl != cycles[curr_pos]:
# Increment the length of the cycle.
count += 1
# The item at curr_pos is a part of curr_cycl.
cycles[curr_pos] = curr_cycl
# Move on to the next position.
curr_pos = order[curr_pos]
moves.add(count)
print lcm(*moves) % 1000000007
if __name__ == "__main__":
garden_game()
|
You are given a text consisting of n space-separated words. There is exactly one space character between any pair of adjacent words. There are no spaces before the first word and no spaces after the last word. The length of text is the number of letters and spaces in it. w_i is the i-th word of text. All words consist only of lowercase Latin letters.
Let's denote a segment of words w[i..j] as a sequence of words w_i, w_{i + 1}, ..., w_j. Two segments of words w[i_1 .. j_1] and w[i_2 .. j_2] are considered equal if j_1 - i_1 = j_2 - i_2, j_1 ≥ i_1, j_2 ≥ i_2, and for every t ∈ [0, j_1 - i_1] w_{i_1 + t} = w_{i_2 + t}. For example, for the text "to be or not to be" the segments w[1..2] and w[5..6] are equal, they correspond to the words "to be".
An abbreviation is a replacement of some segments of words with their first uppercase letters. In order to perform an abbreviation, you have to choose at least two non-intersecting equal segments of words, and replace each chosen segment with the string consisting of first letters of the words in the segment (written in uppercase). For example, for the text "a ab a a b ab a a b c" you can replace segments of words w[2..4] and w[6..8] with an abbreviation "AAA" and obtain the text "a AAA b AAA b c", or you can replace segments of words w[2..5] and w[6..9] with an abbreviation "AAAB" and obtain the text "a AAAB AAAB c".
What is the minimum length of the text after at most one abbreviation?
Input
The first line of the input contains one integer n (1 ≤ n ≤ 300) — the number of words in the text.
The next line contains n space-separated words of the text w_1, w_2, ..., w_n. Each word consists only of lowercase Latin letters.
It is guaranteed that the length of text does not exceed 10^5.
Output
Print one integer — the minimum length of the text after at most one abbreviation.
Examples
Input
6
to be or not to be
Output
12
Input
10
a ab a a b ab a a b c
Output
13
Input
6
aa bb aa aa bb bb
Output
11
Note
In the first example you can obtain the text "TB or not TB".
In the second example you can obtain the text "a AAAB AAAB c".
In the third example you can obtain the text "AB aa AB bb".
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const int N = 300 + 5;
map<string, int> Map;
int id[N], w[N], a[N], p[N];
void getNext(int a[], int n) {
p[0] = -1;
int j = -1;
for (int i = 1; i < n; i++) {
while (j != -1 && a[j + 1] != a[i]) j = p[j];
if (a[j + 1] == a[i]) j++;
p[i] = j;
}
}
int KMP(int a[], int n, int b[], int m) {
int ret = 0;
int j = -1;
for (int i = 0; i < m; i++) {
while (j != -1 && a[j + 1] != b[i]) j = p[j];
if (a[j + 1] == b[i]) j++;
if (j == n - 1) {
ret++;
j = -1;
}
}
return ret;
}
int main() {
int n;
cin >> n;
int idx = 0;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
id[i] = Map[s];
if (!id[i]) id[i] = Map[s] = ++idx;
w[i] = s.size() + w[i - 1];
}
int ans = 0;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
for (int k = i; k <= j; k++) a[k - i] = id[k];
getNext(a, j - i + 1);
int s = KMP(a, j - i + 1, id + 1, n);
if (s > 1) ans = max(ans, (w[j] - w[i - 1] - 1) * s);
}
cout << w[n] + n - 1 - ans;
return 0;
}
|
The campus has m rooms numbered from 0 to m - 1. Also the x-mouse lives in the campus. The x-mouse is not just a mouse: each second x-mouse moves from room i to the room i ⋅ x mod{m} (in fact, it teleports from one room to another since it doesn't visit any intermediate room). Starting position of the x-mouse is unknown.
You are responsible to catch the x-mouse in the campus, so you are guessing about minimum possible number of traps (one trap in one room) you need to place. You are sure that if the x-mouse enters a trapped room, it immediately gets caught.
And the only observation you made is GCD (x, m) = 1.
Input
The only line contains two integers m and x (2 ≤ m ≤ 10^{14}, 1 ≤ x < m, GCD (x, m) = 1) — the number of rooms and the parameter of x-mouse.
Output
Print the only integer — minimum number of traps you need to install to catch the x-mouse.
Examples
Input
4 3
Output
3
Input
5 2
Output
2
Note
In the first example you can, for example, put traps in rooms 0, 2, 3. If the x-mouse starts in one of this rooms it will be caught immediately. If x-mouse starts in the 1-st rooms then it will move to the room 3, where it will be caught.
In the second example you can put one trap in room 0 and one trap in any other room since x-mouse will visit all rooms 1..m-1 if it will start in any of these rooms.
|
#include <bits/stdc++.h>
using namespace std;
const int B = 1e7 + 10;
int mndv[B], prm[B], nprm;
int mdv[60][2], gdv[60], ndv;
long long phidv[60];
int Ndv;
long long m, x;
inline long long Mul(long long a, long long b, long long mod) {
a %= mod, b %= mod;
long long z = (long double)a / mod * b;
long long res = (unsigned long long)a * b - (unsigned long long)z * mod;
return (res + mod) % mod;
}
long long Pow(long long a, long long b, long long mod) {
long long c = 1;
while (b) {
if (b & 1) c = Mul(c, a, mod);
a = Mul(a, a, mod);
b >>= 1;
}
return c;
}
void Init() {
for (int i = 2; i < B; i++) {
if (!mndv[i]) prm[++nprm] = mndv[i] = i;
for (int j = 1; j <= nprm && prm[j] * i < B; j++) {
mndv[prm[j] * i] = prm[j];
if (i % prm[j] == 0) continue;
}
}
}
void Divide(int g) {
for (int i = 1; i <= ndv; i++) gdv[i] = 0;
while (g > 1) {
gdv[prm[mndv[g]]]++;
g /= mndv[g];
}
}
long long Run(const long long& phi, const long long& mod) {
long long ord = phi, tmpphi = phi;
for (int i = 1; i <= Ndv; i++)
if (tmpphi % phidv[i] == 0) {
int cnt = 0;
while (tmpphi % phidv[i] == 0) cnt++, tmpphi /= phidv[i];
long long tdv = 1, mxdv = 1;
for (int j = 0; j <= cnt; j++, tdv *= phidv[i])
if (Pow(x, phi / tdv, mod) == 1) mxdv = max(mxdv, tdv);
ord /= mxdv;
}
return phi / ord;
}
int main() {
Init();
scanf("%lld%lld", &m, &x);
long long tmpm = m, phim = m;
for (int i = 2; i < B; i++)
if (tmpm % i == 0) {
phim = phim / i * (i - 1);
mdv[++ndv][0] = i, prm[i] = ndv;
while (tmpm % i == 0) mdv[ndv][1]++, tmpm /= i;
}
if (tmpm > 1) phim = phim / tmpm * (tmpm - 1);
long long tmpphi = phim;
for (int i = 2; i < B; i++)
if (tmpphi % i == 0) {
phidv[++Ndv] = i;
while (tmpphi % i == 0) tmpphi /= i;
}
if (tmpphi > 1) phidv[++Ndv] = tmpphi;
long long ans = 0;
for (int g = 1; g <= m / g; g++)
if (m % g == 0) {
Divide(g);
long long phi = g;
for (int i = 1; i <= ndv; i++)
if (gdv[i]) phi = phi / mdv[i][0] * (mdv[i][0] - 1);
if (tmpm > 1 && g % tmpm == 0) phi = phi / tmpm * (tmpm - 1);
ans += Run(phi, g);
if (m / g != g) {
phi = m / g;
for (int i = 1; i <= ndv; i++)
if (gdv[i] < mdv[i][1]) phi = phi / mdv[i][0] * (mdv[i][0] - 1);
if (tmpm > 1 && g % tmpm) phi = phi / tmpm * (tmpm - 1);
ans += Run(phi, m / g);
}
}
printf("%lld\n", ans);
return 0;
}
|
After finding and moving to the new planet that supports human life, discussions started on which currency should be used. After long negotiations, Bitcoin was ultimately chosen as the universal currency.
These were the great news for Alice, whose grandfather got into Bitcoin mining in 2013, and accumulated a lot of them throughout the years. Unfortunately, when paying something in bitcoin everyone can see how many bitcoins you have in your public address wallet.
This worried Alice, so she decided to split her bitcoins among multiple different addresses, so that every address has at most x satoshi (1 bitcoin = 10^8 satoshi). She can create new public address wallets for free and is willing to pay f fee in satoshi per transaction to ensure acceptable speed of transfer. The fee is deducted from the address the transaction was sent from. Tell Alice how much total fee in satoshi she will need to pay to achieve her goal.
Input
First line contains number N (1 ≤ N ≤ 200 000) representing total number of public addresses Alice has.
Next line contains N integer numbers a_i (1 ≤ a_i ≤ 10^9) separated by a single space, representing how many satoshi Alice has in her public addresses.
Last line contains two numbers x, f (1 ≤ f < x ≤ 10^9) representing maximum number of satoshies Alice can have in one address, as well as fee in satoshies she is willing to pay per transaction.
Output
Output one integer number representing total fee in satoshi Alice will need to pay to achieve her goal.
Example
Input
3
13 7 6
6 2
Output
4
Note
Alice can make two transactions in a following way:
0. 13 7 6 (initial state)
1. 6 7 6 5 (create new address and transfer from first public address 5 satoshies)
2. 6 4 6 5 1 (create new address and transfer from second address 1 satoshi)
Since cost per transaction is 2 satoshies, total fee is 4.
|
import java.util.Scanner;
public class Main {
private static Scanner in = new Scanner(System.in);
public static void main(String[] args) {
int n = in.nextInt();
int[] x = new int[n];
for (int i = 0; i < n; i++) {
x[i] = in.nextInt();
}
long ans = 0;
int m = in.nextInt();
int f = in.nextInt();
for (int i = 0; i < n; i++) {
ans += (x[i] - 1L + f) / (m + f) * f;
}
System.out.println(ans);
}
}
|
Polycarp has a lot of work to do. Recently he has learned a new time management rule: "if a task takes five minutes or less, do it immediately". Polycarp likes the new rule, however he is not sure that five minutes is the optimal value. He supposes that this value d should be chosen based on existing task list.
Polycarp has a list of n tasks to complete. The i-th task has difficulty p_i, i.e. it requires exactly p_i minutes to be done. Polycarp reads the tasks one by one from the first to the n-th. If a task difficulty is d or less, Polycarp starts the work on the task immediately. If a task difficulty is strictly greater than d, he will not do the task at all. It is not allowed to rearrange tasks in the list. Polycarp doesn't spend any time for reading a task or skipping it.
Polycarp has t minutes in total to complete maximum number of tasks. But he does not want to work all the time. He decides to make a break after each group of m consecutive tasks he was working on. The break should take the same amount of time as it was spent in total on completion of these m tasks.
For example, if n=7, p=[3, 1, 4, 1, 5, 9, 2], d=3 and m=2 Polycarp works by the following schedule:
* Polycarp reads the first task, its difficulty is not greater than d (p_1=3 ≤ d=3) and works for 3 minutes (i.e. the minutes 1, 2, 3);
* Polycarp reads the second task, its difficulty is not greater than d (p_2=1 ≤ d=3) and works for 1 minute (i.e. the minute 4);
* Polycarp notices that he has finished m=2 tasks and takes a break for 3+1=4 minutes (i.e. on the minutes 5, 6, 7, 8);
* Polycarp reads the third task, its difficulty is greater than d (p_3=4 > d=3) and skips it without spending any time;
* Polycarp reads the fourth task, its difficulty is not greater than d (p_4=1 ≤ d=3) and works for 1 minute (i.e. the minute 9);
* Polycarp reads the tasks 5 and 6, skips both of them (p_5>d and p_6>d);
* Polycarp reads the 7-th task, its difficulty is not greater than d (p_7=2 ≤ d=3) and works for 2 minutes (i.e. the minutes 10, 11);
* Polycarp notices that he has finished m=2 tasks and takes a break for 1+2=3 minutes (i.e. on the minutes 12, 13, 14).
Polycarp stops exactly after t minutes. If Polycarp started a task but has not finished it by that time, the task is not considered as completed. It is allowed to complete less than m tasks in the last group. Also Polycarp considers acceptable to have shorter break than needed after the last group of tasks or even not to have this break at all — his working day is over and he will have enough time to rest anyway.
Please help Polycarp to find such value d, which would allow him to complete maximum possible number of tasks in t minutes.
Input
The first line of the input contains single integer c (1 ≤ c ≤ 5 ⋅ 10^4) — number of test cases. Then description of c test cases follows. Solve test cases separately, test cases are completely independent and do not affect each other.
Each test case is described by two lines. The first of these lines contains three space-separated integers n, m and t (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ t ≤ 4 ⋅ 10^{10}) — the number of tasks in Polycarp's list, the number of tasks he can do without a break and the total amount of time Polycarp can work on tasks. The second line of the test case contains n space separated integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ 2 ⋅ 10^5) — difficulties of the tasks.
The sum of values n for all test cases in the input does not exceed 2 ⋅ 10^5.
Output
Print c lines, each line should contain answer for the corresponding test case — the maximum possible number of tasks Polycarp can complete and the integer value d (1 ≤ d ≤ t) Polycarp should use in time management rule, separated by space. If there are several possible values d for a test case, output any of them.
Examples
Input
4
5 2 16
5 6 1 4 7
5 3 30
5 6 1 4 7
6 4 15
12 5 15 7 20 17
1 1 50
100
Output
3 5
4 7
2 10
0 25
Input
3
11 1 29
6 4 3 7 5 3 4 7 3 5 3
7 1 5
1 1 1 1 1 1 1
5 2 18
2 3 3 7 5
Output
4 3
3 1
4 5
Note
In the first test case of the first example n=5, m=2 and t=16. The sequence of difficulties is [5, 6, 1, 4, 7]. If Polycarp chooses d=5 then he will complete 3 tasks. Polycarp will work by the following schedule:
* Polycarp reads the first task, its difficulty is not greater than d (p_1=5 ≤ d=5) and works for 5 minutes (i.e. the minutes 1, 2, ..., 5);
* Polycarp reads the second task, its difficulty is greater than d (p_2=6 > d=5) and skips it without spending any time;
* Polycarp reads the third task, its difficulty is not greater than d (p_3=1 ≤ d=5) and works for 1 minute (i.e. the minute 6);
* Polycarp notices that he has finished m=2 tasks and takes a break for 5+1=6 minutes (i.e. on the minutes 7, 8, ..., 12);
* Polycarp reads the fourth task, its difficulty is not greater than d (p_4=4 ≤ d=5) and works for 4 minutes (i.e. the minutes 13, 14, 15, 16);
* Polycarp stops work because of t=16.
In total in the first test case Polycarp will complete 3 tasks for d=5. He can't choose other value for d to increase the number of completed tasks.
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long sum;
int cnt;
node *ptl, *ptr;
node() {
sum = cnt = 0;
ptl = ptr = NULL;
}
void build(int l, int r) {
sum = cnt = 0;
if (l == r) return;
int mid = (l + r) >> 1;
if (ptl == NULL) ptl = new node();
ptl->build(l, mid);
if (ptr == NULL) ptr = new node();
ptr->build(mid + 1, r);
}
void update(int l, int r, int tar, long long add) {
sum += add;
cnt++;
if (l == r) return;
int mid = (l + r) >> 1;
if (tar <= mid)
ptl->update(l, mid, tar, add);
else
ptr->update(mid + 1, r, tar, add);
}
long long query(int l, int r, int need) {
if (need == 0) return 0;
if (l == r) return sum;
int mid = (l + r) >> 1;
if (ptl->cnt >= need) {
return ptl->query(l, mid, need);
} else {
return ptl->sum + ptr->query(mid + 1, r, need - ptl->cnt);
}
}
} root;
int _T, n, m, arr[200055];
long long t;
vector<int> pos[200055], NUM;
inline long long solve(int tar) {
if (tar == 0) return 0;
long long blocks = (tar - 1) / m;
return root.query(0, n - 1, blocks * m) + root.query(0, n - 1, tar);
}
int main() {
scanf("%d", &_T);
while (_T--) {
int ans = 0, ans2 = 1;
NUM.clear();
scanf("%d%d%lld", &n, &m, &t);
for (int i = 0; i < n; i++) {
scanf("%d", arr + i);
pos[arr[i]].push_back(i);
NUM.push_back(arr[i]);
}
sort(NUM.begin(), NUM.end());
NUM.resize(unique(NUM.begin(), NUM.end()) - NUM.begin());
root.build(0, n - 1);
int cnt = 0;
for (int d : NUM) {
for (int at : pos[d]) {
root.update(0, n - 1, at, d);
cnt++;
}
int lo = 0, hi = cnt + 1;
while (lo < hi - 1) {
int mid = (lo + hi) >> 1;
if (solve(mid) <= t)
lo = mid;
else
hi = mid;
}
if (lo > ans) {
ans = lo;
ans2 = d;
}
}
printf("%d %d\n", ans, ans2);
for (int i = 0; i < n; i++) pos[arr[i]].clear();
}
return 0;
}
|
You are given two integers n and k.
Your task is to construct such a string s of length n that for each i from 1 to k there is at least one i-th letter of the Latin alphabet in this string (the first letter is 'a', the second is 'b' and so on) and there are no other letters except these. You have to maximize the minimal frequency of some letter (the frequency of a letter is the number of occurrences of this letter in a string). If there are several possible answers, you can print any.
You have to answer t independent queries.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of queries.
The next t lines are contain queries, one per line. The i-th line contains two integers n_i and k_i (1 ≤ n_i ≤ 100, 1 ≤ k_i ≤ min(n_i, 26)) — the length of the string in the i-th query and the number of characters in the i-th query.
Output
Print t lines. In the i-th line print the answer to the i-th query: any string s_i satisfying the conditions in the problem statement with constraints from the i-th query.
Example
Input
3
7 3
4 4
6 2
Output
cbcacab
abcd
baabab
Note
In the first example query the maximum possible minimal frequency is 2, it can be easily seen that the better answer doesn't exist. Other examples of correct answers: "cbcabba", "ccbbaaa" (any permutation of given answers is also correct).
In the second example query any permutation of first four letters is acceptable (the maximum minimal frequency is 1).
In the third example query any permutation of the given answer is acceptable (the maximum minimal frequency is 3).
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
a %= b;
return gcd(b, a);
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
int min_freq = n / k;
int p = min_freq;
string s;
while (min_freq--) s += 'a';
int left = n - p;
int last = 'a' + k - 1;
int index = 1;
while (left--) {
if ('a' + index <= last) {
s += 'a' + index;
index++;
} else {
index = 1;
s += 'a' + index;
index++;
}
}
cout << s << endl;
}
}
|
The tic-tac-toe game is starting on a tree of n vertices. Some vertices are already colored in white while the remaining are uncolored.
There are two players — white and black. The players make moves alternatively. The white player starts the game. In his turn, a player must select one uncolored vertex and paint it in his color.
The player wins if he paints some path of three vertices in his color. In case all vertices are colored and neither player won, the game ends in a draw.
Could you please find who will win the game or whether it ends as a draw, assuming both players play optimally?
Input
The first line contains a single integer T (1 ≤ T ≤ 50 000) — the number of test cases. Then descriptions of T test cases follow.
The first line of each test contains a single integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of vertices in the tree.
Each of the following n - 1 lines contains integers v, u (1 ≤ v, u ≤ n) denoting an edge of the tree connecting vertices v and u.
The last line of a test case contains a string of letters 'W' (for white) and 'N' (for not colored) of length n denoting already colored vertices. Vertexes already colored in white are denoted as 'W'.
It's guaranteed that the given edges form a tree, that there is at least one uncolored vertex and that there is no path of three white vertices.
It's guaranteed that sum of all n among all test cases is at most 5 ⋅ 10^5.
Output
For every test case, print either "White", "Draw" or "Black", depending on the result of the game.
Example
Input
2
4
1 2
1 3
1 4
NNNW
5
1 2
2 3
3 4
4 5
NNNNN
Output
White
Draw
Note
In the first example, vertex 4 is already colored in white. The white player can win by coloring the vertex 1 in white first and the remaining vertex on his second turn. The process is illustrated with the pictures below.
<image>
In the second example, we can show that no player can enforce their victory.
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adjList[2000000];
int main() {
int i, j;
int T, t;
int n, u, v;
char c;
scanf("%d", &T);
for (t = 0; t < T; t++) {
scanf("%d", &n);
for (i = 0; i < n - 1; i++) {
scanf("%d %d", &u, &v);
u--, v--;
adjList[u].push_back(v);
adjList[v].push_back(u);
}
int nn = n;
for (i = 0; i < nn; i++) {
scanf(" %c", &c);
if (c == 'W') {
adjList[i].push_back(n), adjList[n].push_back(i);
adjList[n].push_back(n + 1), adjList[n + 1].push_back(n);
adjList[n].push_back(n + 2), adjList[n + 2].push_back(n);
n += 3;
}
}
int c = 0;
for (i = 0; i < n; i++) {
if (adjList[i].size() >= 4)
break;
else if (adjList[i].size() >= 3) {
c++;
int c2 = 0;
for (j = 0; j < adjList[i].size(); j++) {
v = adjList[i][j];
if (adjList[v].size() >= 2) c2++;
}
if (c2 >= 2) break;
}
}
if ((i < n) || ((c == 2) && (n & 1)))
printf("White\n");
else
printf("Draw\n");
for (i = 0; i < n; i++) adjList[i].clear();
}
return 0;
}
|
You are given a regular polygon with n vertices labeled from 1 to n in counter-clockwise order. The triangulation of a given polygon is a set of triangles such that each vertex of each triangle is a vertex of the initial polygon, there is no pair of triangles such that their intersection has non-zero area, and the total area of all triangles is equal to the area of the given polygon. The weight of a triangulation is the sum of weigths of triangles it consists of, where the weight of a triagle is denoted as the product of labels of its vertices.
Calculate the minimum weight among all triangulations of the polygon.
Input
The first line contains single integer n (3 ≤ n ≤ 500) — the number of vertices in the regular polygon.
Output
Print one integer — the minimum weight among all triangulations of the given polygon.
Examples
Input
3
Output
6
Input
4
Output
18
Note
According to Wiki: polygon triangulation is the decomposition of a polygonal area (simple polygon) P into a set of triangles, i. e., finding a set of triangles with pairwise non-intersecting interiors whose union is P.
In the first example the polygon is a triangle, so we don't need to cut it further, so the answer is 1 ⋅ 2 ⋅ 3 = 6.
In the second example the polygon is a rectangle, so it should be divided into two triangles. It's optimal to cut it using diagonal 1-3 so answer is 1 ⋅ 2 ⋅ 3 + 1 ⋅ 3 ⋅ 4 = 6 + 12 = 18.
|
n=int(input())
print((n*(n+1)*(n+2))//3-2-n*(n+1))
|
Let's call an array of non-negative integers a_1, a_2, …, a_n a k-extension for some non-negative integer k if for all possible pairs of indices 1 ≤ i, j ≤ n the inequality k ⋅ |i - j| ≤ min(a_i, a_j) is satisfied. The expansion coefficient of the array a is the maximal integer k such that the array a is a k-extension. Any array is a 0-expansion, so the expansion coefficient always exists.
You are given an array of non-negative integers a_1, a_2, …, a_n. Find its expansion coefficient.
Input
The first line contains one positive integer n — the number of elements in the array a (2 ≤ n ≤ 300 000). The next line contains n non-negative integers a_1, a_2, …, a_n, separated by spaces (0 ≤ a_i ≤ 10^9).
Output
Print one non-negative integer — expansion coefficient of the array a_1, a_2, …, a_n.
Examples
Input
4
6 4 5 5
Output
1
Input
3
0 1 2
Output
0
Input
4
821 500 479 717
Output
239
Note
In the first test, the expansion coefficient of the array [6, 4, 5, 5] is equal to 1 because |i-j| ≤ min(a_i, a_j), because all elements of the array satisfy a_i ≥ 3. On the other hand, this array isn't a 2-extension, because 6 = 2 ⋅ |1 - 4| ≤ min(a_1, a_4) = 5 is false.
In the second test, the expansion coefficient of the array [0, 1, 2] is equal to 0 because this array is not a 1-extension, but it is 0-extension.
|
#include <bits/stdc++.h>
using namespace std;
long long diff[10000006];
long long same[10000006];
long long fastexpo(long long x, long long n) {
if (n == 0) return 1;
long long temp = fastexpo(x, n / 2) % 1000000007;
if (n & 1) return (temp * temp * x) % 1000000007;
return (temp * temp) % 1000000007;
}
int main() {
long long n, i, j;
cin >> n;
vector<pair<long long, long long> > vec;
for (i = 0; i < n; i++) {
long long x;
cin >> x;
vec.push_back(make_pair(x, i + 1));
}
sort(vec.begin(), vec.end());
long long s = 0, e = 1000000007;
long long ans = 0;
while (s <= e) {
long long mid = (s + e) / 2;
for (i = 0; i < n; i++) {
if (mid * max(n - vec[i].second, vec[i].second - 1) > vec[i].first) break;
}
if (i < n)
e = mid - 1;
else {
ans = mid;
s = mid + 1;
}
}
cout << ans << endl;
}
|
Dima worked all day and wrote down on a long paper strip his favorite number n consisting of l digits. Unfortunately, the strip turned out to be so long that it didn't fit in the Dima's bookshelf.
To solve the issue, Dima decided to split the strip into two non-empty parts so that each of them contains a positive integer without leading zeros. After that he will compute the sum of the two integers and write it down on a new strip.
Dima wants the resulting integer to be as small as possible, because it increases the chances that the sum will fit it in the bookshelf. Help Dima decide what is the minimum sum he can obtain.
Input
The first line contains a single integer l (2 ≤ l ≤ 100 000) — the length of the Dima's favorite number.
The second line contains the positive integer n initially written on the strip: the Dima's favorite number.
The integer n consists of exactly l digits and it does not contain leading zeros. Dima guarantees, that there is at least one valid way to split the strip.
Output
Print a single integer — the smallest number Dima can obtain.
Examples
Input
7
1234567
Output
1801
Input
3
101
Output
11
Note
In the first example Dima can split the number 1234567 into integers 1234 and 567. Their sum is 1801.
In the second example Dima can split the number 101 into integers 10 and 1. Their sum is 11. Note that it is impossible to split the strip into "1" and "01" since the numbers can't start with zeros.
|
n = int(input())
s = input()
mid = n//2;
ans = int(s)
for i in range(mid, 0, -1):
if s[i] != '0':
val = int(s[:i]) + int(s[i:])
ans = min(ans, val)
break
for i in range(mid+1, n):
if s[i] != '0':
val = int(s[:i]) + int(s[i:])
ans = min(ans, val)
break
print(ans)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.