input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
Today Johnny wants to increase his contribution. His plan assumes writing n blogs. One blog covers one topic, but one topic can be covered by many blogs. Moreover, some blogs have references to each other. Each pair of blogs that are connected by a reference has to cover different topics because otherwise, the readers can notice that they are split just for more contribution. Set of blogs and bidirectional references between some pairs of them is called blogs network.
There are n different topics, numbered from 1 to n sorted by Johnny's knowledge. The structure of the blogs network is already prepared. Now Johnny has to write the blogs in some order. He is lazy, so each time before writing a blog, he looks at it's already written neighbors (the blogs referenced to current one) and chooses the topic with the smallest number which is not covered by neighbors. It's easy to see that this strategy will always allow him to choose a topic because there are at most n - 1 neighbors.
For example, if already written neighbors of the current blog have topics number 1, 3, 1, 5, and 2, Johnny will choose the topic number 4 for the current blog, because topics number 1, 2 and 3 are already covered by neighbors and topic number 4 isn't covered.
As a good friend, you have done some research and predicted the best topic for each blog. Can you tell Johnny, in which order he has to write the blogs, so that his strategy produces the topic assignment chosen by you?
Input
The first line contains two integers n (1 ≤ n ≤ 5 ⋅ 10^5) and m (0 ≤ m ≤ 5 ⋅ 10^5) — the number of blogs and references, respectively.
Each of the following m lines contains two integers a and b (a ≠ b; 1 ≤ a, b ≤ n), which mean that there is a reference between blogs a and b. It's guaranteed that the graph doesn't contain multiple edges.
The last line contains n integers t_1, t_2, …, t_n, i-th of them denotes desired topic number of the i-th blog (1 ≤ t_i ≤ n).
Output
If the solution does not exist, then write -1. Otherwise, output n distinct integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n), which describe the numbers of blogs in order which Johnny should write them. If there are multiple answers, print any.
Examples
Input
3 3
1 2
2 3
3 1
2 1 3
Output
2 1 3
Input
3 3
1 2
2 3
3 1
1 1 1
Output
-1
Input
5 3
1 2
2 3
4 5
2 1 2 2 1
Output
2 5 1 3 4
Note
In the first example, Johnny starts with writing blog number 2, there are no already written neighbors yet, so it receives the first topic. Later he writes blog number 1, it has reference to the already written second blog, so it receives the second topic. In the end, he writes blog number 3, it has references to blogs number 1 and 2 so it receives the third topic.
Second example: There does not exist any permutation fulfilling given conditions.
Third example: First Johnny writes blog 2, it receives the topic 1. Then he writes blog 5, it receives the topic 1 too because it doesn't have reference to single already written blog 2. Then he writes blog number 1, it has reference to blog number 2 with topic 1, so it receives the topic 2. Then he writes blog number 3 which has reference to blog 2, so it receives the topic 2. Then he ends with writing blog number 4 which has reference to blog 5 and receives the topic 2.
|
#include <bits/stdc++.h>
using std::abs;
using std::array;
using std::cerr;
using std::cin;
using std::cout;
using std::generate;
using std::get;
using std::make_pair;
using std::make_tuple;
using std::map;
using std::max;
using std::max_element;
using std::min;
using std::min_element;
using std::pair;
using std::queue;
using std::reverse;
using std::set;
using std::sort;
using std::string;
using std::swap;
using std::tuple;
using std::unique;
using std::vector;
template <typename T>
T input() {
T res;
cin >> res;
{};
return res;
}
template <typename IT>
void input_seq(IT b, IT e) {
std::generate(b, e,
input<typename std::remove_reference<decltype(*b)>::type>);
}
int main() {
std::iostream::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m;
cin >> n >> m;
vector<vector<int>> go(n);
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
go[a].push_back(b);
go[b].push_back(a);
}
vector<int> col(n);
vector<pair<int, int>> data(n);
for (int i = 0; i < n; ++i) data[i] = make_pair(col[i] = input<int>() - 1, i);
sort(data.begin(), data.end());
for (auto x : data) {
int v = x.second;
vector<char> used(col[v] + 1);
for (int u : go[v])
if (col[u] <= col[v]) used[col[u]] = true;
if (std::find(used.begin(), used.end(), false) != used.end() - 1) {
cout << "-1\n";
return 0;
}
}
for (auto x : data) cout << 1 + x.second << " ";
cout << "\n";
return 0;
}
|
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example.
|
/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
What do you think? What do you think?
1st on Billboard, what do you think of it
Next is a Grammy, what do you think of it
However you think, I’m sorry, but shit, I have no fcking interest
*******************************
I'm standing on top of my Monopoly board
That means I'm on top of my game and it don't stop
til my hip don't hop anymore
https://www.a2oj.com/Ladder16.html
*******************************
300iq as writer = Sad!
*/
import java.util.*;
import java.io.*;
import java.math.*;
public class x1381B
{
public static void main(String hi[]) throws Exception
{
BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(infile.readLine());
int T = Integer.parseInt(st.nextToken());
StringBuilder sb = new StringBuilder();
while(T-->0)
{
int N = Integer.parseInt(infile.readLine())*2;
int[] arr = new int[N];
st = new StringTokenizer(infile.readLine());
for(int i=0; i < N; i++)
arr[i] = Integer.parseInt(st.nextToken());
ArrayList<Integer> sizes = new ArrayList<Integer>();
boolean[] seen = new boolean[N];
for(int v=N; v >= 1; v--)
{
int loc = -1;
for(int i=0; i < N; i++)
if(arr[i] == v)
loc = i;
int cnt = 0;
while(loc < N)
{
if(seen[loc])
break;
seen[loc] = true;
cnt++;
loc++;
}
sizes.add(cnt);
}
boolean[] dp = new boolean[2*N+1];
dp[0] = true;
Collections.sort(sizes);
for(int v: sizes)
for(int i=2*N; i >= 0; i--)
if(i+v <= 2*N && dp[i])
dp[i+v] = true;
if(dp[N/2])
sb.append("YES\n");
else
sb.append("NO\n");
}
System.out.print(sb);
}
}
|
You are given an array a_1, a_2, ..., a_n where all a_i are integers and greater than 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n). If gcd(a_i, a_j) is equal to the minimum element of the whole array a, you can swap a_i and a_j. gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Now you'd like to make a non-decreasing using the operation any number of times (possibly zero). Determine if you can do this.
An array a is non-decreasing if and only if a_1 ≤ a_2 ≤ … ≤ a_n.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^5) — the length of array a.
The second line of each test case contains n positive integers a_1, a_2, … a_n (1 ≤ a_i ≤ 10^9) — the array itself.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output "YES" if it is possible to make the array a non-decreasing using the described operation, or "NO" if it is impossible to do so.
Example
Input
4
1
8
6
4 3 6 6 2 9
4
4 5 6 7
5
7 5 2 2 4
Output
YES
YES
YES
NO
Note
In the first and third sample, the array is already non-decreasing.
In the second sample, we can swap a_1 and a_3 first, and swap a_1 and a_5 second to make the array non-decreasing.
In the forth sample, we cannot the array non-decreasing using the operation.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int t, n, a[N], b[N];
bool solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b + 1, b + n + 1);
int mn = b[1];
for (int i = 1; i <= n; i++) {
if (a[i] == b[i]) continue;
if (a[i] % mn) {
return false;
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> t;
while (t--) {
if (solve()) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
|
In number world, two different numbers are friends if they have a lot in common, but also each one has unique perks.
More precisely, two different numbers a and b are friends if gcd(a,b), (a)/(gcd(a,b)), (b)/(gcd(a,b)) can form sides of a triangle.
Three numbers a, b and c can form sides of a triangle if a + b > c, b + c > a and c + a > b.
In a group of numbers, a number is lonely if it doesn't have any friends in that group.
Given a group of numbers containing all numbers from 1, 2, 3, ..., n, how many numbers in that group are lonely?
Input
The first line contains a single integer t (1 ≤ t ≤ 10^6) - number of test cases.
On next line there are t numbers, n_i (1 ≤ n_i ≤ 10^6) - meaning that in case i you should solve for numbers 1, 2, 3, ..., n_i.
Output
For each test case, print the answer on separate lines: number of lonely numbers in group 1, 2, 3, ..., n_i.
Example
Input
3
1 5 10
Output
1
3
3
Note
For first test case, 1 is the only number and therefore lonely.
For second test case where n=5, numbers 1, 3 and 5 are lonely.
For third test case where n=10, numbers 1, 5 and 7 are lonely.
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0LL) return a;
return gcd(b, a % b);
}
long long bigmod(long long a, long long b, long long mod) {
if (b == 0LL) return 1LL;
long long sq = bigmod(a, b / 2LL, mod);
sq = (sq * sq) % mod;
if (b & 1LL) return (sq * (a % mod)) % mod;
return sq;
}
const int SIZE = 1000010;
vector<int> prime(SIZE + 1, 0);
vector<int> primes;
void sieve(const int n) {
prime[1] = 1;
for (int p = 2; p * p <= n; p++) {
if (!prime[p]) {
for (int i = p * p; i <= n; i += p) prime[i] = p;
}
}
for (int i = 2; i <= n; i++)
if (!prime[i]) primes.push_back(i);
}
void solve() {
int n;
scanf("%d", &n);
sieve(SIZE);
vector<int> a(n);
vector<int> fr(SIZE, 0);
for (int i = 1; i <= SIZE - 2; i++) {
fr[i] = fr[i - 1] + (!prime[i]);
}
vector<int> sq(SIZE + 2, 0);
for (int i = 1; i * i <= (int)(sq).size(); i++) {
sq[i * i] = i;
}
for (int i = 3; i < (int)(sq).size(); i++) {
if (sq[i] == 0) sq[i] = sq[i - 1];
}
for (auto &x : (a)) {
scanf("%d", &x);
int ans = fr[x] - fr[sq[x]];
if (x <= 3) ans = x - 1;
ans += 1;
printf("%d\n", ans);
}
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
You have a knapsack with the capacity of W. There are also n items, the i-th one has weight w_i.
You want to put some of these items into the knapsack in such a way that their total weight C is at least half of its size, but (obviously) does not exceed it. Formally, C should satisfy: ⌈ W/2⌉ ≤ C ≤ W.
Output the list of items you will put into the knapsack or determine that fulfilling the conditions is impossible.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights of items in the knapsack.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4). Description of the test cases follows.
The first line of each test case contains integers n and W (1 ≤ n ≤ 200 000, 1≤ W ≤ 10^{18}).
The second line of each test case contains n integers w_1, w_2, ..., w_n (1 ≤ w_i ≤ 10^9) — weights of the items.
The sum of n over all test cases does not exceed 200 000.
Output
For each test case, if there is no solution, print a single integer -1.
If there exists a solution consisting of m items, print m in the first line of the output and m integers j_1, j_2, ..., j_m (1 ≤ j_i ≤ n, all j_i are distinct) in the second line of the output — indices of the items you would like to pack into the knapsack.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights items in the knapsack.
Example
Input
3
1 3
3
6 2
19 8 19 69 9 4
7 12
1 1 1 17 1 1 1
Output
1
1
-1
6
1 2 3 5 6 7
Note
In the first test case, you can take the item of weight 3 and fill the knapsack just right.
In the second test case, all the items are larger than the knapsack's capacity. Therefore, the answer is -1.
In the third test case, you fill the knapsack exactly in half.
|
import java.io.*;
import java.util.*;
public class Solution {
public static void main(String[] args) throws Exception
{
FastReader fr=new FastReader();
int t=fr.nextInt();
while(t-->0) {
int n=fr.nextInt();
long wt=fr.nextLong();
int w[]=new int[n];
HashMap<Integer,Queue<Integer>> map=new HashMap<>();
for(int i=0;i<n;i++) {
w[i]=fr.nextInt();
if(map.containsKey(w[i])) {
map.get(w[i]).add(i);
}
else {
Queue<Integer> al=new LinkedList<>();
al.add(i);
map.put(w[i],al);
}
}
Arrays.sort(w);
long sum=0;
boolean pos=false;
long f=(long)(Math.ceil(wt/2.0));
ArrayList<Integer> l=new ArrayList<>();
for(int i=n-1;i>=0;i--) {
if((sum+w[i])<=wt) {
sum+=w[i];
l.add(w[i]);
}
if(sum>=f) {
pos=true;
break;
}
}
if(pos==false) {
System.out.println(-1);
}
else {
//Set<Integer> set=new HashSet<>();
System.out.println(l.size());
for(int i:l) {
int j=map.get(i).remove();
//set.add(j);
System.out.print((j+1)+" ");
}
System.out.println();
}
}
}
}
class Pair {
char x;
int y;
Pair(char x,int y){
this.x=x;
this.y=y;
}
}
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;
}
}
|
Petya organized a strange birthday party. He invited n friends and assigned an integer k_i to the i-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are m unique presents available, the j-th present costs c_j dollars (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m). It's not allowed to buy a single present more than once.
For the i-th friend Petya can either buy them a present j ≤ k_i, which costs c_j dollars, or just give them c_{k_i} dollars directly.
Help Petya determine the minimum total cost of hosting his party.
Input
The first input line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of friends, and the number of unique presents available.
The following line contains n integers k_1, k_2, …, k_n (1 ≤ k_i ≤ m), assigned by Petya to his friends.
The next line contains m integers c_1, c_2, …, c_m (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m ≤ 10^9) — the prices of the presents.
It is guaranteed that sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values m over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output a single integer — the minimum cost of the party.
Examples
Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1
Note
In the first example, there are two test cases. In the first one, Petya has 5 friends and 4 available presents. Petya can spend only 30 dollars if he gives
* 5 dollars to the first friend.
* A present that costs 12 dollars to the second friend.
* A present that costs 5 dollars to the third friend.
* A present that costs 3 dollars to the fourth friend.
* 5 dollars to the fifth friend.
In the second one, Petya has 5 and 5 available presents. Petya can spend only 190 dollars if he gives
* A present that costs 10 dollars to the first friend.
* A present that costs 40 dollars to the second friend.
* 90 dollars to the third friend.
* 40 dollars to the fourth friend.
* 10 dollars to the fifth friend.
|
import bisect
import collections
import copy
import functools
import heapq
import itertools
import math
import random
import re
import sys
import time
import string
from typing import List
sys.setrecursionlimit(99999)
t, = map(int, sys.stdin.readline().split())
for _ in range(t):
n, m = map(int, sys.stdin.readline().split())
arrk = list(map(int,sys.stdin.readline().split()))
arrc = list(map(int,input().split()))
arrk.sort()
ans = 0
ak = collections.deque()
for c in arrk:
ak.append(c)
if len(ak)>c:
ans+= arrc[ak.popleft()-1]
while ak and arrc[ak[0]-1]< arrc[len(ak)-1]:
ans += arrc[ak.popleft()-1]
print(ans+ sum(arrc[:len(ak)]))
|
You are given a multiset S initially consisting of n distinct non-negative integers. A multiset is a set, that can contain some elements multiple times.
You will perform the following operation k times:
* Add the element ⌈(a+b)/(2)⌉ (rounded up) into S, where a = \operatorname{mex}(S) and b = max(S). If this number is already in the set, it is added again.
Here \operatorname{max} of a multiset denotes the maximum integer in the multiset, and \operatorname{mex} of a multiset denotes the smallest non-negative integer that is not present in the multiset. For example:
* \operatorname{mex}(\{1,4,0,2\})=3;
* \operatorname{mex}(\{2,5,1\})=0.
Your task is to calculate the number of distinct elements in S after k operations will be done.
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 description of the test cases follows.
The first line of each test case contains two integers n, k (1≤ n≤ 10^5, 0≤ k≤ 10^9) — the initial size of the multiset S and how many operations you need to perform.
The second line of each test case contains n distinct integers a_1,a_2,...,a_n (0≤ a_i≤ 10^9) — the numbers in the initial multiset.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the number of distinct elements in S after k operations will be done.
Example
Input
5
4 1
0 1 3 4
3 1
0 1 4
3 0
0 1 4
3 2
0 1 2
3 2
1 2 3
Output
4
4
3
5
3
Note
In the first test case, S=\{0,1,3,4\}, a=\operatorname{mex}(S)=2, b=max(S)=4, ⌈(a+b)/(2)⌉=3. So 3 is added into S, and S becomes \{0,1,3,3,4\}. The answer is 4.
In the second test case, S=\{0,1,4\}, a=\operatorname{mex}(S)=2, b=max(S)=4, ⌈(a+b)/(2)⌉=3. So 3 is added into S, and S becomes \{0,1,3,4\}. The answer is 4.
|
#include<bits/stdc++.h>
#define ll long long
#define fio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
using namespace std;
int main()
{
fio;
ll t=0;
cin>>t;
for(ll z=0; z<t; z++){
ll n,k,temp;
cin>>n>>k;
vector<ll> v;
for(int i = 0; i < n; i++){
cin>>temp;
v.push_back(temp);
}
if(k == 0){
cout<<n<<"\n";
continue;
}
if(n == 1){
if(v[0] == 1){
cout<<1<<"\n";
continue;
}
else if(v[0] == 0){
cout<<n+k<<"\n";
continue;
}
else{
cout<<2<<"\n";
continue;
}
}
sort(v.begin(), v.end());
ll a = -1;
ll b = v[n-1];
bool done = false;
if(v[0] != 0){
a = 0;
}
else{
ll iter = 0;
for(int i = 0; i < n; i++){
if(v[i] != iter){
a = iter;
break;
}
iter++;
}
if(a == -1){
cout<<n+k<<"\n";
done = true;
}
}
if(done){
continue;
}
ll val = 0;
if((a + b) % 2 == 0){
val = (a + b) / 2;
}
else{
val = ((a + b) / 2) + 1;
}
ll sizeset = 0;
for(int i = 0; i < n; i++){
if(v[i] == val){
sizeset = n;
break;
}
if(v[i] > val){
break;
}
}
if(sizeset == 0){
sizeset = n + 1;
}
cout<<sizeset<<"\n";
}
return 0;
}
|
There are n points on an infinite plane. The i-th point has coordinates (x_i, y_i) such that x_i > 0 and y_i > 0. The coordinates are not necessarily integer.
In one move you perform the following operations:
* choose two points a and b (a ≠ b);
* move point a from (x_a, y_a) to either (x_a + 1, y_a) or (x_a, y_a + 1);
* move point b from (x_b, y_b) to either (x_b + 1, y_b) or (x_b, y_b + 1);
* remove points a and b.
However, the move can only be performed if there exists a line that passes through the new coordinates of a, new coordinates of b and (0, 0).
Otherwise, the move can't be performed and the points stay at their original coordinates (x_a, y_a) and (x_b, y_b), respectively.
The numeration of points does not change after some points are removed. Once the points are removed, they can't be chosen in any later moves. Note that you have to move both points during the move, you can't leave them at their original coordinates.
What is the maximum number of moves you can perform? What are these moves?
If there are multiple answers, you can print any of them.
Input
The first line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of points.
The i-th of the next n lines contains four integers a_i, b_i, c_i, d_i (1 ≤ a_i, b_i, c_i, d_i ≤ 10^9). The coordinates of the i-th point are x_i = (a_i)/(b_i) and y_i = (c_i)/(d_i).
Output
In the first line print a single integer c — the maximum number of moves you can perform.
Each of the next c lines should contain a description of a move: two integers a and b (1 ≤ a, b ≤ n, a ≠ b) — the points that are removed during the current move. There should be a way to move points a and b according to the statement so that there's a line that passes through the new coordinates of a, the new coordinates of b and (0, 0). No removed point can be chosen in a later move.
If there are multiple answers, you can print any of them. You can print the moves and the points in the move in the arbitrary order.
Examples
Input
7
4 1 5 1
1 1 1 1
3 3 3 3
1 1 4 1
6 1 1 1
5 1 4 1
6 1 1 1
Output
3
1 6
2 4
5 7
Input
4
2 1 1 1
1 1 2 1
2 1 1 2
1 2 1 2
Output
1
1 2
Input
4
182 168 60 96
78 72 45 72
69 21 144 63
148 12 105 6
Output
1
2 4
Note
Here are the points and the moves for the ones that get chosen for the moves from the first example:
<image>
|
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include<bits/stdc++.h>
// #include<ext/pb_ds/assoc_container.hpp>
// #include<ext/pb_ds/tree_policy.hpp>
// #include<ext/pb_ds/tag_and_trait.hpp>
// using namespace __gnu_pbds;
// #include<boost/multiprecision/cpp_int.hpp>
// namespace multiprecisioninteger = boost::multiprecision;
// using cint=multiprecisioninteger::cpp_int;
using namespace std;
using ll=long long;
using datas=pair<ll,ll>;
using ddatas=pair<long double,long double>;
using tdata=pair<ll,datas>;
using vec=vector<ll>;
using mat=vector<vec>;
using pvec=vector<datas>;
using pmat=vector<pvec>;
// using llset=tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update>;
#define For(i,a,b) for(i=a;i<(ll)b;++i)
#define bFor(i,b,a) for(i=b,--i;i>=(ll)a;--i)
#define rep(i,N) For(i,0,N)
#define rep1(i,N) For(i,1,N)
#define brep(i,N) bFor(i,N,0)
#define brep1(i,N) bFor(i,N,1)
#define all(v) (v).begin(),(v).end()
#define allr(v) (v).rbegin(),(v).rend()
#define vsort(v) sort(all(v))
#define vrsort(v) sort(allr(v))
#define uniq(v) vsort(v);(v).erase(unique(all(v)),(v).end())
#define endl "\n"
#define popcount __builtin_popcountll
#define eb emplace_back
#define print(x) cout<<x<<endl
#define printyes print("Yes")
#define printno print("No")
#define printYES print("YES")
#define printNO print("NO")
#define output(v) do{bool f=0;for(auto outi:v){cout<<(f?" ":"")<<outi;f=1;}cout<<endl;}while(0)
#define matoutput(v) do{for(auto outimat:v)output(outimat);}while(0)
constexpr ll mod=1000000007;
// constexpr ll mod=998244353;
constexpr ll inf=1LL<<60;
constexpr long double eps=1e-9;
const long double PI=acosl(-1);
template<class T,class E> ostream& operator<<(ostream& os,const pair<T,E>& p){return os<<"("<<p.first<<","<<p.second<<")";}
template<class T> ostream& operator<<(ostream& os,const vector<T>& v){
os<<"{";bool f=false;
for(auto& x:v){if(f)os<<",";os<<x;f=true;}
os<<"}";
return os;
}
template<class T> ostream& operator<<(ostream& os,const set<T>& v){
os<<"{";bool f=false;
for(auto& x:v){if(f)os<<",";os<<x;f=true;}
os<<"}";
return os;
}
template<class T> ostream& operator<<(ostream& os,const multiset<T>& v){
os<<"{";bool f=false;
for(auto& x:v){if(f)os<<",";os<<x;f=true;}
os<<"}";
return os;
}
template<class T,class E> ostream& operator<<(ostream& os,const map<T,E>& v){
os<<"{";bool f=false;
for(auto& x:v){if(f)os<<",";os<<x;f=true;}
os<<"}";
return os;
}
template<class T> inline bool chmax(T& a,const T b){bool x=a<b;if(x)a=b;return x;}
template<class T> inline bool chmin(T& a,const T b){bool x=a>b;if(x)a=b;return x;}
#ifdef DEBUG
void debugg(){cout<<endl;}
template<class T,class... Args>void debugg(const T& x,const Args&... args){cout<<" "<<x;debugg(args...);}
#define debug(...) cout<<__LINE__<<" ["<<#__VA_ARGS__<<"]:",debugg(__VA_ARGS__)
#else
#define debug(...) (void(0))
#endif
inline void startupcpp(void) noexcept{
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(15);
}
ll modinv(ll a,const ll m=mod) noexcept{
ll b=m,u=1,v=0,t;
while(b){
t=a/b;
a-=t*b; swap(a,b);
u-=t*v; swap(u,v);
}
return (u+m)%m;
}
ll moddevide(const ll a,const ll b) noexcept{return (a*modinv(b))%mod;}
vec modncrlistp,modncrlistm;
ll modncr(const ll n,const ll r) noexcept{
if(n<r)return 0;
ll i,size=modncrlistp.size();
if(size<=n){
modncrlistp.resize(n+1);
modncrlistm.resize(n+1);
if(!size){
modncrlistp[0]=modncrlistm[0]=1;
size++;
}
For(i,size,n+1)modncrlistp[i]=modncrlistp[i-1]*i%mod;
modncrlistm[n]=modinv(modncrlistp[n]);
for(i=n;i>size;--i)modncrlistm[i-1]=modncrlistm[i]*i%mod;
}
return modncrlistp[n]*modncrlistm[r]%mod*modncrlistm[n-r]%mod;
}
ll modpow(ll a,ll n,const ll m=mod){
if(n<0)return 0;
ll res=1;
while(n>0){
if(n&1)res=res*a%m;
a=a*a%m;
n>>=1;
}
return res;
}
constexpr ll gcd(const ll a,const ll b) noexcept{return (!b)?abs(a):(a%b==0)?abs(b):gcd(b,a%b);}
constexpr ll lcm(const ll a,const ll b) noexcept{return a/gcd(a,b)*b;}
ll N,idcnt;
pvec edge;
bool vis[400001],nowval[400001];
pmat g;
bool dfs(int nowvertex){
for(auto [edgeid,nextvertex]:g[nowvertex]){
if(vis[nextvertex])continue;
vis[nextvertex]=true;
if(edge[edgeid].first!=nowvertex){
nowval[edge[edgeid].first]^=true;
nowval[edge[edgeid].second]^=true;
swap(edge[edgeid].first,edge[edgeid].second);
}
if(dfs(nextvertex)){
nowval[edge[edgeid].first]^=true;
nowval[edge[edgeid].second]^=true;
swap(edge[edgeid].first,edge[edgeid].second);
}
}
return nowval[nowvertex];
}
int main(){
// startupcpp();
ll i,j;
cin>>N;
{
map<datas,ll> id;
edge.resize(N);
for(auto&[u,v]:edge){
ll a,b,c,d;
cin>>a>>b>>c>>d;
i=(a+b)*d;j=b*c;
ll t=gcd(i,j);
i/=t;j/=t;
auto now=datas(i,j);
if(id.count(now))u=id[now];
else u=id[now]=idcnt++;
i=a*d;j=b*(c+d);
t=gcd(i,j);
i/=t;j/=t;
now=datas(i,j);
if(id.count(now))v=id[now];
else v=id[now]=idcnt++;
}
}
g.resize(idcnt);
//nowvalは極力falseだとうれしい
rep(i,N){
g[edge[i].first].emplace_back(i,edge[i].second);
g[edge[i].second].emplace_back(i,edge[i].first);
nowval[edge[i].first]^=true;
}
rep(i,idcnt){
if(!vis[i])dfs(i);
}
mat ans(idcnt);
rep(i,N)ans[edge[i].first].emplace_back(i);
mat pr;
for(auto v:ans){
if(v.size()&1)v.pop_back();
rep1(i,v.size()){
pr.emplace_back(vec({v[i-1]+1,v[i]+1}));
++i;
}
}
print(pr.size());
matoutput(pr);
}
|
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 <bits/stdc++.h>
#define FOR(i,a,b) for(long long i=a;i<=b;i++)
#define FORD(i,a,b) for(int i=a;i>=b;i--)
using namespace std;
string s;
const int mn = 505;
const int md = 998244353;
int n, a[mn*2][mn], id[mn*2], removed[mn*2];
void solve()
{
long long way = 1;
vector<int> res;
int cur_size = n*2;
FOR(i,1,cur_size) removed[i]=0;
while (int(res.size()) < n)
{
int find_gud = 0;
FOR(j,1,n)
{
int cnt[mn];
int pos[mn];
FOR(i,1,n)
{
cnt[i] = 0;
pos[i] = 0;
}
FOR(i,1,cur_size) if (!removed[i])
{
cnt[a[i][j]]++;
pos[a[i][j]] = i;
}
FOR(i,1,n) if (cnt[i]==1)
{
find_gud = pos[i];
break;
}
if (find_gud) break;
}
if (find_gud)
{
int i = find_gud;
res.push_back(id[i]);
find_gud = 1;
int temp_[505];
FOR(j,1,n) temp_[j] = a[i][j];
FORD(i2,cur_size,1) if (!removed[i2])
{
int bad = 0;
FOR(j,1,n) if (a[i2][j]==temp_[j])
{
bad = 1;
break;
}
if (bad) removed[i2]=1;
}
}
if (!find_gud)
{
way = way*2 % md;
int iii;
FOR(ii,1,cur_size) if (!removed[ii])
{
iii=ii;
break;
}
res.push_back(id[iii]);
int temp_[505];
FOR(j,1,n) temp_[j] = a[iii][j];
FORD(i2,cur_size,1)
{
int bad = 0;
FOR(j,1,n) if (a[i2][j]==temp_[j])
{
bad = 1;
break;
}
if (bad) removed[i2]=1;
}
}
}
cout << way << '\n';
for(int v : res) cout << v << ' '; cout << '\n';
}
int main()
{
int ts;
cin >> ts;
while (ts--)
{
cin >> n;
FOR(i,1,2*n)
{
FOR(j,1,n) cin>>a[i][j];
id[i]=i;
}
solve();
}
}
|
A group of n merry programmers celebrate Robert Floyd's birthday. Polucarpus has got an honourable task of pouring Ber-Cola to everybody. Pouring the same amount of Ber-Cola to everybody is really important. In other words, the drink's volume in each of the n mugs must be the same.
Polycarpus has already began the process and he partially emptied the Ber-Cola bottle. Now the first mug has a1 milliliters of the drink, the second one has a2 milliliters and so on. The bottle has b milliliters left and Polycarpus plans to pour them into the mugs so that the main equation was fulfilled.
Write a program that would determine what volume of the drink Polycarpus needs to add into each mug to ensure that the following two conditions were fulfilled simultaneously:
* there were b milliliters poured in total. That is, the bottle need to be emptied;
* after the process is over, the volumes of the drink in the mugs should be equal.
Input
The first line contains a pair of integers n, b (2 ≤ n ≤ 100, 1 ≤ b ≤ 100), where n is the total number of friends in the group and b is the current volume of drink in the bottle. The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 100), where ai is the current volume of drink in the i-th mug.
Output
Print a single number "-1" (without the quotes), if there is no solution. Otherwise, print n float numbers c1, c2, ..., cn, where ci is the volume of the drink to add in the i-th mug. Print the numbers with no less than 6 digits after the decimal point, print each ci on a single line. Polycarpus proved that if a solution exists then it is unique.
Russian locale is installed by default on the testing computer. Make sure that your solution use the point to separate the integer part of a real number from the decimal, not a comma.
Examples
Input
5 50
1 2 3 4 5
Output
12.000000
11.000000
10.000000
9.000000
8.000000
Input
2 2
1 100
Output
-1
|
#include <bits/stdc++.h>
using namespace std;
double a[100];
int main() {
int n;
double b, sum, m = 0, one;
cin >> n >> b;
sum = b;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
m = max(m, a[i]);
}
one = sum / n;
if (m > one) {
cout << -1;
return 0;
}
for (int i = 0; i < n; i++) printf("%0.9lf\n", -a[i] + one);
}
|
There is a square painted on a piece of paper, the square's side equals n meters. John Doe draws crosses on the square's perimeter. John paints the first cross in the lower left corner of the square. Then John moves along the square's perimeter in the clockwise direction (first upwards, then to the right, then downwards, then to the left and so on). Every time he walks (n + 1) meters, he draws a cross (see picture for clarifications).
John Doe stops only when the lower left corner of the square has two crosses. How many crosses will John draw?
<image> The figure shows the order in which John draws crosses for a square with side 4. The lower left square has two crosses. Overall John paints 17 crosses.
Input
The first line contains integer t (1 ≤ t ≤ 104) — the number of test cases.
The second line contains t space-separated integers ni (1 ≤ ni ≤ 109) — the sides of the square for each test sample.
Output
For each test sample print on a single line the answer to it, that is, the number of crosses John will draw as he will move along the square of the corresponding size. Print the answers to the samples in the order in which the samples are given in the input.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
4 8 100
Output
17
33
401
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
long long int n;
cin >> t;
for (int i = 0; i < t; ++i) {
cin >> n;
if (n % 2 == 0)
cout << 4 * n + 1;
else if (n % 4 == 1)
cout << 2 * n + 1;
else if (n % 4 == 3)
cout << n + 1;
else
;
cout << "\n";
}
return 0;
}
|
Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
* it is up to a passenger to choose a plane to fly on;
* if the chosen plane has x (x > 0) empty seats at the given moment, then the ticket for such a plane costs x zlotys (units of Polish currency).
The only ticket office of the airport already has a queue of n passengers in front of it. Lolek and Bolek have not stood in the queue yet, but they are already wondering what is the maximum and the minimum number of zlotys the airport administration can earn if all n passengers buy tickets according to the conditions of this offer?
The passengers buy tickets in turn, the first person in the queue goes first, then goes the second one, and so on up to n-th person.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 1000) — ai stands for the number of empty seats in the i-th plane before the ticket office starts selling tickets.
The numbers in the lines are separated by a space. It is guaranteed that there are at least n empty seats in total.
Output
Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly.
Examples
Input
4 3
2 1 1
Output
5 5
Input
4 3
2 2 2
Output
7 6
Note
In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd plane, the 3-rd person — to the 3-rd plane, the 4-th person — to the 1-st plane. The sum is minimized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 1-st plane, the 3-rd person — to the 2-nd plane, the 4-th person — to the 2-nd plane.
|
n,m=list(map(int,input().split()))
L=list(map(int,input().split()))
P=list(map(int,L))
mi=0
ma=0
for i in range(n):
x=max(L)
ma+=x
L[L.index(x)]-=1
#print(P)
for i in range(n):
x=min(P)
if x==0:
P.remove(x)
x=min(P)
mi+=x
P[P.index(x)]-=1
print(ma,mi)
|
The Old City is a rectangular city represented as an m × n grid of blocks. This city contains many buildings, straight two-way streets and junctions. Each junction and each building is exactly one block. All the streets have width of one block and are either vertical or horizontal. There is a junction on both sides of each street. We call two blocks adjacent if and only if they share a common side. No two blocks of different streets are adjacent and no two junctions are adjacent.
There is an annual festival and as a part of it, The Old Peykan follows a special path in the city. This path starts from a block in a street, continues with many junctions and ends in a block of some street. For each street block, we know how much time it takes for the Old Peykan to go from this block to an adjacent block. Also the Old Peykan can go from each junction to its adjacent street blocks in one minute. Of course Old Peykan can't go to building blocks.
We know the initial position of the Old Peykan and the sequence of junctions that it passes to reach its destination. After passing all the junctions and reaching the destination, it will stay there forever. Your task is to find out where will the Old Peykan be k minutes after it starts moving. Consider that The Old Peykan always follows the shortest path that passes through the given sequence of junctions and reaches the destination.
Note that the Old Peykan may visit some blocks more than once.
Input
The first line of input contains three integers m, n and k (3 ≤ m, n ≤ 100, 1 ≤ k ≤ 100000). Next m lines are representing the city's map. Each of them containts n characters, each character is a block:
* Character "#" represents a building.
* Digits "1", "2", ..., "9" represent a block of an street and this digit means the number of minutes it takes for the Old Peykan to pass this block.
* Characters "a", "b", ..., "z" means that this block is a junction and this character is it's name. All the junction names are unique.
Consider that all blocks have the coordinates: the j-th in the i-th line have coordinates (i, j) (1 ≤ i ≤ m, 1 ≤ j ≤ n).
The (m + 2)th line contains two integers rs and cs (1 ≤ rs ≤ m, 1 ≤ cs ≤ n), string s and another two integers re and ce (1 ≤ re ≤ m, 1 ≤ ce ≤ n). The path starts from block (rs, cs), continues through junctions in the order that is specified by s and will end in block (re, ce). Length of s is between 1 and 1000.
It's guaranteed that string s denotes a correct path from the start position to the end position and string s doesn't contain two consecutive equal letters. Also start position (rs, cs) and the end position (re, ce) are street blocks.
Output
In a single line print two integers rf and cf — (rf, cf) being the position of the Old Peykan after exactly k minutes.
Examples
Input
3 10 12
##########
#z1a1111b#
##########
2 3 ab 2 8
Output
2 8
Input
10 3 5
###
#w#
#1#
#a#
#1#
#1#
#1#
#1#
#b#
###
3 2 abababababababab 6 2
Output
8 2
Input
3 10 6
##########
#z1a1311b#
##########
2 3 ab 2 8
Output
2 7
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, pn;
char s[111][111];
int dxy[4][2] = {{0, -1}, {-1, 0}, {0, 1}, {1, 0}};
struct edge {
int v, w, next;
edge() {}
edge(int _v, int _w, int _next) {
v = _v;
w = _w;
next = _next;
}
} e[200011];
int head[100011], sz;
void init() {
memset(head, -1, sizeof(head));
sz = 0;
}
void insert(int u, int v, int w) {
e[++sz] = edge(v, w, head[u]);
head[u] = sz;
}
struct node {
int v, d;
node() {}
node(int _v, int _d) {
v = _v;
d = _d;
}
bool operator<(const node &a) const { return d > a.d; }
};
priority_queue<node> pq;
bool vis[100011];
int pos[31][2], rs, cs, re, ce, dis[31][100011], lst[31][100011], pth[10000011],
tpth[10011];
char t[100011];
void dijkstra(int s, int *dis, int *lst) {
for (int i = 1; i <= n * m; ++i) dis[i] = 0x3f3f3f3f;
memset(vis, 0, sizeof(vis));
pq.push(node(s, 0));
dis[s] = 0;
lst[s] = -1;
while (!pq.empty()) {
int p = pq.top().v;
pq.pop();
if (vis[p]) continue;
vis[p] = 1;
if (::s[(p - 1) / m + 1][(p - 1) % m + 1] <= 'z' &&
::s[(p - 1) / m + 1][(p - 1) % m + 1] >= 'a' && p != s)
continue;
for (int i = head[p]; ~i; i = e[i].next)
if (dis[e[i].v] > dis[p] + e[i].w)
dis[e[i].v] = dis[p] + e[i].w, lst[e[i].v] = p,
pq.push(node(e[i].v, dis[e[i].v]));
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i) scanf("%s", s[i] + 1);
init();
for (int i = 0; i <= n; ++i) s[i][0] = s[i][m + 1] = '#';
for (int i = 0; i <= m; ++i) s[0][i] = s[n + 1][i] = '#';
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
for (int k = 0; k < 4; ++k)
if (s[i + dxy[k][0]][j + dxy[k][1]] != '#')
insert(((i - 1) * m + j), ((i + dxy[k][0] - 1) * m + j + dxy[k][1]),
s[i][j] >= '0' && s[i][j] <= '9' ? s[i][j] - '0' : 1);
}
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (s[i][j] >= 'a' && s[i][j] <= 'z')
pos[s[i][j] - 'a' + 1][0] = i, pos[s[i][j] - 'a' + 1][1] = j;
scanf("%d%d%s%d%d", &rs, &cs, t + 1, &re, &ce);
pos[27][0] = rs;
pos[27][1] = cs;
pos[28][0] = re;
pos[28][1] = ce;
for (int i = 1; i <= 28; ++i)
if (pos[i][0]) dijkstra(((pos[i][0] - 1) * m + pos[i][1]), dis[i], lst[i]);
int q = strlen(t + 1);
t[0] = 'a' + 26;
t[++q] = 'a' + 27;
for (int i = 1; i <= q; ++i) {
int u = ((pos[t[i] - 'a' + 1][0] - 1) * m + pos[t[i] - 'a' + 1][1]), tn = 0;
while (~u) {
tpth[++tn] = u;
u = lst[t[i - 1] - 'a' + 1][u];
}
for (int j = tn - 1; j; --j) pth[++pn] = tpth[j];
}
pth[0] = ((rs - 1) * m + cs);
int cur = 0, ans = pn;
for (int i = 0; i <= pn; ++i) {
char c = s[(pth[i] - 1) / m + 1][(pth[i] - 1) % m + 1];
cur += c >= '0' && c <= '9' ? c - '0' : 1;
if (cur > k) {
ans = i;
break;
}
}
printf("%d %d\n", (pth[ans] - 1) / m + 1, (pth[ans] - 1) % m + 1);
return 0;
}
|
You've got an array, consisting of n integers: a1, a2, ..., an. Your task is to quickly run the queries of two types:
1. Assign value x to all elements from l to r inclusive. After such query the values of the elements of array al, al + 1, ..., ar become equal to x.
2. Calculate and print sum <image>, where k doesn't exceed 5. As the value of the sum can be rather large, you should print it modulo 1000000007 (109 + 7).
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105), showing, how many numbers are in the array and the number of queries, correspondingly. The second line contains n integers: a1, a2, ..., an (0 ≤ ai ≤ 109) — the initial values of the array elements.
Then m queries follow, one per line:
1. The assign query has the following format: "<image>", (1 ≤ l ≤ r ≤ n; 0 ≤ x ≤ 109).
2. The query to calculate the sum has the following format: "<image>", (1 ≤ l ≤ r ≤ n; 0 ≤ k ≤ 5).
All numbers in the input are integers.
Output
For each query to calculate the sum print an integer — the required sum modulo 1000000007 (109 + 7).
Examples
Input
4 5
5 10 2 1
? 1 2 1
= 2 2 0
? 2 4 3
= 1 4 1
? 1 4 5
Output
25
43
1300
Input
3 1
1000000000 1000000000 1000000000
? 1 3 0
Output
999999986
|
#include <bits/stdc++.h>
using namespace std;
int c[100005][6][6];
const int modo = 1000000007;
int sum[100005][6];
int val[1 << 18][6];
int a[100005];
int tag[1 << 18];
void updates(int num, int delta) {
register int i;
for (i = 0; i <= 5; i++) {
val[num][i] = val[num * 2 + 1][i];
int j;
for (j = 0; j <= i; j++) {
val[num][i] =
(val[num][i] + (long long)val[num * 2 + 2][j] * c[delta][i][j]) %
modo;
}
}
}
int sums;
int k;
void update(int num, int delta) {
int j;
for (j = 0; j <= k; j++) {
sums = (sums + (long long)val[num][j] * c[delta][k][j]) % modo;
}
}
void push_down(int num, int l, int mid, int r) {
if (tag[num] == -1) return;
int i;
for (i = 0; i <= 5; i++) {
val[num * 2 + 1][i] = (long long)sum[mid - l][i] * tag[num] % modo;
val[num * 2 + 2][i] = (long long)sum[r - mid][i] * tag[num] % modo;
}
tag[num * 2 + 1] = tag[num];
tag[num * 2 + 2] = tag[num];
tag[num] = -1;
}
void build_tree(int num, int l, int r) {
tag[num] = -1;
if (l == r - 1) {
int i;
for (i = 0; i <= 5; i++) {
val[num][i] = a[l];
}
return;
}
int mid = (l + r) / 2;
build_tree(num * 2 + 1, l, mid);
build_tree(num * 2 + 2, mid, r);
updates(num, mid - l);
}
void change(int num, int l, int r, int l0, int r0, int vals) {
if ((l0 <= l) && (r <= r0)) {
tag[num] = vals;
int i;
for (i = 0; i <= 5; i++) {
val[num][i] = (long long)sum[r - l][i] * vals % modo;
}
return;
}
int mid = (l + r) / 2;
push_down(num, l, mid, r);
if (l0 < mid) change(num * 2 + 1, l, mid, l0, r0, vals);
if (mid < r0) change(num * 2 + 2, mid, r, l0, r0, vals);
updates(num, mid - l);
}
void query(int num, int l, int r, int l0, int r0) {
if ((l0 <= l) && (r <= r0)) {
update(num, l - l0);
return;
}
int mid = (l + r) / 2;
push_down(num, l, mid, r);
if (l0 < mid) query(num * 2 + 1, l, mid, l0, r0);
if (mid < r0) query(num * 2 + 2, mid, r, l0, r0);
}
int main() {
int i;
for (i = 0; i <= 100000; i++) {
int j;
for (j = 0; j <= 5; j++) {
int k;
c[i][j][0] = 1;
for (k = 1; k <= j; k++) {
c[i][j][k] = c[i][j - 1][k] + c[i][j - 1][k - 1];
if (c[i][j][k] >= modo) c[i][j][k] -= modo;
}
}
for (j = 0; j <= 5; j++) {
int k;
c[i][j][0] = 1;
int p = 1;
for (k = j; k >= 0; k--) {
c[i][j][k] = (long long)c[i][j][k] * p % modo;
p = (long long)p * i % modo;
}
}
}
for (i = 1; i <= 100000; i++) {
int j;
int p = 1;
for (j = 0; j <= 5; j++) {
sum[i][j] = sum[i - 1][j] + p;
if (sum[i][j] >= modo) sum[i][j] -= modo;
p = (long long)p * i % modo;
}
}
int n;
scanf("%d", &n);
int q;
scanf("%d", &q);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
build_tree(0, 0, n);
for (i = 0; i < q; i++) {
static char b[15];
scanf("%s", b);
int l, r, z;
scanf("%d%d%d", &l, &r, &z);
l--;
if (b[0] == '=') {
change(0, 0, n, l, r, z);
} else {
sums = 0;
k = z;
query(0, 0, n, l, r);
printf("%d\n", sums);
}
}
return 0;
}
|
How horrible! The empire of galactic chickens tries to conquer a beautiful city «Z», they have built a huge incubator that produces millions of chicken soldiers a day, and fenced it around. The huge incubator looks like a poligon on the the plane Oxy with n vertices. Naturally, DravDe can't keep still, he wants to destroy the chicken empire. For sure, he will start with the incubator.
DravDe is strictly outside the incubator's territory in point A(xa, ya), and wants to get inside and kill all the chickens working there. But it takes a lot of doing! The problem is that recently DravDe went roller skating and has broken both his legs. He will get to the incubator's territory in his jet airplane LEVAP-41.
LEVAP-41 flies at speed V(xv, yv, zv). DravDe can get on the plane in point A, fly for some time, and then air drop himself. DravDe is very heavy, that's why he falls vertically at speed Fdown, but in each point of his free fall DravDe can open his parachute, and from that moment he starts to fall at the wind speed U(xu, yu, zu) until he lands. Unfortunately, DravDe isn't good at mathematics. Would you help poor world's saviour find such an air dropping plan, that allows him to land on the incubator's territory? If the answer is not unique, DravDe wants to find the plan with the minimum time of his flight on the plane. If the answers are still multiple, he wants to find the one with the minimum time of his free fall before opening his parachute
Input
The first line contains number n (3 ≤ n ≤ 104) — amount of vertices of the fence. Then there follow n lines containing the coordinates of these vertices (two integer numbers xi, yi) in clockwise or counter-clockwise order. It's guaranteed, that the fence does not contain self-intersections.
The following four lines contain coordinates of point A(xa, ya), speeds V(xv, yv, zv), Fdown and speed U(xu, yu, zu). All the input numbers are integer. All the coordinates don't exceed 104 in absolute value. It's guaranteed, that zv > 0 and Fdown, zu < 0, and point A is strictly outside the incubator's territory.
Output
In the first line output two numbers t1, t2 such, that if DravDe air drops at time t1 (counting from the beginning of the flight), he lands on the incubator's territory (landing on the border is regarder as landing on the territory). If DravDe doesn't open his parachute, the second number should be equal to the duration of DravDe's falling down. If it's impossible for DravDe to get to the incubator's territory, output -1 -1. If the answer is not unique, output the answer with the minimum t1. If the answers are still multiple, output the answer with the minimum t2. Your answer must have an absolute or relative error less than 10 - 6.
Examples
Input
4
0 0
1 0
1 1
0 1
0 -1
1 0 1
-1
0 1 -1
Output
1.00000000 0.00000000
Input
4
0 0
0 1
1 1
1 0
0 -1
-1 -1 1
-1
0 1 -1
Output
-1.00000000 -1.00000000
Input
4
0 0
1 0
1 1
0 1
0 -1
1 1 1
-1
1 1 -1
Output
0.50000000 0.00000000
|
#include <bits/stdc++.h>
using namespace std;
struct Point {
double x, y;
Point operator*(double cof) {
Point ret;
ret.x = x * cof;
ret.y = y * cof;
return ret;
}
Point operator+(Point other) {
Point ret;
ret.x = x + other.x;
ret.y = y + other.y;
return ret;
}
Point operator-(Point other) {
Point ret;
ret.x = x - other.x;
ret.y = y - other.y;
return ret;
}
};
struct Ray {
Point start, speed;
};
struct Segment {
Point start, ending;
};
struct Line {
Point start, dir0, dir1;
};
struct Triangle {
Point a, b, c;
};
const double error = 1e-9;
const int MAXN = 10000;
Point polygon[MAXN];
Point A, V, U;
double Vz, Fdown, Uz;
Ray r0, r1;
Line line0;
double r0_t, r1_t, line0_t;
int n;
bool Equals(double val0, double val1) {
double tem = fabs(val0 - val1);
return tem < error;
}
double CrossProduct(Point a, Point b) { return (a.x * b.y - a.y * b.x); }
double dist(Point a, Point b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
bool InSegment(Point test, Point a, Point b) {
double tem = CrossProduct(a - test, b - test);
if (a.x > b.x) swap(a.x, b.x);
if (a.y > b.y) swap(a.y, b.y);
return Equals(tem, 0) && (a.x - error <= test.x && test.x <= b.x + error &&
a.y - error <= test.y && test.y <= b.y + error);
}
double CheckRayCrossSegment(Ray ray, Segment seg) {
double tem = (seg.start.x - seg.ending.x) * ray.speed.y -
(seg.start.y - seg.ending.y) * ray.speed.x;
if (Equals(tem, 0))
return -1;
else {
double t = (seg.start.y - seg.ending.y) * ray.start.x +
(seg.start.x * seg.ending.y - seg.ending.x * seg.start.y) -
(seg.start.x - seg.ending.x) * ray.start.y;
t /= tem;
if (t < 0) return -1;
Point p = (ray.start + (ray.speed * t));
if (InSegment(p, seg.start, seg.ending))
return t;
else
return -1;
}
}
double CheckRayCrossPolygon(Ray ray) {
double minv = DBL_MAX;
for (int i = 0; i < n; i++) {
Segment s;
s.start = polygon[i];
s.ending = polygon[(i + 1) % n];
double val = CheckRayCrossSegment(ray, s);
if (val > 0) minv = min(minv, val);
}
return minv;
}
bool IsTriangle(Triangle tr) {
return !Equals(CrossProduct(tr.a - tr.b, tr.a - tr.c), 0);
}
bool InTriangle(Point p, Triangle tr) {
if (!IsTriangle(tr)) return false;
double cro0 = CrossProduct(tr.a - p, tr.b - p);
double cro1 = CrossProduct(tr.b - p, tr.c - p);
double cro2 = CrossProduct(tr.c - p, tr.a - p);
if (InSegment(p, tr.a, tr.b) || InSegment(p, tr.b, tr.c) ||
InSegment(p, tr.c, tr.a))
return true;
if (cro0 * cro1 < 0 || cro1 * cro2 < 0 || cro2 * cro0 < 0) return false;
return true;
}
double CheckLineCrossPoint(Line line, Point p) {
double ansmin = 0, ansmax = 1e100;
Point tem0, tem1;
Triangle tr;
tr.a = line.start + (line.dir0 * ansmax);
tr.b = line.start + (line.dir1 * ansmax);
tr.c = line.start;
if (!InTriangle(p, tr)) return -1;
while (!Equals(ansmin, ansmax)) {
double ansmid = (ansmin + ansmax) / 2;
tr.a = line.start + (line.dir0 * ansmid);
tr.b = line.start + (line.dir1 * ansmid);
tr.c = line.start;
if (InTriangle(p, tr))
ansmax = ansmid;
else
ansmin = ansmid;
}
return ansmax;
}
double CheckLineCrossPolygonPoint(Line line, double &line_t_tem) {
double minv = DBL_MAX;
for (int i = 0; i < n; i++) {
Point s;
s = polygon[i];
double deltab = CheckLineCrossPoint(line, s);
if (deltab > 0) {
if (deltab < minv) {
minv = deltab;
if (!Equals(U.x, 0))
line_t_tem =
(deltab * Vz -
(fabs(line.start.x + line.dir0.x * deltab - s.x) / fabs(U.x)) *
-Uz) /
-Fdown;
else
line_t_tem =
(deltab * Vz -
(fabs(line.start.y + line.dir0.y * deltab - s.y) / fabs(U.y)) *
-Uz) /
-Fdown;
}
}
}
return minv;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lf%lf", &(polygon[i].x), &(polygon[i].y));
scanf("%lf%lf", &(A.x), &(A.y));
scanf("%lf%lf%lf", &(V.x), &(V.y), &(Vz));
scanf("%lf", &(Fdown));
scanf("%lf%lf%lf", &(U.x), &(U.y), &(Uz));
r0.start = A;
r0.speed = V;
r1.start = A;
r1.speed = (V + (U * (Vz / -Uz)));
line0.start = A;
line0.dir0 = r0.speed;
line0.dir1 = r1.speed;
double line_t_tem;
r0_t = CheckRayCrossPolygon(r0);
r1_t = CheckRayCrossPolygon(r1);
line0_t = CheckLineCrossPolygonPoint(line0, line_t_tem);
double minval = min(min(r0_t, r1_t), line0_t);
if (Equals(minval, DBL_MAX))
printf("%.9lf %.9lf\n", (double)-1, (double)-1);
else if (Equals(r1_t, minval))
printf("%.9lf %.9lf\n", r1_t, 0);
else if (Equals(r0_t, minval))
printf("%.9lf %.9lf\n", r0_t, r0_t * Vz / -Fdown);
else if (Equals(line0_t, minval)) {
if (Equals(line0_t, r1_t))
printf("%.9lf %.9lf\n", r1_t, 0);
else
printf("%.9lf %.9lf\n", line0_t, line_t_tem);
}
return 0;
}
|
Sereja has a sequence that consists of n positive integers, a1, a2, ..., an.
First Sereja took a piece of squared paper and wrote all distinct non-empty non-decreasing subsequences of sequence a. Then for each sequence written on the squared paper, Sereja wrote on a piece of lines paper all sequences that do not exceed it.
A sequence of positive integers x = x1, x2, ..., xr doesn't exceed a sequence of positive integers y = y1, y2, ..., yr, if the following inequation holds: x1 ≤ y1, x2 ≤ y2, ..., xr ≤ yr.
Now Sereja wonders, how many sequences are written on the lines piece of paper. Help Sereja, find the required quantity modulo 1000000007 (109 + 7).
Input
The first line contains integer n (1 ≤ n ≤ 105). The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106).
Output
In the single line print the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
1
42
Output
42
Input
3
1 2 2
Output
13
Input
5
1 2 3 4 5
Output
719
|
#include <bits/stdc++.h>
using namespace std;
int fen[100005];
int mod = 1000000007;
void upd(int n, int pos, int val) {
for (; pos <= n; pos |= (pos + 1)) {
fen[pos] += val;
if (fen[pos] >= mod) fen[pos] -= mod;
}
}
int fnd(int pos) {
int ret = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) {
ret += fen[pos];
if (ret >= mod) ret -= mod;
}
return ret;
}
pair<int, int> v[100005];
pair<int, int> to[100005];
int main() {
int n, a;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a);
v[i] = make_pair(a, i);
}
sort(v, v + n);
int out = 0;
for (int i = 0; i < n;) {
int val = v[i].first, cnt = 0, mul = val;
int g = 0, last = -1;
while (i < n && v[i].first == val) {
g = (1LL * g * val + (fnd(v[i].second) - fnd(last))) % mod;
if (g < 0) g += mod;
int ans = (mul + 1LL * val * g) % mod;
out += ans;
if (out >= mod) out -= mod;
to[cnt++] = make_pair(v[i].second, ans);
last = v[i].second;
++i;
mul = (1LL * mul * val) % mod;
}
for (int j = 0; j < cnt; ++j) upd(n + 1, to[j].first, to[j].second);
}
printf("%d\n", out);
return 0;
}
|
Paladin Manao caught the trail of the ancient Book of Evil in a swampy area. This area contains n settlements numbered from 1 to n. Moving through the swamp is very difficult, so people tramped exactly n - 1 paths. Each of these paths connects some pair of settlements and is bidirectional. Moreover, it is possible to reach any settlement from any other one by traversing one or several paths.
The distance between two settlements is the minimum number of paths that have to be crossed to get from one settlement to the other one. Manao knows that the Book of Evil has got a damage range d. This means that if the Book of Evil is located in some settlement, its damage (for example, emergence of ghosts and werewolves) affects other settlements at distance d or less from the settlement where the Book resides.
Manao has heard of m settlements affected by the Book of Evil. Their numbers are p1, p2, ..., pm. Note that the Book may be affecting other settlements as well, but this has not been detected yet. Manao wants to determine which settlements may contain the Book. Help him with this difficult task.
Input
The first line contains three space-separated integers n, m and d (1 ≤ m ≤ n ≤ 100000; 0 ≤ d ≤ n - 1). The second line contains m distinct space-separated integers p1, p2, ..., pm (1 ≤ pi ≤ n). Then n - 1 lines follow, each line describes a path made in the area. A path is described by a pair of space-separated integers ai and bi representing the ends of this path.
Output
Print a single number — the number of settlements that may contain the Book of Evil. It is possible that Manao received some controversial information and there is no settlement that may contain the Book. In such case, print 0.
Examples
Input
6 2 3
1 2
1 5
2 3
3 4
4 5
5 6
Output
3
Note
Sample 1. The damage range of the Book of Evil equals 3 and its effects have been noticed in settlements 1 and 2. Thus, it can be in settlements 3, 4 or 5.
<image>
|
import java.util.ArrayList;
import java.util.Scanner;
public class SolutionB {
static int dfs1(int v, int p, int[] maxDistanceDown, boolean marked[], ArrayList<Integer> adj[])
{
maxDistanceDown[v] = marked[v] ? 0 : -1;
for(int i = 0; i < adj[v].size(); i++)
{
int u = adj[v].get(i);
if (u == p) continue;
int d = dfs1(u, v, maxDistanceDown, marked, adj);
if (d > -1)
maxDistanceDown[v] = Math.max(maxDistanceDown[v], d + 1);
}
return maxDistanceDown[v];
}
static void dfs2(int v, int p, int[] maxDistanceUp, int[] maxDistanceDown, boolean marked[], ArrayList<Integer> adj[])
{
int mx1 = -1, mx2 = -1;
for(int i = 0; i < adj[v].size(); i++)
{
int u = adj[v].get(i);
if (u == p) continue;
if (maxDistanceDown[u] > mx1)
{
mx2 = mx1;
mx1 = maxDistanceDown[u];
} else
if (maxDistanceDown[u] > mx2)
{
mx2 = maxDistanceDown[u];
}
}
for(int i = 0; i < adj[v].size(); i++)
{
int u = adj[v].get(i);
if (u == p) continue;
int siblingDistance = maxDistanceDown[u] == mx1 ? mx2 : mx1;
if (siblingDistance != -1)
siblingDistance += 2;
maxDistanceUp[u] = siblingDistance;
if (maxDistanceUp[v] != -1)
maxDistanceUp[u] = Math.max(maxDistanceUp[u], maxDistanceUp[v] + 1);
if (marked[u])
maxDistanceUp[u] = Math.max(maxDistanceUp[u], 0);
dfs2(u, v, maxDistanceUp, maxDistanceDown, marked, adj);
}
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
int d = in.nextInt();
boolean[] marked = new boolean[n];
while(m-- > 0)
{
marked[in.nextInt() - 1] = true;
}
ArrayList<Integer> adj[] = new ArrayList[n];
for(int i = 0; i < n; i++)
adj[i] = new ArrayList<Integer>();
for(int k = 0; k < n - 1; k++)
{
int i = in.nextInt() - 1;
int j = in.nextInt() - 1;
adj[i].add(j);
adj[j].add(i);
}
int[] maxDistanceDown = new int[n];
dfs1(0, -1, maxDistanceDown, marked, adj);
int[] maxDistanceUp = new int[n];
maxDistanceUp[0] = marked[0] ? 0 : -1;
dfs2(0, -1, maxDistanceUp, maxDistanceDown, marked, adj);
int ans = 0;
for(int i = 0; i < n; i++)
ans += (maxDistanceUp[i] <= d && maxDistanceDown[i] <= d ? 1 : 0);
System.out.println(ans);
}
}
|
Levko loves all sorts of sets very much.
Levko has two arrays of integers a1, a2, ... , an and b1, b2, ... , bm and a prime number p. Today he generates n sets. Let's describe the generation process for the i-th set:
1. First it has a single number 1.
2. Let's take any element c from this set. For all j (1 ≤ j ≤ m) if number (c·aibj) mod p doesn't occur in the set, then add it to the set.
3. Repeat step 2 as long as we can add at least one element to our set.
Levko wonders, how many numbers belong to at least one set. That is, he wants to know what size is the union of n generated sets.
Input
The first line contains three integers n, m and p (1 ≤ n ≤ 104, 1 ≤ m ≤ 105, 2 ≤ p ≤ 109), p is prime.
The second line contains space-separated integers a1, a2, ... , an (1 ≤ ai < p). The third line contains space-separated integers b1, b2, ... , bm (1 ≤ bi ≤ 109).
Output
The single number — the size of the union of the sets.
Examples
Input
1 1 7
2
5
Output
3
Input
1 2 7
2
2 4
Output
3
Input
2 1 7
1 6
2
Output
1
Input
2 1 7
1 6
5
Output
2
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m, p;
int a[N], b[N];
int dr[N], dn, r[N], f[N];
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int fpm(int a, int b, int p) {
int w = 1;
for (; b; b >>= 1, a = 1LL * a * a % p)
if (b & 1) w = 1LL * w * a % p;
return w;
}
int main() {
scanf("%d %d %d", &n, &m, &p);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
}
int tb = p - 1;
for (int i = 1; i <= m; ++i) {
scanf("%d", b + i);
tb = gcd(tb, b[i]);
}
for (int x = 1; 1LL * x * x <= p - 1; ++x)
if ((p - 1) % x == 0) {
dr[++dn] = x;
if (x != (p - 1) / x) {
dr[++dn] = (p - 1) / x;
}
}
sort(dr + 1, dr + dn + 1);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= dn; ++j)
if (fpm(a[i], dr[j], p) == 1) {
r[i] = gcd(1LL * (p - 1) / dr[j] * tb % (p - 1), p - 1);
break;
}
sort(r + 1, r + n + 1);
int nn = unique(r + 1, r + n + 1) - r - 1;
int tot = 0;
for (int i = nn; i >= 1; --i) {
f[i] = (p - 1) / r[i];
for (int j = i + 1; j <= nn; ++j)
if (r[j] % r[i] == 0) {
f[i] -= f[j];
}
tot += f[i];
}
printf("%d\n", tot);
}
|
Iahub wants to enhance his multitasking abilities. In order to do this, he wants to sort n arrays simultaneously, each array consisting of m integers.
Iahub can choose a pair of distinct indices i and j (1 ≤ i, j ≤ m, i ≠ j). Then in each array the values at positions i and j are swapped only if the value at position i is strictly greater than the value at position j.
Iahub wants to find an array of pairs of distinct indices that, chosen in order, sort all of the n arrays in ascending or descending order (the particular order is given in input). The size of the array can be at most <image> (at most <image> pairs). Help Iahub, find any suitable array.
Input
The first line contains three integers n (1 ≤ n ≤ 1000), m (1 ≤ m ≤ 100) and k. Integer k is 0 if the arrays must be sorted in ascending order, and 1 if the arrays must be sorted in descending order. Each line i of the next n lines contains m integers separated by a space, representing the i-th array. For each element x of the array i, 1 ≤ x ≤ 106 holds.
Output
On the first line of the output print an integer p, the size of the array (p can be at most <image>). Each of the next p lines must contain two distinct integers i and j (1 ≤ i, j ≤ m, i ≠ j), representing the chosen indices.
If there are multiple correct answers, you can print any.
Examples
Input
2 5 0
1 3 2 5 4
1 4 3 2 5
Output
3
2 4
2 3
4 5
Input
3 2 1
1 2
2 3
3 4
Output
1
2 1
Note
Consider the first sample. After the first operation, the arrays become [1, 3, 2, 5, 4] and [1, 2, 3, 4, 5]. After the second operation, the arrays become [1, 2, 3, 5, 4] and [1, 2, 3, 4, 5]. After the third operation they become [1, 2, 3, 4, 5] and [1, 2, 3, 4, 5].
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, i, j;
cin >> n >> m >> k;
cout << m * (m - 1) / 2 << endl;
if (k) {
for (i = 1; i < m; i++)
for (j = i + 1; j <= m; j++) cout << j << " " << i << endl;
} else {
for (i = 1; i < m; i++)
for (j = i + 1; j <= m; j++) cout << i << " " << j << endl;
}
return 0;
}
|
Little Chris is bored during his physics lessons (too easy), so he has built a toy box to keep himself occupied. The box is special, since it has the ability to change gravity.
There are n columns of toy cubes in the box arranged in a line. The i-th column contains ai cubes. At first, the gravity in the box is pulling the cubes downwards. When Chris switches the gravity, it begins to pull all the cubes to the right side of the box. The figure shows the initial and final configurations of the cubes in the box: the cubes that have changed their position are highlighted with orange.
<image>
Given the initial configuration of the toy cubes in the box, find the amounts of cubes in each of the n columns after the gravity switch!
Input
The first line of input contains an integer n (1 ≤ n ≤ 100), the number of the columns in the box. The next line contains n space-separated integer numbers. The i-th number ai (1 ≤ ai ≤ 100) denotes the number of cubes in the i-th column.
Output
Output n integer numbers separated by spaces, where the i-th number is the amount of cubes in the i-th column after the gravity switch.
Examples
Input
4
3 2 1 2
Output
1 2 2 3
Input
3
2 3 8
Output
2 3 8
Note
The first example case is shown on the figure. The top cube of the first column falls to the top of the last column; the top cube of the second column falls to the top of the third column; the middle cube of the first column falls to the top of the second column.
In the second example case the gravity switch does not change the heights of the columns.
|
cols = int(input(""))
inputs = input("")
inputList = inputs.split(' ')
inputList.sort(key=int)
for i in inputList:
print(i, end=" ")
|
Consider a football tournament where n teams participate. Each team has two football kits: for home games, and for away games. The kit for home games of the i-th team has color xi and the kit for away games of this team has color yi (xi ≠ yi).
In the tournament, each team plays exactly one home game and exactly one away game with each other team (n(n - 1) games in total). The team, that plays the home game, traditionally plays in its home kit. The team that plays an away game plays in its away kit. However, if two teams has the kits of the same color, they cannot be distinguished. In this case the away team plays in its home kit.
Calculate how many games in the described tournament each team plays in its home kit and how many games it plays in its away kit.
Input
The first line contains a single integer n (2 ≤ n ≤ 105) — the number of teams. Next n lines contain the description of the teams. The i-th line contains two space-separated numbers xi, yi (1 ≤ xi, yi ≤ 105; xi ≠ yi) — the color numbers for the home and away kits of the i-th team.
Output
For each team, print on a single line two space-separated integers — the number of games this team is going to play in home and away kits, correspondingly. Print the answers for the teams in the order they appeared in the input.
Examples
Input
2
1 2
2 1
Output
2 0
2 0
Input
3
1 2
2 1
1 3
Output
3 1
4 0
2 2
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] home = new int[n];
int[] guest = new int[n];
int[] home_count = new int[100001];
int[] guest_count = new int[100001];
for (int i = 0; i < n; i++) {
int h = sc.nextInt();
int g = sc.nextInt();
home[i] = h;
guest[i] = g;
home_count[h]++;
guest_count[g]++;
}
for (int i = 0; i < n; i++) {
int playInHomeWhileGuest = home_count[guest[i]];
System.out.println((n - 1 + playInHomeWhileGuest) + " " + (n - 1 - playInHomeWhileGuest));
}
}
}
|
Princess Twilight went to Celestia and Luna's old castle to research the chest from the Elements of Harmony.
<image>
A sequence of positive integers bi is harmony if and only if for every two elements of the sequence their greatest common divisor equals 1. According to an ancient book, the key of the chest is a harmony sequence bi which minimizes the following expression:
<image>
You are given sequence ai, help Princess Twilight to find the key.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of elements of the sequences a and b. The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 30).
Output
Output the key — sequence bi that minimizes the sum described above. If there are multiple optimal sequences, you can output any of them.
Examples
Input
5
1 1 1 1 1
Output
1 1 1 1 1
Input
5
1 6 4 2 8
Output
1 5 3 1 8
|
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;
import java.math.BigInteger;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.io.IOException;
import java.util.Arrays;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.util.Comparator;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author Egor Kulikov (egor@egork.net)
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
TaskB solver = new TaskB();
solver.solve(1, in, out);
out.close();
}
}
class TaskB {
public void solve(int testNumber, InputReader in, OutputWriter out) {
int[] primes = IntegerUtils.generatePrimes(58);
int[] mask = new int[58];
for (int i = 1; i < 58; i++) {
int current = 0;
for (int j = 0; j < 16; j++) {
if (i % primes[j] == 0) {
current += 1 << j;
}
}
mask[i] = current;
}
int count = in.readInt();
int[] base = IOUtils.readIntArray(in, count);
int[][] answer = new int[count + 1][1 << 16];
int[][] last = new int[count + 1][1 << 16];
ArrayUtils.fill(answer, Integer.MAX_VALUE);
answer[0][0] = 0;
for (int i = 0; i < count; i++) {
for (int j = 0; j < (1 << 16); j++) {
if (answer[i][j] == Integer.MAX_VALUE) {
continue;
}
for (int k = 1; k < 58; k++) {
if ((j & mask[k]) == 0) {
if (answer[i + 1][j + mask[k]] > answer[i][j] + Math.abs(k - base[i])) {
answer[i + 1][j + mask[k]] = answer[i][j] + Math.abs(k - base[i]);
last[i + 1][j + mask[k]] = k;
}
}
}
}
}
int at = ArrayUtils.minPosition(answer[count]);
int[] result = new int[count];
for (int i = count; i > 0; i--) {
result[i - 1] = last[i][at];
at -= mask[last[i][at]];
}
out.printLine(result);
}
}
class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public int readInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void print(int[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0)
writer.print(' ');
writer.print(array[i]);
}
}
public void printLine(int[] array) {
print(array);
writer.println();
}
public void close() {
writer.close();
}
}
class IntegerUtils {
public static int[] generatePrimes(int upTo) {
int[] isPrime = generateBitPrimalityTable(upTo);
IntList primes = new IntArrayList();
for (int i = 0; i < upTo; i++) {
if ((isPrime[i >> 5] >>> (i & 31) & 1) == 1)
primes.add(i);
}
return primes.toArray();
}
public static int[] generateBitPrimalityTable(int upTo) {
int[] isPrime = new int[(upTo + 31) >> 5];
if (upTo < 2)
return isPrime;
Arrays.fill(isPrime, -1);
isPrime[0] &= -4;
for (int i = 2; i * i < upTo; i++) {
if ((isPrime[i >> 5] >>> (i & 31) & 1) == 1) {
for (int j = i * i; j < upTo; j += i)
isPrime[j >> 5] &= -1 - (1 << (j & 31));
}
}
return isPrime;
}
}
class IOUtils {
public static int[] readIntArray(InputReader in, int size) {
int[] array = new int[size];
for (int i = 0; i < size; i++)
array[i] = in.readInt();
return array;
}
}
class ArrayUtils {
public static void fill(int[][] array, int value) {
for (int[] row : array)
Arrays.fill(row, value);
}
public static int minPosition(int[] array) {
return minPosition(array, 0, array.length);
}
public static int minPosition(int[] array, int from, int to) {
if (from >= to)
return -1;
int min = array[from];
int result = from;
for (int i = from + 1; i < to; i++) {
if (array[i] < min) {
min = array[i];
result = i;
}
}
return result;
}
}
abstract class IntCollection {
public abstract IntIterator iterator();
public abstract int size();
public abstract void add(int value);
public int[] toArray() {
int size = size();
int[] array = new int[size];
int i = 0;
for (IntIterator iterator = iterator(); iterator.isValid(); iterator.advance())
array[i++] = iterator.value();
return array;
}
public void addAll(IntCollection values) {
for (IntIterator it = values.iterator(); it.isValid(); it.advance()) {
add(it.value());
}
}
}
interface IntIterator {
public int value() throws NoSuchElementException;
/*
* @throws NoSuchElementException only if iterator already invalid
*/
public void advance() throws NoSuchElementException;
public boolean isValid();
}
abstract class IntList extends IntCollection implements Comparable<IntList> {
public abstract int get(int index);
public IntIterator iterator() {
return new IntIterator() {
private int size = size();
private int index = 0;
public int value() throws NoSuchElementException {
if (!isValid())
throw new NoSuchElementException();
return get(index);
}
public void advance() throws NoSuchElementException {
if (!isValid())
throw new NoSuchElementException();
index++;
}
public boolean isValid() {
return index < size;
}
};
}
public int hashCode() {
int hashCode = 1;
for (IntIterator i = iterator(); i.isValid(); i.advance())
hashCode = 31 * hashCode + i.value();
return hashCode;
}
public boolean equals(Object obj) {
if (!(obj instanceof IntList))
return false;
IntList list = (IntList)obj;
if (list.size() != size())
return false;
IntIterator i = iterator();
IntIterator j = list.iterator();
while (i.isValid()) {
if (i.value() != j.value())
return false;
i.advance();
j.advance();
}
return true;
}
public int compareTo(IntList o) {
IntIterator i = iterator();
IntIterator j = o.iterator();
while (true) {
if (i.isValid()) {
if (j.isValid()) {
if (i.value() != j.value()) {
if (i.value() < j.value())
return -1;
else
return 1;
}
} else
return 1;
} else {
if (j.isValid())
return -1;
else
return 0;
}
i.advance();
j.advance();
}
}
}
class IntArrayList extends IntList {
private int[] array;
private int size;
public IntArrayList() {
this(10);
}
public IntArrayList(int capacity) {
array = new int[capacity];
}
public IntArrayList(IntList list) {
this(list.size());
addAll(list);
}
public int get(int index) {
if (index >= size)
throw new IndexOutOfBoundsException();
return array[index];
}
public int size() {
return size;
}
public void add(int value) {
ensureCapacity(size + 1);
array[size++] = value;
}
public void ensureCapacity(int newCapacity) {
if (newCapacity > array.length) {
int[] newArray = new int[Math.max(newCapacity, array.length << 1)];
System.arraycopy(array, 0, newArray, 0, size);
array = newArray;
}
}
public int[] toArray() {
int[] array = new int[size];
System.arraycopy(this.array, 0, array, 0, size);
return array;
}
}
|
Dreamoon likes to play with sets, integers and <image>. <image> is defined as the largest positive integer that divides both a and b.
Let S be a set of exactly four distinct integers greater than 0. Define S to be of rank k if and only if for all pairs of distinct elements si, sj from S, <image>.
Given k and n, Dreamoon wants to make up n sets of rank k using integers from 1 to m such that no integer is used in two different sets (of course you can leave some integers without use). Calculate the minimum m that makes it possible and print one possible solution.
Input
The single line of the input contains two space separated integers n, k (1 ≤ n ≤ 10 000, 1 ≤ k ≤ 100).
Output
On the first line print a single integer — the minimal possible m.
On each of the next n lines print four space separated integers representing the i-th set.
Neither the order of the sets nor the order of integers within a set is important. If there are multiple possible solutions with minimal m, print any one of them.
Examples
Input
1 1
Output
5
1 2 3 5
Input
2 2
Output
22
2 4 6 22
14 18 10 16
Note
For the first example it's easy to see that set {1, 2, 3, 4} isn't a valid set of rank 1 since <image>.
|
#include <bits/stdc++.h>
using namespace std;
int a[4] = {1, 2, 3, 5};
int main(void) {
int n, k;
scanf("%d%d", &n, &k);
printf("%d\n", (5 + 6 * (n - 1)) * k);
for (int i = 0; i < n; i++) {
printf("%d %d %d %d\n", (a[0] + 6 * i) * k, (a[1] + 6 * i) * k,
(a[2] + 6 * i) * k, (a[3] + 6 * i) * k);
}
}
|
A new e-mail service "Berlandesk" is going to be opened in Berland in the near future. The site administration wants to launch their project as soon as possible, that's why they ask you to help. You're suggested to implement the prototype of site registration system. The system should work on the following principle.
Each time a new user wants to register, he sends to the system a request with his name. If such a name does not exist in the system database, it is inserted into the database, and the user gets the response OK, confirming the successful registration. If the name already exists in the system database, the system makes up a new user name, sends it to the user as a prompt and also inserts the prompt into the database. The new name is formed by the following rule. Numbers, starting with 1, are appended one after another to name (name1, name2, ...), among these numbers the least i is found so that namei does not yet exist in the database.
Input
The first line contains number n (1 ≤ n ≤ 105). The following n lines contain the requests to the system. Each request is a non-empty line, and consists of not more than 32 characters, which are all lowercase Latin letters.
Output
Print n lines, which are system responses to the requests: OK in case of successful registration, or a prompt with a new name, if the requested name is already taken.
Examples
Input
4
abacaba
acaba
abacaba
acab
Output
OK
OK
abacaba1
OK
Input
6
first
first
second
second
third
third
Output
OK
first1
OK
second1
OK
third1
|
names = {}
N = int(raw_input())
for n in range(N):
name = raw_input().strip()
try:
names[name] += 1
print name+str(names[name])
except:
names[name] = 0
print 'OK'
|
Pasha got a very beautiful string s for his birthday, the string consists of lowercase Latin letters. The letters in the string are numbered from 1 to |s| from left to right, where |s| is the length of the given string.
Pasha didn't like his present very much so he decided to change it. After his birthday Pasha spent m days performing the following transformations on his string — each day he chose integer ai and reversed a piece of string (a segment) from position ai to position |s| - ai + 1. It is guaranteed that 2·ai ≤ |s|.
You face the following task: determine what Pasha's string will look like after m days.
Input
The first line of the input contains Pasha's string s of length from 2 to 2·105 characters, consisting of lowercase Latin letters.
The second line contains a single integer m (1 ≤ m ≤ 105) — the number of days when Pasha changed his string.
The third line contains m space-separated elements ai (1 ≤ ai; 2·ai ≤ |s|) — the position from which Pasha started transforming the string on the i-th day.
Output
In the first line of the output print what Pasha's string s will look like after m days.
Examples
Input
abcdef
1
2
Output
aedcbf
Input
vwxyz
2
2 2
Output
vwxyz
Input
abcdef
3
1 2 3
Output
fbdcea
|
import java.io.*;
import java.util.*;
public class CF_530B {
public static void main(String[] args) throws IOException {
new CF_530B().solve();
}
void solve() throws IOException{
InputStream in = System.in;
PrintStream out = System.out;
// in = new FileInputStream("in.txt");
// out = new PrintStream("out.txt");
//
Scanner sc=new Scanner(in);
String s=sc.next();
StringBuilder sb=new StringBuilder(s);
boolean[] change=new boolean[s.length()];
int n=sc.nextInt();
for (int i=0;i<n;i++){
int a=sc.nextInt()-1;
change[a]=!change[a];
}
// System.out.println(Arrays.toString(change));
boolean toChange=false;
for (int i=0; i<sb.length()/2;i++){
if (change[i]) toChange=!toChange;
if (toChange){
int to=sb.length()-1-i;
char temp=sb.charAt(i);
sb.setCharAt(i, sb.charAt(to));
sb.setCharAt(to,temp);
}
}
out.println(sb.toString());
}
}
|
You are given a non-negative integer n, its decimal representation consists of at most 100 digits and doesn't contain leading zeroes.
Your task is to determine if it is possible in this case to remove some of the digits (possibly not remove any digit at all) so that the result contains at least one digit, forms a non-negative integer, doesn't have leading zeroes and is divisible by 8. After the removing, it is forbidden to rearrange the digits.
If a solution exists, you should print it.
Input
The single line of the input contains a non-negative integer n. The representation of number n doesn't contain any leading zeroes and its length doesn't exceed 100 digits.
Output
Print "NO" (without quotes), if there is no such way to remove some digits from number n.
Otherwise, print "YES" in the first line and the resulting number after removing digits from number n in the second line. The printed number must be divisible by 8.
If there are multiple possible answers, you may print any of them.
Examples
Input
3454
Output
YES
344
Input
10
Output
YES
0
Input
111111
Output
NO
|
from itertools import combinations
def solve():
n="00"+input()
for s in (int(n[i]+n[j]+n[k]) for i,j,k in combinations(range(len(n)),3)):
if s%8==0:
print("YES\n{}".format(s))
exit(0)
print("NO")
solve()
|
A tree of size n is an undirected connected graph consisting of n vertices without cycles.
Consider some tree with n vertices. We call a tree invariant relative to permutation p = p1p2... pn, if for any two vertices of the tree u and v the condition holds: "vertices u and v are connected by an edge if and only if vertices pu and pv are connected by an edge".
You are given permutation p of size n. Find some tree size n, invariant relative to the given permutation.
Input
The first line contains number n (1 ≤ n ≤ 105) — the size of the permutation (also equal to the size of the sought tree).
The second line contains permutation pi (1 ≤ pi ≤ n).
Output
If the sought tree does not exist, print "NO" (without the quotes).
Otherwise, print "YES", and then print n - 1 lines, each of which contains two integers — the numbers of vertices connected by an edge of the tree you found. The vertices are numbered from 1, the order of the edges and the order of the vertices within the edges does not matter.
If there are multiple solutions, output any of them.
Examples
Input
4
4 3 2 1
Output
YES
4 1
4 2
1 3
Input
3
3 1 2
Output
NO
Note
In the first sample test a permutation transforms edge (4, 1) into edge (1, 4), edge (4, 2) into edge (1, 3) and edge (1, 3) into edge (4, 2). These edges all appear in the resulting tree.
It can be shown that in the second sample test no tree satisfies the given condition.
|
#include <bits/stdc++.h>
using namespace std;
void read_file(bool outToFile = true) {}
int n, m;
int p[100000 + 9];
vector<vector<int> > cycle;
bool vis[100000 + 9];
void DFS(int i) {
vis[i] = true;
cycle[m].push_back(i);
if (!vis[p[i]]) DFS(p[i]);
}
int main() {
read_file();
while (cin >> n) {
int chosen = -1;
for (int i = 0; i < n; i++)
cin >> p[i], p[i]--, chosen = (chosen == -1 && i == p[i]) ? i : chosen;
if (chosen != -1) {
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
if (i == chosen) continue;
cout << chosen + 1 << ' ' << i + 1 << endl;
}
continue;
}
memset(vis, false, sizeof vis);
cycle.clear();
m = 0;
for (int i = 0; i < n; i++) {
if (!vis[i] && p[i] != i) {
cycle.push_back(vector<int>());
DFS(i);
m++;
}
}
bool canWe = true;
for (int i = 0; i < m && canWe; i++)
if (cycle[i].size() % 2 != 0) canWe = false;
if (!canWe) {
cout << "NO" << endl;
continue;
}
canWe = false;
for (int i = 0; i < m && !canWe; i++)
if (cycle[i].size() == 2) canWe = true, chosen = i;
if (!canWe) {
cout << "NO" << endl;
continue;
}
cout << "YES" << endl;
cout << cycle[chosen][0] + 1 << ' ' << cycle[chosen][1] + 1 << endl;
for (int i = 0; i < m; i++) {
if (i == chosen) continue;
for (int j = 0; j < cycle[i].size(); j += 2) {
cout << cycle[chosen][0] + 1 << ' ' << cycle[i][j] + 1 << endl;
cout << cycle[chosen][1] + 1 << ' ' << cycle[i][j + 1] + 1 << endl;
}
}
}
}
|
Marina loves Sasha. But she keeps wondering whether Sasha loves her. Of course, the best way to know it is fortune telling. There are many ways of telling fortune, but Marina has picked the easiest one. She takes in her hand one or several camomiles and tears off the petals one by one. After each petal she pronounces alternatively "Loves" and "Doesn't love", at that Marina always starts with "Loves". There are n camomiles growing in the field, possessing the numbers of petals equal to a1, a2, ... an. Marina wants to pick a bouquet with the maximal possible total number of petals so that the result would still be "Loves". Help her do that; find the maximal number of petals possible in the bouquet.
Input
The first line contains an integer n (1 ≤ n ≤ 100), which is the number of flowers growing in the field. The second line contains n integers ai (1 ≤ ai ≤ 100) which represent the number of petals on a given i-th camomile.
Output
Print a single number which is the maximal number of petals in the bouquet, the fortune telling on which would result in "Loves". If there are no such bouquet, print 0 instead. The bouquet may consist of a single flower.
Examples
Input
1
1
Output
1
Input
1
2
Output
0
Input
3
5 6 7
Output
13
|
//package CF;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class A{
public static void main(String[] args) throws NumberFormatException, IOException{
Scanner bf = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
int n = bf.nextInt();
int ans = 0;
int minO = -1;
int numO = 0;
for (int i = 0; i < n; i++)
{
int num = bf.nextInt();
ans += num;
if((num&1)!=0){numO++; minO = minO==-1?num:Math.min(minO, num);}
}
if((numO&1)==0) ans-=minO;
if(numO==0) ans = 0;
out.println(ans);
out.flush();
out.close();
}
static class Scanner{
BufferedReader bf;
StringTokenizer st;
public Scanner(InputStream i){
bf = new BufferedReader(new InputStreamReader(System.in));
}
public int nextInt() throws NumberFormatException, IOException{
return Integer.parseInt(next());
}
public String next() throws IOException{
while(st== null || !st.hasMoreTokens())
st = new StringTokenizer(bf.readLine());
return st.nextToken();
}
public String nextLine() throws IOException{
return bf.readLine();
}
}
}
|
You are given an array with n integers ai and m queries. Each query is described by two integers (lj, rj).
Let's define the function <image>. The function is defined for only u ≤ v.
For each query print the maximal value of the function f(ax, ay) over all lj ≤ x, y ≤ rj, ax ≤ ay.
Input
The first line contains two integers n, m (1 ≤ n ≤ 5·104, 1 ≤ m ≤ 5·103) — the size of the array and the number of the queries.
The second line contains n integers ai (1 ≤ ai ≤ 106) — the elements of the array a.
Each of the next m lines contains two integers lj, rj (1 ≤ lj ≤ rj ≤ n) – the parameters of the j-th query.
Output
For each query print the value aj on a separate line — the maximal value of the function f(ax, ay) over all lj ≤ x, y ≤ rj, ax ≤ ay.
Examples
Input
6 3
1 2 3 4 5 6
1 6
2 5
3 4
Output
7
7
7
Input
1 1
1
1 1
Output
1
Input
6 20
10 21312 2314 214 1 322
1 1
1 2
1 3
1 4
1 5
1 6
2 2
2 3
2 4
2 5
2 6
3 4
3 5
3 6
4 4
4 5
4 6
5 5
5 6
6 6
Output
10
21313
21313
21313
21313
21313
21312
21313
21313
21313
21313
2314
2315
2315
214
215
323
1
323
322
|
#include <bits/stdc++.h>
using namespace std;
const int tam = 100010;
const int MOD = 1000000007;
const int MOD1 = 998244353;
const double EPS = 1e-9;
const double PI = acos(-1);
const int sq = 225;
int ar[tam];
int res[tam];
bool comp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
if (a.first.first / sq == b.first.first / sq)
return a.first.second < b.first.second;
return a.first.first / sq < b.first.first / sq;
}
struct trie {
int maxo, mino, nam;
trie* ce;
trie* un;
trie() {
ce = un = NULL;
maxo = 0;
mino = MOD;
}
};
typedef trie* ptrie;
void del(ptrie t) {
if (t) {
del(t->ce);
del(t->un);
delete t;
}
}
void add(string& second, int ind, int num, ptrie t, int nam) {
if (ind < second.size()) {
ptrie go;
if (second[ind] == '0') {
if (t->ce == NULL) t->ce = new trie();
go = t->ce;
} else {
if (t->un == NULL) t->un = new trie();
go = t->un;
}
add(second, ind + 1, num, go, nam);
} else
t->nam = nam;
t->maxo = max(max(t->ce ? t->ce->maxo : 0, t->un ? t->un->maxo : 0), num);
t->mino = min(min(t->ce ? t->ce->mino : MOD, t->un ? t->un->mino : MOD), num);
}
int ask1(string& second, int ind, int num, ptrie t) {
if (ind == second.size()) return t->nam;
ptrie go;
if (second[ind] == '0') {
if (t->un != NULL && t->un->maxo > num)
go = t->un;
else if (t->ce != NULL && t->ce->maxo > num)
go = t->ce;
else
return -1;
} else {
if (t->ce != NULL && t->ce->maxo > num)
go = t->ce;
else if (t->un != NULL && t->un->maxo > num)
go = t->un;
else
return -1;
}
return ask1(second, ind + 1, num, go);
}
int ask2(string& second, int ind, int num, ptrie t) {
if (ind == second.size()) return t->nam;
ptrie go;
if (second[ind] == '0') {
if (t->un != NULL && t->un->mino < num)
go = t->un;
else if (t->ce != NULL && t->ce->mino < num)
go = t->ce;
else
return -1;
} else {
if (t->ce != NULL && t->ce->mino < num)
go = t->ce;
else if (t->un != NULL && t->un->mino < num)
go = t->un;
else
return -1;
}
return ask2(second, ind + 1, num, go);
}
string tost(int n) {
string res = "";
while (n > 0) {
res += (n % 2) + '0';
n /= 2;
}
while (res.size() < 22) res += '0';
reverse((res).begin(), (res).end());
return res;
}
int xo[1000010];
int ros[tam];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int i = 1; i < 1000010; i++) xo[i] = xo[i - 1] ^ i;
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> ar[i];
int a, b;
vector<pair<pair<int, int>, int>> que;
ptrie t1 = 0, t2 = 0;
int ras;
string s1, s2;
int x, y, x1, y1;
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--;
b--;
if (b - a < sq) {
del(t1);
del(t2);
t1 = new trie();
t2 = new trie();
ras = 0;
for (int i = a; i < b + 1; i++) {
x = ar[i] - 1;
y = ar[i];
s1 = tost(xo[x]);
s2 = tost(xo[y]);
add(s1, 0, x, t2, xo[x]);
add(s2, 0, y, t1, xo[y]);
x1 = ask1(s1, 0, x, t1);
y1 = ask2(s2, 0, y, t2);
ras = max(ras,
max(xo[x] ^ ask1(s1, 0, x, t1), xo[y] ^ ask2(s2, 0, y, t2)));
}
res[i] = ras;
} else
que.push_back({{a, b}, i});
}
sort((que).begin(), (que).end(), comp);
int level = 0;
int nu = sq;
while (nu <= n) {
for (int i = nu - 1; i > nu - sq - 1; i--) {
ros[i] = ros[i + 1];
for (int j = i; j < nu; j++)
ros[i] = max(ros[i], ar[i] > ar[j] ? xo[ar[i]] ^ xo[ar[j] - 1]
: xo[ar[i] - 1] ^ xo[ar[j]]);
}
nu += sq;
}
int divo = -1, lasto = -1, rus;
for (int i = 0; i < que.size(); i++) {
if (que[i].first.first / sq != divo) {
divo = que[i].first.first / sq;
lasto = que[i].first.first / sq * sq + sq;
del(t1);
del(t2);
t1 = new trie();
t2 = new trie();
ras = 0;
}
while (que[i].first.second >= lasto) {
x = ar[lasto] - 1;
y = ar[lasto];
s1 = tost(xo[x]);
s2 = tost(xo[y]);
add(s1, 0, x, t2, xo[x]);
add(s2, 0, y, t1, xo[y]);
ras =
max(ras, max(xo[x] ^ ask1(s1, 0, x, t1), xo[y] ^ ask2(s2, 0, y, t2)));
lasto++;
}
rus = ros[que[i].first.first];
for (int j = que[i].first.first; j < que[i].first.first / sq * sq + sq;
j++) {
x = ar[j] - 1;
y = ar[j];
s1 = tost(xo[x]);
s2 = tost(xo[y]);
rus =
max(rus, max(xo[x] ^ ask1(s1, 0, x, t1), xo[y] ^ ask2(s2, 0, y, t2)));
}
res[que[i].second] = max(rus, ras);
}
for (int i = 0; i < m; i++) cout << res[i] << '\n';
return 0;
}
|
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 ≤ ai ≤ 3, 1 ≤ ti, xi ≤ 109) — type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0
|
#include <bits/stdc++.h>
using namespace std;
struct itree {
int L, R;
itree *l = 0, *r = 0;
int info = 0;
itree(int L, int R) : L(L), R(R) {}
itree() : L(0), R(INT_MAX) {}
void update(int i) {
info++;
if (R > L + 1) {
int M = (L + R) / 2;
if (l == 0) l = new itree(L, M);
if (r == 0) r = new itree(M, R);
itree *t = (i < M) ? l : r;
t->update(i);
}
}
void dndate(int i) {
info--;
if (R > L + 1) {
int M = (L + R) / 2;
if (l == 0) l = new itree(L, M);
if (r == 0) r = new itree(M, R);
itree *t = (i < M) ? l : r;
t->dndate(i);
}
}
int count(int _L, int _R) {
if ((L == _L && R == _R)) return info;
int M = (L + R) / 2;
int answ = 0;
if (_L < M && l != 0) answ += l->count(_L, min(_R, M));
if (_R > M && r != 0) answ += r->count(max(_L, M), _R);
return answ;
}
};
int main() {
int n;
scanf("%d", &n);
const int inf = 1e9 + 100;
unordered_map<int, itree *> a;
for (int i = 0; i < n; i++) {
int tp, x, t;
scanf("%d %d %d", &tp, &t, &x);
if (a.count(x) == 0) a[x] = new itree(0, inf);
switch (tp) {
case 1:
a[x]->update(t);
break;
case 2:
a[x]->dndate(t);
break;
case 3:
printf("%d\n", a[x]->count(0, t + 1));
break;
}
}
}
|
Recently, on a programming lesson little Petya showed how quickly he can create files and folders on the computer. But he got soon fed up with this activity, and he decided to do a much more useful thing. He decided to calculate what folder contains most subfolders (including nested folders, nested folders of nested folders, and so on) and what folder contains most files (including the files in the subfolders).
More formally, the subfolders of the folder are all its directly nested folders and the subfolders of these nested folders. The given folder is not considered the subfolder of itself. A file is regarded as lying in a folder, if and only if it either lies directly in this folder, or lies in some subfolder of the folder.
For a better understanding of how to count subfolders and files for calculating the answer, see notes and answers to the samples.
You are given a few files that Petya has managed to create. The path to each file looks as follows:
diskName:\folder1\folder2\...\ foldern\fileName
* diskName is single capital letter from the set {C,D,E,F,G}.
* folder1, ..., foldern are folder names. Each folder name is nonempty sequence of lowercase Latin letters and digits from 0 to 9. (n ≥ 1)
* fileName is a file name in the form of name.extension, where the name and the extension are nonempty sequences of lowercase Latin letters and digits from 0 to 9.
It is also known that there is no file whose path looks like diskName:\fileName. That is, each file is stored in some folder, but there are no files directly in the root. Also let us assume that the disk root is not a folder.
Help Petya to find the largest number of subfolders, which can be in some folder, and the largest number of files that can be in some folder, counting all its subfolders.
Input
Each line of input data contains the description of one file path. The length of each line does not exceed 100, and overall there are no more than 100 lines. It is guaranteed, that all the paths are correct and meet the above rules. It is also guaranteed, that there are no two completely equal lines. That is, each file is described exactly once.
There is at least one line in the input data.
Output
Print two space-separated numbers. The first one is the maximal number of possible subfolders in a folder (including nested folders, nested folders of nested folders, and so on). The second one is the maximal number of files in a folder (including nested files in subfolders). Note that the disks are not regarded as folders.
Examples
Input
C:<span class="tex-span">\</span>folder1<span class="tex-span">\</span>file1.txt
Output
0 1
Input
C:<span class="tex-span">\</span>folder1<span class="tex-span">\</span>folder2<span class="tex-span">\</span>folder3<span class="tex-span">\</span>file1.txt
C:<span class="tex-span">\</span>folder1<span class="tex-span">\</span>folder2<span class="tex-span">\</span>folder4<span class="tex-span">\</span>file1.txt
D:<span class="tex-span">\</span>folder1<span class="tex-span">\</span>file1.txt
Output
3 2
Input
C:<span class="tex-span">\</span>file<span class="tex-span">\</span>file<span class="tex-span">\</span>file<span class="tex-span">\</span>file<span class="tex-span">\</span>file.txt
C:<span class="tex-span">\</span>file<span class="tex-span">\</span>file<span class="tex-span">\</span>file<span class="tex-span">\</span>file2<span class="tex-span">\</span>file.txt
Output
4 2
Note
In the first sample we have one folder on the "C" disk. It has no subfolders, which is why the first number in the answer is 0. But this folder contains one file, so the second number of the answer is 1.
In the second sample we have several different folders. Consider the "folder1" folder on the "C" disk. This folder directly contains one folder, "folder2". The "folder2" folder contains two more folders — "folder3" and "folder4". Thus, the "folder1" folder on the "C" drive has exactly 3 subfolders. Also this folder contains two files, even though they do not lie directly in the folder, but they are located in subfolders of "folder1".
In the third example we see that the names of some folders and some subfolders are identical. Consider the "file" folder, which lies directly on the "C" disk. That folder contains another "file" folder, which in turn contains another "file" folder, which contains two more folders, "file" and "file2". Thus, the "file" folder, which lies directly on the "C" disk, contains 4 subfolders.
|
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static class Folder{
Folder father = null;
int foldercnt= 0;
int fCnt = 0;
String name;
ArrayList<Folder> foldersons = new ArrayList<Folder>();
ArrayList<String> sons = new ArrayList<String>();
}
static void updateNode(Folder node,String[] fs){
for(int i=0;i<fs.length;i++){
if(fs[i].contains(".")){
if(!node.sons.contains(fs[i])){
node.sons.add(fs[i]);
node.fCnt++;
while(node.father!=null){
node = node.father;
node.fCnt++;
}
}
}else {
Folder tmp = null;
boolean f = false;
for(int j=0;j<node.foldersons.size();j++){
if(node.foldersons.get(j).name.equals(fs[i])){
f = true;
tmp=node.foldersons.get(j);
break;
}
}
if(!f){
Folder folder = new Folder();
folder.name = fs[i];
folder.father = node;
node.foldersons.add(folder);
node.foldercnt++;
// 更新父节点
tmp = node;
while (tmp.father!=null){
tmp = tmp.father;
tmp.foldercnt++;
}
node = folder;
}else{
node = tmp;
}
}
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Folder[] nodes= new Folder[5];
for(int i=0;i<5;i++){
nodes[i] = new Folder();
}
while (sc.hasNext()){
String line = sc.nextLine();
char c = line.charAt(0);
String fs[] =line.substring(3).split("\\\\");
switch (c){
case 'C':
updateNode(nodes[0],fs);
break;
case 'D':
updateNode(nodes[1],fs);
break;
case 'E':
updateNode(nodes[2],fs);
break;
case 'F':
updateNode(nodes[3],fs);
break;
case 'G':
updateNode(nodes[4],fs);
break;
default:
}
}
int res1=0,res2=0;
for(int i=0;i<5;i++){
for(int j=0;j<nodes[i].foldersons.size();j++){
if(nodes[i].foldersons.get(j).foldercnt>res1){
res1 = nodes[i].foldersons.get(j).foldercnt;
}
if(nodes[i].foldersons.get(j).fCnt>res2){
res2 = nodes[i].foldersons.get(j).fCnt;
}
}
}
System.out.println(res1+" "+res2);
}
}
|
To add insult to injury, the zombies have taken all but two drawings from Heidi! Please help her recover the Tree of Life from only these two drawings.
Input
The input format is the same as in the medium version, except that now the bound on n is 2 ≤ n ≤ 1000 and that k = 2.
Output
The same as in the medium version.
Example
Input
1
9 2
6
4 3
5 4
6 1
8 6
8 2
7 1
5
8 6
8 7
8 1
7 3
5 1
Output
YES
2 1
3 1
5 4
6 5
7 6
8 5
9 8
1 4
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1010, MaxM = 2010;
const unsigned long long base = 300007, mod = 100000000000007ll;
unsigned long long rand_val[MaxN];
class Graph {
public:
int en[MaxN], next[MaxM], to[MaxM], tot;
int lab[MaxN];
void add_edge(int x, int y) {
next[++tot] = en[x];
en[x] = tot;
to[tot] = y;
}
void clear() {
memset(en, 0, sizeof en);
tot = 0;
memset(lab, 0, sizeof lab);
}
} Gu, Gv;
struct Status {
int ker;
vector<pair<unsigned long long, int> > u, v;
};
vector<Status> Su, Sv;
vector<pair<int, int> > ans;
vector<int> stk;
int n, total;
int vis[MaxN], done[MaxN], v_time;
bool read_graph(Graph &G) {
int m;
scanf("%d", &m);
map<int, int> hash;
int total = 0;
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
if (!hash.count(u)) hash[u] = ++total;
if (!hash.count(v)) hash[v] = ++total;
u = hash[u];
v = hash[v];
G.add_edge(u, v);
G.add_edge(v, u);
}
if (total == n) return 1;
return 0;
}
int size[MaxN], mx[MaxN];
int dfs_size(Graph &G, int now) {
vis[now] = v_time;
size[now] = 1;
mx[now] = 0;
stk.push_back(now);
for (int i = G.en[now]; i; i = G.next[i])
if (vis[G.to[i]] != v_time) {
int tmp = dfs_size(G, G.to[i]);
size[now] += tmp;
mx[now] = max(mx[now], tmp);
}
return size[now];
}
pair<int, int> get_gra(Graph &G, int root, int u) {
++v_time;
vis[u] = v_time;
stk.clear();
int sz = dfs_size(G, root);
pair<int, int> ret(0, 0);
int mn = sz;
for (auto i : stk) {
mx[i] = max(mx[i], sz - size[i]);
mn = min(mn, mx[i]);
}
for (auto i : stk)
if (mx[i] == mn) {
if (ret.first == 0)
ret.first = i;
else
ret.second = i;
}
return ret;
}
unsigned long long vec_hash(vector<unsigned long long> &s) {
sort(s.begin(), s.end());
unsigned long long ret = 0;
for (unsigned int i = 0; i < s.size(); ++i)
ret = ((ret * base + s[i]) ^ (s[i] * 2333 + rand_val[i])) % mod;
return ret;
}
unsigned long long dfs_hash(Graph &G, int now) {
vis[now] = v_time;
done[now] = 1;
vector<unsigned long long> v;
for (int i = G.en[now]; i; i = G.next[i])
if (v_time != vis[G.to[i]]) v.push_back(dfs_hash(G, G.to[i]));
v.push_back(0);
return vec_hash(v);
}
unsigned long long get_hash(Graph &G, int root, int u = 0) {
pair<int, int> gra = get_gra(G, root, u);
if (gra.second == 0) {
++v_time;
vis[u] = v_time;
return dfs_hash(G, gra.first);
} else {
vector<unsigned long long> v;
++v_time;
vis[u] = v_time;
vis[gra.second] = vis[gra.first] = v_time;
v.push_back(dfs_hash(G, gra.first));
v.push_back(dfs_hash(G, gra.second));
v.push_back(base);
return vec_hash(v);
}
return 0;
}
int relabel(Graph &G, int now, int flag = 0) {
if (flag) stk.push_back(now);
vis[now] = v_time;
G.lab[now] = ++total;
for (int i = G.en[now]; i; i = G.next[i])
if (vis[G.to[i]] != v_time)
ans.push_back(make_pair(G.lab[now], relabel(G, G.to[i], flag)));
return G.lab[now];
}
pair<unsigned long long, int> set_xor(
vector<pair<unsigned long long, int> > &u,
vector<pair<unsigned long long, int> > &v) {
if (u.size() < v.size() || u.size() > v.size() + 1) return make_pair(0, -1);
multiset<unsigned long long> s;
pair<unsigned long long, int> ret(0, 0);
for (auto i : v) s.insert(i.first);
for (auto i : u) {
auto t = s.find(i.first);
if (t == s.end()) {
if (ret.second != 0)
return make_pair(0, -1);
else
ret = i;
} else
s.erase(t);
}
if (u.size() == v.size() && ret.second != 0) return make_pair(0, -1);
return ret;
}
bool check(Status Su, Status Sv) {
pair<unsigned long long, int> com_u, com_v;
com_u = set_xor(Su.u, Sv.v);
com_v = set_xor(Sv.u, Su.v);
if (com_u.second == -1 || com_v.second == -1 || com_u.first != com_v.first)
return 0;
if ((com_u.second == 0) ^ (com_v.second == 0)) return 0;
total = 2;
int u = Su.ker, v = Sv.ker;
for (int i = Gu.en[u]; i; i = Gu.next[i])
if (Gu.to[i] != com_u.second) {
++v_time;
vis[Su.ker] = v_time;
ans.push_back(make_pair(1, relabel(Gu, Gu.to[i])));
}
for (int i = Gv.en[v]; i; i = Gv.next[i])
if (Gv.to[i] != com_v.second) {
++v_time;
vis[Sv.ker] = v_time;
ans.push_back(make_pair(2, relabel(Gv, Gv.to[i])));
}
if (com_u.second == 0)
ans.push_back(make_pair(1, 2));
else {
stk.clear();
++v_time;
vis[Su.ker] = v_time;
ans.push_back(make_pair(1, relabel(Gu, com_u.second, 1)));
++v_time;
vis[Sv.ker] = v_time;
unsigned long long hv = dfs_hash(Gv, com_v.second);
for (auto i : stk) {
++v_time;
vis[Su.ker] = v_time;
unsigned long long tmp = dfs_hash(Gu, i);
if (tmp == hv) {
ans.push_back(make_pair(2, Gu.lab[i]));
break;
}
}
}
return 1;
}
void work(Graph &G, vector<Status> &S) {
for (int u = 1; u < n; ++u) {
Status now;
now.ker = u;
memset(done, 0, sizeof done);
done[u] = 1;
for (int i = G.en[u]; i; i = G.next[i])
now.u.push_back(make_pair(get_hash(G, G.to[i], u), G.to[i]));
for (int i = 1; i < n; ++i)
if (!done[i]) now.v.push_back(make_pair(get_hash(G, i, u), i));
S.push_back(now);
}
}
void solve() {
ans.clear();
Gu.clear();
Gv.clear();
Su.clear();
Sv.clear();
scanf("%d%*d", &n);
bool flag = 0;
flag |= read_graph(Gu);
flag |= read_graph(Gv);
for (int i = 0; i <= n; ++i)
rand_val[i] = ((unsigned long long)rand() << 15) ^ rand();
if (flag) {
puts("NO");
return;
}
work(Gu, Su);
work(Gv, Sv);
for (auto i : Su)
for (auto j : Sv)
if (check(i, j)) {
assert(int(ans.size()) == n - 1);
puts("YES");
for (auto e : ans) printf("%d %d\n", e.first, e.second);
return;
}
puts("NO");
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
return 0;
}
|
ZS the Coder is given two permutations p and q of {1, 2, ..., n}, but some of their elements are replaced with 0. The distance between two permutations p and q is defined as the minimum number of moves required to turn p into q. A move consists of swapping exactly 2 elements of p.
ZS the Coder wants to determine the number of ways to replace the zeros with positive integers from the set {1, 2, ..., n} such that p and q are permutations of {1, 2, ..., n} and the distance between p and q is exactly k.
ZS the Coder wants to find the answer for all 0 ≤ k ≤ n - 1. Can you help him?
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 250) — the number of elements in the permutations.
The second line contains n integers, p1, p2, ..., pn (0 ≤ pi ≤ n) — the permutation p. It is guaranteed that there is at least one way to replace zeros such that p is a permutation of {1, 2, ..., n}.
The third line contains n integers, q1, q2, ..., qn (0 ≤ qi ≤ n) — the permutation q. It is guaranteed that there is at least one way to replace zeros such that q is a permutation of {1, 2, ..., n}.
Output
Print n integers, i-th of them should denote the answer for k = i - 1. Since the answer may be quite large, and ZS the Coder loves weird primes, print them modulo 998244353 = 223·7·17 + 1, which is a prime.
Examples
Input
3
1 0 0
0 2 0
Output
1 2 1
Input
4
1 0 0 3
0 0 0 4
Output
0 2 6 4
Input
6
1 3 2 5 4 6
6 4 5 1 0 0
Output
0 0 0 0 1 1
Input
4
1 2 3 4
2 3 4 1
Output
0 0 0 1
Note
In the first sample case, there is the only way to replace zeros so that it takes 0 swaps to convert p into q, namely p = (1, 2, 3), q = (1, 2, 3).
There are two ways to replace zeros so that it takes 1 swap to turn p into q. One of these ways is p = (1, 2, 3), q = (3, 2, 1), then swapping 1 and 3 from p transform it into q. The other way is p = (1, 3, 2), q = (1, 2, 3). Swapping 2 and 3 works in this case.
Finally, there is one way to replace zeros so that it takes 2 swaps to turn p into q, namely p = (1, 3, 2), q = (3, 2, 1). Then, we can transform p into q like following: <image>.
|
#include <bits/stdc++.h>
using namespace std;
int dg[2010], a[2010], b[2010], n, dp[2010][2010];
int va[2010], vb[2010], v[2010], vs[2010], f[2010], g[2010], h[2010];
int A, B, X, C, D, fac[2010], inv[2010];
int gmod(int x) { return x >= 998244353 ? x - 998244353 : x; }
void mul(int a[], int b[], int c[]) {
for (int i = 0; i <= n; ++i) h[i] = 0;
for (int i = 0; i <= n; ++i)
for (int j = 0; i + j <= n; ++j)
h[i + j] = (h[i + j] + 1ll * a[i] * b[j]) % 998244353;
for (int i = 0; i <= n; ++i) c[i] = h[i];
}
int qpow(int a, int b) {
int ans = 1;
for (; b; b >>= 1, a = 1ll * a * a % 998244353)
if (b & 1) ans = 1ll * ans * a % 998244353;
return ans;
}
int main() {
scanf("%d", &n);
fac[0] = inv[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = 1ll * fac[i - 1] * i % 998244353;
inv[n] = qpow(fac[n], 998244353 - 2);
for (int i = n - 1; i >= 1; --i)
inv[i] = 1ll * inv[i + 1] * (i + 1) % 998244353;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), a[i] ? va[a[i]] = i : 0;
for (int i = 1; i <= n; ++i) scanf("%d", &b[i]), b[i] ? vb[b[i]] = i : 0;
for (int i = 1; i <= n; ++i)
if (a[i] && b[i]) dg[a[i]]++, dg[b[i]]++;
int N = n, X = 0;
for (int i = 1, j; i <= n; ++i)
if (!vs[i] && dg[i] == 1) {
if (va[i]) {
int x = va[i];
vs[i] = 1;
while (x) {
int y = b[x];
vs[y] = 1, x = va[y];
}
} else {
int x = vb[i];
vs[i] = 1;
while (x) {
int y = a[x];
vs[y] = 1, x = vb[y];
}
}
}
for (int i = 1, j; i <= n; ++i)
if (!vs[i] && dg[i] == 2) {
for (j = i; !vs[j];) {
int nxt = b[va[j]];
vs[j] = 1, j = nxt;
}
X++;
}
for (int i = 1; i <= n; ++i)
if (va[i] && vb[i]) N--;
for (int i = 1; i <= n; ++i)
if (((!!va[i]) ^ (!!vb[i]))) {
if (va[i]) {
int x = va[i];
while (1) {
int y = b[x];
if (!y) {
A++;
break;
}
if (!va[y]) {
C++;
break;
}
x = va[y];
}
} else {
int x = vb[i];
while (1) {
int y = a[x];
if (!y) {
B++;
break;
}
if (!vb[y]) {
C++;
break;
}
x = vb[y];
}
}
}
C /= 2;
D = N - A - B - C;
g[X] = 1;
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 1; i <= A; ++i)
for (int j = 0; j <= i; ++j)
dp[i][j] =
((j ? dp[i - 1][j - 1] : 0) + 1ll * dp[i - 1][j] * (A + D - i)) %
998244353;
mul(dp[A], g, g);
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 1; i <= B; ++i)
for (int j = 0; j <= i; ++j)
dp[i][j] =
((j ? dp[i - 1][j - 1] : 0) + 1ll * dp[i - 1][j] * (B + D - i)) %
998244353;
mul(dp[B], g, g);
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 1; i <= C; ++i)
for (int j = 0, x = D - i + 1; j <= i; ++j)
dp[i][j] = ((j ? 1ll * dp[i - 1][j - 1] * x : 0) +
1ll * dp[i - 1][j] * x * (x - 1)) %
998244353;
mul(dp[C], g, g);
D -= C;
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 1; i <= D; ++i)
for (int j = 0; j <= i; ++j)
dp[i][j] = ((j ? 1ll * dp[i - 1][j - 1] * i : 0) +
1ll * dp[i - 1][j] * (D - i) * i) %
998244353;
mul(dp[D], g, g);
for (int i = 1; i <= n; ++i) printf("%d ", g[n - i + 1]);
}
|
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
|
import java.util.Scanner;
public class P736B
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
int n = in.nextInt();
if (prime(n))
System.out.println(1);
else if (n % 2 == 0 || prime(n - 2))
System.out.println(2);
else
System.out.println(3);
in.close();
}
public static boolean prime(int n)
{
for (int i = 2; i * i <= n; i++)
if (n % i == 0)
return false;
return true;
}
}
|
n hobbits are planning to spend the night at Frodo's house. Frodo has n beds standing in a row and m pillows (n ≤ m). Each hobbit needs a bed and at least one pillow to sleep, however, everyone wants as many pillows as possible. Of course, it's not always possible to share pillows equally, but any hobbit gets hurt if he has at least two pillows less than some of his neighbors have.
Frodo will sleep on the k-th bed in the row. What is the maximum number of pillows he can have so that every hobbit has at least one pillow, every pillow is given to some hobbit and no one is hurt?
Input
The only line contain three integers n, m and k (1 ≤ n ≤ m ≤ 109, 1 ≤ k ≤ n) — the number of hobbits, the number of pillows and the number of Frodo's bed.
Output
Print single integer — the maximum number of pillows Frodo can have so that no one is hurt.
Examples
Input
4 6 2
Output
2
Input
3 10 3
Output
4
Input
3 6 1
Output
3
Note
In the first example Frodo can have at most two pillows. In this case, he can give two pillows to the hobbit on the first bed, and one pillow to each of the hobbits on the third and the fourth beds.
In the second example Frodo can take at most four pillows, giving three pillows to each of the others.
In the third example Frodo can take three pillows, giving two pillows to the hobbit in the middle and one pillow to the hobbit on the third bed.
|
#include <bits/stdc++.h>
using namespace std;
namespace ib {
char b[100];
}
inline void pi(int x) {
if (x == 0) {
putchar(48);
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
char *s = ib::b;
while (x) *(++s) = x % 10, x /= 10;
while (s != ib::b) putchar((*(s--)) + 48);
}
inline void ri(int &x) {
x = 0;
static char c;
bool t(0);
while (c = getchar(), c < '0' || c > '9')
if (c == '-')
t = 1;
else
t = 0;
do x = x * 10 + c - '0';
while (c = getchar(), c >= '0' && c <= '9');
if (t) x = -x;
}
int main() {
int i, n, m, k;
long long s, l = 1, r = ~0u >> 2, x, y, mid;
cin >> n >> m >> k;
while (l + 1 < r) {
mid = (l + r) >> 1;
x = mid - k + 1;
y = mid - (n - k);
if (x < 1 && y < 1)
s = (long long)mid * mid + n - mid - mid + 1;
else if (x < 1)
s = (long long)(mid - 1 + y) * (n - k) / 2 + (1 + mid) * mid / 2 + k -
mid;
else if (y < 1)
s = (long long)(x + mid) * k / 2 + (long long)mid * (mid - 1) / 2 + n -
(k + mid - 1);
else
s = (long long)(x + mid) * k / 2 + (long long)(mid - 1 + y) * (n - k) / 2;
if (s > m)
r = mid;
else
l = mid;
}
cout << l;
return 0;
}
|
A couple of friends, Axel and Marston are travelling across the country of Bitland. There are n towns in Bitland, with some pairs of towns connected by one-directional roads. Each road in Bitland is either a pedestrian road or a bike road. There can be multiple roads between any pair of towns, and may even be a road from a town to itself. However, no pair of roads shares the starting and the destination towns along with their types simultaneously.
The friends are now located in the town 1 and are planning the travel route. Axel enjoys walking, while Marston prefers biking. In order to choose a route diverse and equally interesting for both friends, they have agreed upon the following procedure for choosing the road types during the travel:
* The route starts with a pedestrian route.
* Suppose that a beginning of the route is written in a string s of letters P (pedestrain road) and B (biking road). Then, the string <image> is appended to s, where <image> stands for the string s with each character changed to opposite (that is, all pedestrian roads changed to bike roads, and vice versa).
In the first few steps the route will look as follows: P, PB, PBBP, PBBPBPPB, PBBPBPPBBPPBPBBP, and so on.
After that the friends start travelling from the town 1 via Bitlandian roads, choosing the next road according to the next character of their route type each time. If it is impossible to choose the next road, the friends terminate their travel and fly home instead.
Help the friends to find the longest possible route that can be travelled along roads of Bitland according to the road types choosing procedure described above. If there is such a route with more than 1018 roads in it, print -1 instead.
Input
The first line contains two integers n and m (1 ≤ n ≤ 500, 0 ≤ m ≤ 2n2) — the number of towns and roads in Bitland respectively.
Next m lines describe the roads. i-th of these lines contains three integers vi, ui and ti (1 ≤ vi, ui ≤ n, 0 ≤ ti ≤ 1), where vi and ui denote start and destination towns indices of the i-th road, and ti decribes the type of i-th road (0 for a pedestrian road, 1 for a bike road). It is guaranteed that for each pair of distinct indices i, j such that 1 ≤ i, j ≤ m, either vi ≠ vj, or ui ≠ uj, or ti ≠ tj holds.
Output
If it is possible to find a route with length strictly greater than 1018, print -1. Otherwise, print the maximum length of a suitable path.
Examples
Input
2 2
1 2 0
2 2 1
Output
3
Input
2 3
1 2 0
2 2 1
2 2 0
Output
-1
Note
In the first sample we can obtain a route of length 3 by travelling along the road 1 from town 1 to town 2, and then following the road 2 twice from town 2 to itself.
In the second sample we can obtain an arbitrarily long route by travelling the road 1 first, and then choosing road 2 or 3 depending on the necessary type.
|
#include <bits/stdc++.h>
const int MAX_N = 500 + 10;
std::bitset<MAX_N> f[2][64][MAX_N], g, temp;
int n, m;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; ++i) {
int x, y, t;
scanf("%d %d %d", &x, &y, &t);
f[t][0][x][y] = 1;
}
for (int i = 1; i <= 60; ++i)
for (int j = 1; j <= n; ++j)
for (int k = 1; k <= n; ++k)
for (int t = 0; t < 2; ++t)
if (f[t][i - 1][j][k]) f[t][i][j] |= f[t ^ 1][i - 1][k];
int flg = 0;
long long ans = 0, INF = 1e18;
g[1] = 1;
for (int i = 60; i >= 0; --i) {
temp = 0;
for (int j = 1; j <= n; ++j)
if (g[j]) temp |= f[flg][i][j];
if (temp.count()) {
ans += ((long long)1 << i);
g = temp;
flg ^= 1;
}
}
if (ans > INF)
printf("-1\n");
else
printf("%I64d\n", ans);
return 0;
}
|
Isart and Modsart were trying to solve an interesting problem when suddenly Kasra arrived. Breathless, he asked: "Can you solve a problem I'm stuck at all day?"
We have a tree T with n vertices and m types of ice cream numerated from 1 to m. Each vertex i has a set of si types of ice cream. Vertices which have the i-th (1 ≤ i ≤ m) type of ice cream form a connected subgraph. We build a new graph G with m vertices. We put an edge between the v-th and the u-th (1 ≤ u, v ≤ m, u ≠ v) vertices in G if and only if there exists a vertex in T that has both the v-th and the u-th types of ice cream in its set. The problem is to paint the vertices of G with minimum possible number of colors in a way that no adjacent vertices have the same color.
Please note that we consider that empty set of vertices form a connected subgraph in this problem.
As usual, Modsart don't like to abandon the previous problem, so Isart wants you to solve the new problem.
Input
The first line contains two integer n and m (1 ≤ n, m ≤ 3·105) — the number of vertices in T and the number of ice cream types.
n lines follow, the i-th of these lines contain single integer si (0 ≤ si ≤ 3·105) and then si distinct integers, each between 1 and m — the types of ice cream in the i-th vertex. The sum of si doesn't exceed 5·105.
n - 1 lines follow. Each of these lines describes an edge of the tree with two integers u and v (1 ≤ u, v ≤ n) — the indexes of connected by this edge vertices.
Output
Print single integer c in the first line — the minimum number of colors to paint the vertices in graph G.
In the second line print m integers, the i-th of which should be the color of the i-th vertex. The colors should be between 1 and c. If there are some answers, print any of them.
Examples
Input
3 3
1 1
2 2 3
1 2
1 2
2 3
Output
2
1 1 2
Input
4 5
0
1 1
1 3
3 2 4 5
2 1
3 2
4 3
Output
3
1 1 1 2 3
Note
In the first example the first type of ice cream is present in the first vertex only, so we can color it in any color. The second and the third ice cream are both presented in the second vertex, so we should paint them in different colors.
In the second example the colors of the second, the fourth and the fifth ice cream should obviously be distinct.
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500005;
int N, M, C, ban[MAXN], ans[MAXN], done[MAXN];
set<int> pset;
vector<int> color[MAXN], E[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> N >> M;
C = 0;
int rt = 0;
for (int i = (1); i <= (N); i++) {
int K;
cin >> K;
color[i].resize(K);
for (int j = 0; j < (K); j++) cin >> color[i][j];
if (K > C) {
C = K;
rt = i;
}
sort(begin(color[i]), end(color[i]));
}
for (int _ = 0; _ < (N - 1); _++) {
int u, v;
cin >> u >> v;
E[u].push_back(v);
E[v].push_back(u);
}
queue<int> que;
for (int i = (1); i <= (C); i++) {
ans[color[rt][i - 1]] = i;
pset.insert(i);
}
done[rt] = 1;
que.push(rt);
while (!que.empty()) {
int u = que.front();
que.pop();
for (auto it : color[u]) ban[it] = 1;
for (auto v : E[u]) {
if (done[v]) continue;
done[v] = 1;
for (auto it : color[v]) {
if (ban[it]) {
pset.erase(ans[it]);
assert(ans[it]);
}
}
for (auto it : color[v]) {
if (ans[it]) continue;
assert(!pset.empty());
ans[it] = *pset.begin();
pset.erase(pset.begin());
}
que.push(v);
for (auto it : color[v]) {
pset.insert(ans[it]);
}
}
for (auto it : color[u]) ban[it] = 0;
}
for (int i = (1); i <= (M); i++) {
if (!ans[i]) ans[i] = 1;
}
C = max(C, 1);
cout << C << endl;
for (int i = (1); i <= (M); i++) cout << ans[i] << " \n"[i == M];
for (int i = (1); i <= (N); i++) {
int k = ((int)((color[i]).size()));
for (int j = 0; j < (k - 1); j++)
assert(ans[color[i][j]] != ans[color[i][j + 1]]);
}
return 0;
}
|
Little Vasya likes very much to play with sets consisting of positive integers. To make the game more interesting, Vasya chose n non-empty sets in such a way, that no two of them have common elements.
One day he wanted to show his friends just how interesting playing with numbers is. For that he wrote out all possible unions of two different sets on n·(n - 1) / 2 pieces of paper. Then he shuffled the pieces of paper. He had written out the numbers in the unions in an arbitrary order.
For example, if n = 4, and the actual sets have the following form {1, 3}, {5}, {2, 4}, {7}, then the number of set pairs equals to six. The six pieces of paper can contain the following numbers:
* 2, 7, 4.
* 1, 7, 3;
* 5, 4, 2;
* 1, 3, 5;
* 3, 1, 2, 4;
* 5, 7.
Then Vasya showed the pieces of paper to his friends, but kept the n sets secret from them. His friends managed to calculate which sets Vasya had thought of in the first place. And how about you, can you restore the sets by the given pieces of paper?
Input
The first input file line contains a number n (2 ≤ n ≤ 200), n is the number of sets at Vasya's disposal. Then follow sets of numbers from the pieces of paper written on n·(n - 1) / 2 lines. Each set starts with the number ki (2 ≤ ki ≤ 200), which is the number of numbers written of the i-th piece of paper, and then follow ki numbers aij (1 ≤ aij ≤ 200). All the numbers on the lines are separated by exactly one space. It is guaranteed that the input data is constructed according to the above given rules from n non-intersecting sets.
Output
Print on n lines Vasya's sets' description. The first number on the line shows how many numbers the current set has. Then the set should be recorded by listing its elements. Separate the numbers by spaces. Each number and each set should be printed exactly once. Print the sets and the numbers in the sets in any order. If there are several answers to that problem, print any of them.
It is guaranteed that there is a solution.
Examples
Input
4
3 2 7 4
3 1 7 3
3 5 4 2
3 1 3 5
4 3 1 2 4
2 5 7
Output
1 7
2 2 4
2 1 3
1 5
Input
4
5 6 7 8 9 100
4 7 8 9 1
4 7 8 9 2
3 1 6 100
3 2 6 100
2 1 2
Output
3 7 8 9
2 6 100
1 1
1 2
Input
3
2 1 2
2 1 3
2 2 3
Output
1 1
1 2
1 3
|
import java.io.*;
import java.util.*;
public class Sets {
public void run() {
BufferedReader in = new BufferedReader(
new InputStreamReader(System.in));
Scanner scanner = new Scanner(in);
int n = scanner.nextInt();
int[][] papers = new int[n * (n - 1) / 2][];
int[] id = new int[200 + 1];
boolean[][] has = new boolean[papers.length][200 + 1];
boolean[] present = new boolean[200 + 1];
for (int i = 0; i < papers.length; i++) {
int k = scanner.nextInt();
papers[i] = new int[k];
for (int j = 0; j < k; j++) {
papers[i][j] = scanner.nextInt();
present[papers[i][j]] = true;
has[i][papers[i][j]] = true;
}
Arrays.sort(papers[i]);
}
int ids = 0;
for (int i = 1; i <= 200; i++) {
if (present[i] && id[i] == 0) {
int[] two = new int[2];
int found = 0;
for (int j = 0; j < papers.length && found < 2; j++) {
if (has[j][i])
two[found++] = j;
}
if (found == 2) {
ids++;
int p = 0;
int q = 0;
while (p < papers[two[0]].length && q < papers[two[1]].length) {
if (papers[two[0]][p] == papers[two[1]][q]) {
id[papers[two[0]][p]] = ids;
id[papers[two[1]][q]] = ids;
p++;
q++;
}
else if (papers[two[0]][p] < papers[two[1]][q]) {
p++;
}
else {
q++;
}
}
}
}
}
// The only case left is when there is a single group, because
// if there are more groups, then each will be used more than once in
// the resulting sets. The only exception is when there are 2 groups
// at the beginning and 1 group in the end: 1 group can be achieved
// either from 1 group (no action), or from 2 groups
// (2 * (2 - 1) / 2 == 1).
for (int i = 1; i <= 200; i++)
if (present[i] && id[i] == 0) {
++ids;
for (int j = i; j <= 200; j++) {
if (present[j] && id[j] == 0) {
id[j] = ids;
}
}
}
// A corner case. Our algorithm will put everything into a single group
// in this case. But we need to have exactly 2 groups.
if (n == 2) {
id[papers[0][0]] = ++ids;
}
for (int i = 1; i <= ids; i++) {
int count = 0;
for (int j = 1; j <= 200; j++)
if (id[j] == i)
count++;
System.out.print(count);
for (int j = 1; j <= 200; j++)
if (id[j] == i)
System.out.print(" " + j);
System.out.println();
}
}
public static void main(String[] args) {
new Sets().run();
}
}
|
Ivan is reading a book about tournaments. He knows that a tournament is an oriented graph with exactly one oriented edge between each pair of vertices. The score of a vertex is the number of edges going outside this vertex.
Yesterday Ivan learned Landau's criterion: there is tournament with scores d1 ≤ d2 ≤ ... ≤ dn if and only if <image> for all 1 ≤ k < n and <image>.
Now, Ivan wanna solve following problem: given a set of numbers S = {a1, a2, ..., am}, is there a tournament with given set of scores? I.e. is there tournament with sequence of scores d1, d2, ..., dn such that if we remove duplicates in scores, we obtain the required set {a1, a2, ..., am}?
Find a tournament with minimum possible number of vertices.
Input
The first line contains a single integer m (1 ≤ m ≤ 31).
The next line contains m distinct integers a1, a2, ..., am (0 ≤ ai ≤ 30) — elements of the set S. It is guaranteed that all elements of the set are distinct.
Output
If there are no such tournaments, print string "=(" (without quotes).
Otherwise, print an integer n — the number of vertices in the tournament.
Then print n lines with n characters — matrix of the tournament. The j-th element in the i-th row should be 1 if the edge between the i-th and the j-th vertices is oriented towards the j-th vertex, and 0 otherwise. The main diagonal should contain only zeros.
Examples
Input
2
1 2
Output
4
0011
1001
0100
0010
Input
2
0 3
Output
6
000111
100011
110001
011001
001101
000000
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int UNDEF = -1;
const long long INF = 1e18;
template <typename T>
inline bool chkmax(T &aa, T bb) {
return aa < bb ? aa = bb, true : false;
}
template <typename T>
inline bool chkmin(T &aa, T bb) {
return aa > bb ? aa = bb, true : false;
}
int rint();
char rch();
long long rlong();
const int mv = 160;
const int mc = ((mv * (mv - 1)) / 2) + 1;
const int ma = 31;
bitset<mc> f[mv][ma];
void reset() {
for (int v = 0; v < mv; v++)
for (int ai = 0; ai < ma; ai++) f[v][ai].reset();
}
vector<int> solve(vector<int> &a) {
vector<int> fail;
sort(a.begin(), a.end());
int alim = a.size();
f[0][0][a[0]] = true;
{
int v = 0;
int klim = (v * (v + 1)) / 2;
if (f[(v)][alim - 1][klim]) {
return vector<int>({a[0]});
}
}
for (int v = 1; v < mv; v++) {
for (int sai = 0; sai < alim; sai++) {
for (int dai = sai; dai <= min(alim - 1, sai + 1); dai++) {
int shift = a[dai];
f[(v)][dai] |= (f[(v)-1][sai] << shift);
}
}
int klim = (v * (v + 1)) / 2;
if (f[(v)][alim - 1][klim]) {
vector<int> final;
int ai = alim - 1;
int k = klim;
for (int x = v; x >= 1; x--) {
final.push_back(a[ai]);
k -= a[ai];
if (f[x - 1][ai][k]) {
ai = ai;
} else {
ai--;
}
}
final.push_back(a[0]);
sort(final.begin(), final.end());
return final;
}
bitset<mc> filt;
filt.set();
filt >>= klim;
filt <<= klim;
for (int ai = 0; ai < alim; ai++) {
f[(v)][ai] &= filt;
}
}
return fail;
}
bool vans[mv + 2][mv + 2];
void recurse(vector<int> &r) {
int n = r.size() - 1;
if (n == 0) return;
vector<int> R;
R.push_back(-1);
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += r[i];
R.push_back(sum);
}
int s = n - 1 - r[n];
vector<int> F;
F.resize(n + 1);
for (int v = 1; v <= n; v++) F[v] = R[v] - (v * (v - 1)) / 2;
int j = 1;
vector<int> rp = r;
for (int x = 1; x <= n; x++) vans[n][x] = 1;
vans[n][n] = 0;
vector<int> vj;
vj.resize(s + 1);
for (int d = 1; d <= s; d++) {
int vmin = max(1, vj[d - 1] + 1);
int ans = vmin;
for (int v = n - 1; v >= vmin; v--) {
if (F[v] < d) {
ans = v + 1;
break;
}
}
vj[d] = ans;
}
for (int d = 1; d <= s; d++) {
int j = vj[d];
assert(j <= n - 1);
vans[n][j] = 0;
vans[j][n] = 1;
rp[j]--;
}
rp.resize(rp.size() - 1);
recurse(rp);
}
vector<int> fgot;
int comb(vector<int> &va) {
auto got = solve(va);
fgot = got;
if (got.size() == 0) {
printf("=(\n");
return 0;
} else {
vector<int> r;
r.push_back(-1);
for (auto &w : got) r.push_back(w);
recurse(r);
int sz = got.size();
printf("%d\n", sz);
for (int x = 1; x <= sz; x++) {
for (int y = 1; y <= sz; y++) {
printf("%d", (int)vans[x][y]);
}
printf("\n");
}
return sz;
}
}
void test() {
reset();
memset(vans, 0, sizeof vans);
vector<int> va;
int p = (rand() % 100);
for (int x = 0; x <= 30; x++) {
if (rand() % 100 <= p) va.push_back(x);
}
if (va.size() == 0) va.push_back(rand() % 31);
int got = comb(va);
if (got != 0) {
set<int> s;
for (int x = 1; x <= got; x++) {
assert(vans[x][x] == 0);
int degout = 0;
for (int y = 1; y <= got; y++) {
degout += vans[x][y];
}
s.insert(degout);
}
for (int x = 1; x <= got; x++) {
for (int y = 1; y <= got; y++) {
if (x == y) continue;
assert(vans[x][y] + vans[y][x] == 1);
}
}
set<int> sa;
for (auto &w : va) sa.insert(w);
if (s != sa) {
for (auto &w : sa) printf("%d ", w);
printf(" sa\n");
for (auto &w : s) printf("%d ", w);
printf(" s\n");
for (auto &w : fgot) printf("%d ", w);
printf(" fgot\n");
exit(1);
}
}
}
void go() {
for (int k = 0; k < 100000; k++) {
srand(clock());
test();
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n = rint();
vector<int> va;
va.reserve(n);
for (int i = 0; i < n; i++) {
int x = rint();
va.push_back(x);
}
comb(va);
}
static char stdinBuffer[1024];
static char *stdinDataEnd = stdinBuffer + sizeof(stdinBuffer);
static const char *stdinPos = stdinDataEnd;
void readAhead(size_t amount) {
size_t remaining = stdinDataEnd - stdinPos;
if (remaining < amount) {
memmove(stdinBuffer, stdinPos, remaining);
size_t sz = fread(stdinBuffer + remaining, 1,
sizeof(stdinBuffer) - remaining, stdin);
stdinPos = stdinBuffer;
stdinDataEnd = stdinBuffer + remaining + sz;
if (stdinDataEnd != stdinBuffer + sizeof(stdinBuffer)) *stdinDataEnd = 0;
}
}
int rint() {
readAhead(16);
int x = 0;
bool neg = false;
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
if (*stdinPos == '-') {
++stdinPos;
neg = true;
}
while (*stdinPos >= '0' && *stdinPos <= '9') {
x *= 10;
x += *stdinPos - '0';
++stdinPos;
}
return neg ? -x : x;
}
char rch() {
readAhead(16);
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
char ans = *stdinPos;
++stdinPos;
return ans;
}
long long rlong() {
readAhead(32);
long long x = 0;
bool neg = false;
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
if (*stdinPos == '-') {
++stdinPos;
neg = true;
}
while (*stdinPos >= '0' && *stdinPos <= '9') {
x *= 10;
x += *stdinPos - '0';
++stdinPos;
}
return neg ? -x : x;
}
|
You are given a string s consisting of n lowercase Latin letters. Some indices in this string are marked as forbidden.
You want to find a string a such that the value of |a|·f(a) is maximum possible, where f(a) is the number of occurences of a in s such that these occurences end in non-forbidden indices. So, for example, if s is aaaa, a is aa and index 3 is forbidden, then f(a) = 2 because there are three occurences of a in s (starting in indices 1, 2 and 3), but one of them (starting in index 2) ends in a forbidden index.
Calculate the maximum possible value of |a|·f(a) you can get.
Input
The first line contains an integer number n (1 ≤ n ≤ 200000) — the length of s.
The second line contains a string s, consisting of n lowercase Latin letters.
The third line contains a string t, consisting of n characters 0 and 1. If i-th character in t is 1, then i is a forbidden index (otherwise i is not forbidden).
Output
Print the maximum possible value of |a|·f(a).
Examples
Input
5
ababa
00100
Output
5
Input
5
ababa
00000
Output
6
Input
5
ababa
11111
Output
0
|
//package Strings;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Map;
import java.util.TreeMap;
import java.util.Map.Entry;
public class forbiddenIndices {
static class pair implements Comparable<pair> {
int ind, len;
public pair(int i, int l) {
ind = i;
len = l;
}
@Override
public int compareTo(pair p) {
if (len > p.len)
return 1;
else if (len < p.len)
return -1;
else
return ind - p.ind;
}
}
static class SuffixAutomaton {
int[] link, len;
pair[] lengths;
TreeMap<Character, Integer>[] next;
int lst, idx;
char[] ind,s;
long[] ways;
long[] map;
int[] badInfo;
int [] badInfoOrig;
void populate() {
lengths = new pair[link.length];
for (int i = 0; i < len.length; i++) {
lengths[i] = new pair(i, len[i]);
}
Arrays.sort(lengths);
for (int i = lengths.length - 1; i >= 0; i--) {
int idx = lengths[i].ind;
int curLink = link[idx];
map[idx] += badInfo[idx];
map[curLink] += map[idx];
}
}
SuffixAutomaton(char[] s, char[] ind) {
this.ind = ind;
int n = s.length;
this.s = s;
ways = new long[n << 1];
link = new int[n << 1];
len = new int[n << 1];
map = new long[n << 1];
badInfo = new int[n << 1];
next = new TreeMap[n << 1];
next[0] = new TreeMap<>();
int count = 0;
for (char c : s)
addLetter(c);
}
void addLetter(char c) {
int cur = ++idx, p = lst;
while(!next[p].containsKey(c)) { next[p].put(c, cur); p = link[p]; }
int q = next[p].get(c);
if(q != cur)
if(len[q] == len[p] + 1)
link[cur] = q;
else
{
int clone = ++idx;
len[clone] = len[p] + 1;
link[clone] = link[q];
next[clone] = new TreeMap<>(next[q]);
link[cur] = link[q] = clone;
while(next[p].get(c) == q) { next[p].put(c, clone); p = link[p]; }
}
len[cur] = len[lst] + 1;
next[cur] = new TreeMap<>();
lst = cur;
}
void trace(int idx, int pos) {
for (Map.Entry<Character, Integer> entry : next[idx].entrySet()) {
Character c = entry.getKey();
Integer x = entry.getValue();
if(s[pos]==c) {
badInfo[x]=ind[pos]-'0';
trace(x,pos+1);
return;
}
}
return;
}
long dfs(int idx) {
if (ways[idx] != -1)
return ways[idx];
long way = 0;
for (Map.Entry<Character, Integer> entry : next[idx].entrySet()) {
Character c = entry.getKey();
Integer x = entry.getValue();
if (c == '$' && idx != 0)
way++;
else {
way += dfs(x);
}
}
return ways[idx] = way;
}
void traverse() {
Arrays.fill(ways, -1);
dfs3(0);
trace(0,0);
// System.out.println(Arrays.toString(badInfo));
}
void dfs3(int u) {
if (ways[u] != -1)
return;
ways[u] = 0;
for (Entry<Character, Integer> e : next[u].entrySet()) {
int v = e.getValue();
char c = e.getKey();
if (c == '$')
ways[u]++;
dfs3(v);
ways[u] += ways[v];
}
}
}
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
in.readLine();
String x = in.readLine();
String ind = in.readLine() + "0";
SuffixAutomaton sa = new SuffixAutomaton((x + "$").toCharArray(), ind.toCharArray());
sa.traverse();
sa.populate();
long ans = 0;
PrintWriter out = new PrintWriter(System.out);
for (int i = 1; i < sa.len.length; i++) {
long max = sa.len[i];
long indicesBad = sa.map[i];
long ways = sa.ways[i];
//System.out.println(ways+" "+indicesBad+" "+max);
ans = Math.max(ans, (ways - indicesBad*1l) * max);
// System.out.println(ans);
}
out.println(ans);
out.flush();
out.close();
}
}
|
Vasya has an array of integers of length n.
Vasya performs the following operations on the array: on each step he finds the longest segment of consecutive equal integers (the leftmost, if there are several such segments) and removes it. For example, if Vasya's array is [13, 13, 7, 7, 7, 2, 2, 2], then after one operation it becomes [13, 13, 2, 2, 2].
Compute the number of operations Vasya should make until the array becomes empty, i.e. Vasya removes all elements from it.
Input
The first line contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array.
The second line contains a sequence a1, a2, ..., an (1 ≤ ai ≤ 109) — Vasya's array.
Output
Print the number of operations Vasya should make to remove all elements from the array.
Examples
Input
4
2 5 5 2
Output
2
Input
5
6 3 4 1 5
Output
5
Input
8
4 4 4 2 2 100 100 100
Output
3
Input
6
10 10 50 10 50 50
Output
4
Note
In the first example, at first Vasya removes two fives at the second and third positions. The array becomes [2, 2]. In the second operation Vasya removes two twos at the first and second positions. After that the array becomes empty.
In the second example Vasya has to perform five operations to make the array empty. In each of them he removes the first element from the array.
In the third example Vasya needs three operations. In the first operation he removes all integers 4, in the second — all integers 100, in the third — all integers 2.
In the fourth example in the first operation Vasya removes the first two integers 10. After that the array becomes [50, 10, 50, 50]. Then in the second operation Vasya removes the two rightmost integers 50, so that the array becomes [50, 10]. In the third operation he removes the remaining 50, and the array becomes [10] after that. In the last, fourth operation he removes the only remaining 10. The array is empty after that.
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.TreeSet;
public class Solution{
public static void main(String[] args) throws IOException {
FastScanner fs = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
int tt = 1;
while(tt-->0) {
int n = fs.nextInt();
int[] a = fs.readArray(n);
TreeSet<int[]> tsSize = new TreeSet<>((x, y) -> (x[0]==y[0])?(x[1]-y[1]):(y[0]-x[0]));
TreeSet<int[]> tsLeft = new TreeSet<>((x, y) -> x[1] - y[1]);
for(int i=0;i<n;) {
int left = i, val = a[i];
int size = 0;
while(i<n && a[i]==val) {
i++; size++;
}
tsSize.add(new int[] {size, left});
tsLeft.add(new int[] {size, left});
}
int ans = 0;
while(tsSize.size()>0) {
ans++;
int[] cur = tsSize.pollFirst();
tsLeft.remove(cur);
int ind = cur[1];
int[] left = tsLeft.floor(new int[] {0, ind});
int[] right = tsLeft.ceiling(new int[] {0, ind});
if(left==null || right==null || a[left[1]]!=a[right[1]]) continue;
tsSize.remove(left);
tsLeft.remove(left);
tsSize.remove(right);
tsLeft.remove(right);
int[] merge = new int[] {left[0]+right[0], left[1]};
tsSize.add(merge);
tsLeft.add(merge);
}
out.println(ans);
}
out.close();
}
static final Random random=new Random();
static <T> void shuffle(T[] arr) {
int n = arr.length;
for(int i=0;i<n;i++ ) {
int k = random.nextInt(n);
T temp = arr[k]; arr[k] = arr[i]; arr[i] = temp;
}
}
static void ruffleSort(int[] a) {
int n=a.length;//shuffle, then sort
for (int i=0; i<n; i++) {
int oi=random.nextInt(n); int temp=a[oi];
a[oi]=a[i]; a[i]=temp;
}
Arrays.sort(a);
}
static void ruffleSort(long[] a) {
int n=a.length;//shuffle, then sort
for (int i=0; i<n; i++) {
int oi=random.nextInt(n); long temp=a[oi];
a[oi]=a[i]; a[i]=temp;
}
Arrays.sort(a);
}
static void reverse(int[] arr, int l, int r) {
for(int i=l;i<l+(r-l)/2;i++){
int temp = arr[i]; arr[i] = arr[r-i+l-1]; arr[r-i+l-1] = temp;
}
}
static void reverse(long[] arr, int l, int r) {
for(int i=l;i<l+(r-l)/2;i++){
long temp = arr[i]; arr[i] = arr[r-i+l-1]; arr[r-i+l-1] = temp;
}
}
static <T> void reverse(T[] arr, int l, int r) {
for(int i=l;i<l+(r-l)/2;i++) {
T temp = arr[i]; arr[i] = arr[r-i+l-1]; arr[r-i+l-1] = temp;
}
}
static class FastScanner{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer("");
public String next(){
while(!st.hasMoreElements()){
try{
st = new StringTokenizer(br.readLine());
} catch(IOException e){
e.printStackTrace();
}
}
return st.nextToken();
}
public String nextLine() throws IOException {
return br.readLine();
}
public int nextInt(){
return Integer.parseInt(next());
}
public int[] readArray(int n){
int[] a = new int[n];
for(int i=0;i<n;i++)
a[i] = nextInt();
return a;
}
public long nextLong() {
return Long.parseLong(next());
}
public char nextChar() {
return next().toCharArray()[0];
}
}
}
|
It is winter now, and Max decided it's about time he watered the garden.
The garden can be represented as n consecutive garden beds, numbered from 1 to n. k beds contain water taps (i-th tap is located in the bed xi), which, if turned on, start delivering water to neighbouring beds. If the tap on the bed xi is turned on, then after one second has passed, the bed xi will be watered; after two seconds have passed, the beds from the segment [xi - 1, xi + 1] will be watered (if they exist); after j seconds have passed (j is an integer number), the beds from the segment [xi - (j - 1), xi + (j - 1)] will be watered (if they exist). Nothing changes during the seconds, so, for example, we can't say that the segment [xi - 2.5, xi + 2.5] will be watered after 2.5 seconds have passed; only the segment [xi - 2, xi + 2] will be watered at that moment.
<image> The garden from test 1. White colour denotes a garden bed without a tap, red colour — a garden bed with a tap. <image> The garden from test 1 after 2 seconds have passed after turning on the tap. White colour denotes an unwatered garden bed, blue colour — a watered bed.
Max wants to turn on all the water taps at the same moment, and now he wonders, what is the minimum number of seconds that have to pass after he turns on some taps until the whole garden is watered. Help him to find the answer!
Input
The first line contains one integer t — the number of test cases to solve (1 ≤ t ≤ 200).
Then t test cases follow. The first line of each test case contains two integers n and k (1 ≤ n ≤ 200, 1 ≤ k ≤ n) — the number of garden beds and water taps, respectively.
Next line contains k integers xi (1 ≤ xi ≤ n) — the location of i-th water tap. It is guaranteed that for each <image> condition xi - 1 < xi holds.
It is guaranteed that the sum of n over all test cases doesn't exceed 200.
Note that in hacks you have to set t = 1.
Output
For each test case print one integer — the minimum number of seconds that have to pass after Max turns on some of the water taps, until the whole garden is watered.
Example
Input
3
5 1
3
3 3
1 2 3
4 1
1
Output
3
1
4
Note
The first example consists of 3 tests:
1. There are 5 garden beds, and a water tap in the bed 3. If we turn it on, then after 1 second passes, only bed 3 will be watered; after 2 seconds pass, beds [1, 3] will be watered, and after 3 seconds pass, everything will be watered.
2. There are 3 garden beds, and there is a water tap in each one. If we turn all of them on, then everything will be watered after 1 second passes.
3. There are 4 garden beds, and only one tap in the bed 1. It will take 4 seconds to water, for example, bed 4.
|
t=int(input())
for _ in range(t):
n,k=list(map(int,input().split()))
x=list(map(int,input().split()))
b=[]
for i in range(1,n+1):
a=[]
for j in range(k):
a.append(abs(x[j]-i))
b.append(min(a))
print(max(b)+1)
|
Alice has a very important message M consisting of some non-negative integers that she wants to keep secret from Eve. Alice knows that the only theoretically secure cipher is one-time pad. Alice generates a random key K of the length equal to the message's length. Alice computes the bitwise xor of each element of the message and the key (<image>, where <image> denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR)) and stores this encrypted message A. Alice is smart. Be like Alice.
For example, Alice may have wanted to store a message M = (0, 15, 9, 18). She generated a key K = (16, 7, 6, 3). The encrypted message is thus A = (16, 8, 15, 17).
Alice realised that she cannot store the key with the encrypted message. Alice sent her key K to Bob and deleted her own copy. Alice is smart. Really, be like Alice.
Bob realised that the encrypted message is only secure as long as the key is secret. Bob thus randomly permuted the key before storing it. Bob thinks that this way, even if Eve gets both the encrypted message and the key, she will not be able to read the message. Bob is not smart. Don't be like Bob.
In the above example, Bob may have, for instance, selected a permutation (3, 4, 1, 2) and stored the permuted key P = (6, 3, 16, 7).
One year has passed and Alice wants to decrypt her message. Only now Bob has realised that this is impossible. As he has permuted the key randomly, the message is lost forever. Did we mention that Bob isn't smart?
Bob wants to salvage at least some information from the message. Since he is not so smart, he asks for your help. You know the encrypted message A and the permuted key P. What is the lexicographically smallest message that could have resulted in the given encrypted text?
More precisely, for given A and P, find the lexicographically smallest message O, for which there exists a permutation π such that <image> for every i.
Note that the sequence S is lexicographically smaller than the sequence T, if there is an index i such that Si < Ti and for all j < i the condition Sj = Tj holds.
Input
The first line contains a single integer N (1 ≤ N ≤ 300000), the length of the message.
The second line contains N integers A1, A2, ..., AN (0 ≤ Ai < 230) representing the encrypted message.
The third line contains N integers P1, P2, ..., PN (0 ≤ Pi < 230) representing the permuted encryption key.
Output
Output a single line with N integers, the lexicographically smallest possible message O. Note that all its elements should be non-negative.
Examples
Input
3
8 4 13
17 2 7
Output
10 3 28
Input
5
12 7 87 22 11
18 39 9 12 16
Output
0 14 69 6 44
Input
10
331415699 278745619 998190004 423175621 42983144 166555524 843586353 802130100 337889448 685310951
226011312 266003835 342809544 504667531 529814910 684873393 817026985 844010788 993949858 1031395667
Output
128965467 243912600 4281110 112029883 223689619 76924724 429589 119397893 613490433 362863284
Note
In the first case, the solution is (10, 3, 28), since <image>, <image> and <image>. Other possible permutations of key yield messages (25, 6, 10), (25, 3, 15), (10, 21, 10), (15, 21, 15) and (15, 6, 28), which are all lexicographically larger than the solution.
|
#include <bits/stdc++.h>
using namespace std;
struct TrieNode {
int cnt;
TrieNode *arr[2];
};
TrieNode *newNode() {
TrieNode *temp = new TrieNode;
temp->cnt = 0;
temp->arr[0] = temp->arr[1] = NULL;
return temp;
}
void insert(TrieNode *root, int pre_xor) {
TrieNode *temp = root;
for (int i = 32 - 1; i >= 0; i--) {
bool val = pre_xor & (1 << i);
if (temp->arr[val] == NULL) {
temp->arr[val] = newNode();
}
temp = temp->arr[val];
temp->cnt += 1;
}
}
int query(TrieNode *root, int pre_xor) {
TrieNode *temp = root;
int ans = 0;
for (int i = 32 - 1; i >= 0; i--) {
bool val = pre_xor & (1 << i);
if ((temp->arr[val] != NULL) && (temp->arr[val]->cnt) > 0) {
temp = temp->arr[val];
ans += val * (1 << i);
} else if ((temp->arr[1 - val]) != NULL && (temp->arr[1 - val]->cnt) > 0) {
temp = temp->arr[1 - val];
ans += (1 - val) * (1 << i);
}
temp->cnt -= 1;
}
return pre_xor ^ ans;
}
int main() {
int n;
cin >> n;
vector<int> a, b;
for (int i = 0; i < n; i++) {
int u;
cin >> u;
a.push_back(u);
}
TrieNode *root = newNode();
for (int i = 0; i < n; i++) {
int v;
cin >> v;
insert(root, v);
}
vector<int> ans;
for (int i = 0; i < n; i++) {
int u = a[i];
ans.push_back(query(root, u));
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
cout << '\n';
}
|
You are given a sequence of n positive integers d1, d2, ..., dn (d1 < d2 < ... < dn). Your task is to construct an undirected graph such that:
* there are exactly dn + 1 vertices;
* there are no self-loops;
* there are no multiple edges;
* there are no more than 106 edges;
* its degree set is equal to d.
Vertices should be numbered 1 through (dn + 1).
Degree sequence is an array a with length equal to the number of vertices in a graph such that ai is the number of vertices adjacent to i-th vertex.
Degree set is a sorted in increasing order sequence of all distinct values from the degree sequence.
It is guaranteed that there exists such a graph that all the conditions hold, and it contains no more than 106 edges.
Print the resulting graph.
Input
The first line contains one integer n (1 ≤ n ≤ 300) — the size of the degree set.
The second line contains n integers d1, d2, ..., dn (1 ≤ di ≤ 1000, d1 < d2 < ... < dn) — the degree set.
Output
In the first line print one integer m (1 ≤ m ≤ 106) — the number of edges in the resulting graph. It is guaranteed that there exists such a graph that all the conditions hold and it contains no more than 106 edges.
Each of the next m lines should contain two integers vi and ui (1 ≤ vi, ui ≤ dn + 1) — the description of the i-th edge.
Examples
Input
3
2 3 4
Output
8
3 1
4 2
4 5
2 5
5 1
3 2
2 1
5 3
Input
3
1 2 3
Output
4
1 2
1 3
1 4
2 3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int d[1010];
cin >> n;
for (int i = 0; i < n; i++) cin >> d[i];
vector<vector<int> > G(d[n - 1] + 1);
int l = 0, m = 0;
for (int i = 0, j = n - 1; i <= j; i++, j--) {
for (int k = 0; k < d[i]; k++)
for (int t = l; t <= l + d[j]; t++)
if (t > k + l) {
m++;
G[t].push_back(k + l);
G[k + l].push_back(t);
}
l += d[i] + 1;
for (int k = j; k >= i; k--) d[k] -= d[i];
}
cout << m << endl;
for (int i = 0; i < G.size(); i++)
for (int j = 0; j < G[i].size(); j++)
if (i < G[i][j]) cout << i + 1 << ' ' << G[i][j] + 1 << endl;
return 0;
}
|
Allen wants to enter a fan zone that occupies a round square and has n entrances.
There already is a queue of a_i people in front of the i-th entrance. Each entrance allows one person from its queue to enter the fan zone in one minute.
Allen uses the following strategy to enter the fan zone:
* Initially he stands in the end of the queue in front of the first entrance.
* Each minute, if he is not allowed into the fan zone during the minute (meaning he is not the first in the queue), he leaves the current queue and stands in the end of the queue of the next entrance (or the first entrance if he leaves the last entrance).
Determine the entrance through which Allen will finally enter the fan zone.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of entrances.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — the number of people in queues. These numbers do not include Allen.
Output
Print a single integer — the number of entrance that Allen will use.
Examples
Input
4
2 3 2 0
Output
3
Input
2
10 10
Output
1
Input
6
5 2 6 5 7 4
Output
6
Note
In the first example the number of people (not including Allen) changes as follows: [2, 3, 2, 0] → [1, 2, 1, 0] → [0, 1, 0, 0]. The number in bold is the queue Alles stands in. We see that he will enter the fan zone through the third entrance.
In the second example the number of people (not including Allen) changes as follows: [10, 10] → [9, 9] → [8, 8] → [7, 7] → [6, 6] → \\\ [5, 5] → [4, 4] → [3, 3] → [2, 2] → [1, 1] → [0, 0].
In the third example the number of people (not including Allen) changes as follows: [5, 2, 6, 5, 7, 4] → [4, 1, 5, 4, 6, 3] → [3, 0, 4, 3, 5, 2] → \\\ [2, 0, 3, 2, 4, 1] → [1, 0, 2, 1, 3, 0] → [0, 0, 1, 0, 2, 0].
|
import math
num_entrances = int(raw_input())
num_people = map(int, raw_input().split())
when_he_arrives = num_people
for i in range(len(num_people)):
when_he_arrives[i] = num_people[i] - i
# import pdb; pdb.set_trace()
min_en = (999999999999, 999999999999) #entrance number, num iter
for j in range(len(num_people)):
num_iter = math.ceil(float(when_he_arrives[j]) / num_entrances)
if (num_iter <= 0):
if (min_en[1] > 0):
min_en = (j, num_iter)
else:
if (num_iter < min_en[1]):
min_en = (j, num_iter)
print min_en[0] + 1
|
A square pyramid of balls consists of square layers of balls stacked on top of each other. The i th (1-based indexing )layer from the top consists of exactly i^2 balls. Image
You have received one such beautiful square pyramid on your birthday, with each layer having a unique color. However, being the clumsy doofus you are, you knocked it over and lost some(maybe all) balls of some(maybe all) layers. You quickly gather the balls and try to reconstruct a square pyramid(maybe of a different height) by using all the recovered balls and replacing the missing balls by new ones from the nearby shop(remember, all layers had unique colors, so you couldn't use balls from one layer in another). Find the minimum number of balls you shall have to purchase.
Input:
You are given an integer N, the number of layers having at-least one recovered ball.
Then N space separated integers follow in the next line, with A[i] representing the number of recovered balls in the ith such layer
Output:
Print the required value.
Constraints:
1 ≤ N ≤ 1,000,000
1 ≤ A[i] ≤ 1,000,000,000
SAMPLE INPUT
5
1 2 3 4 5
SAMPLE OUTPUT
40
Explanation
For layer one, you have enough balls (1 + 0 = 1)
For layer two, you have enough balls (4 + 0 = 4)
For layer three, you buy 4 balls (5 + 4 = 9)
For layer four, you buy 14 balls (2 + 14 = 16)
For layer five, you buy 22 balls (3 + 22 = 25)
|
n = input()
a = map(int, raw_input().split() )
a.sort()
layer, result = 1, 0
for u in a:
while layer * layer < u:
result += layer * layer
layer += 1
result += layer * layer - u
layer += 1
print result
|
"Money money MONEY, I want money" thought Alex. "Now how do I get money? Well... I'll open up a camp!"
Well, unfortunately things didn't go so well for Alex's campers, and now there are N campers wandering around the city aimlessly. You have to handle Q queries; which consist of two groups finding each other and becoming one larger group. After each query, output the difference between the group of largest size and group of smallest size. If there is only one group, output 0. At first, everyone is in their own group.
Also note, if the two campers in the query are already in the same group, print the current answer, and skip merging the groups together.
Input:
The first line consists of two space separated integers, N and Q
The next Q line consists of two integers, A and B, meaning that the groups involving camper A and camper B find each other.
Output:
Output Q lines, the answer after each query.
Constraints:
1 ≤ N ≤ 10^5
1 ≤ Q ≤ 10^5
SAMPLE INPUT
2 1
1 2
SAMPLE OUTPUT
0
Explanation
Here, the two campers find each other, so the answer is 0.
|
def union(parents, depths, i, j):
''' Union with under the deepest root '''
if depths[i] > depths[j]:
parents[j] = i
else:
parents[i] = j
depths[i] = max(depths[i], depths[j] + 1)
def find(parents, el):
''' Find an element and compress the sets '''
if parents[el] == el: return el
leader = find(parents, parents[el])
parents[el] = leader
return leader
def solve(n, xss):
depths = [1] * n
parents = range(0, n)
group_sizes = [1] * n
count_group_of_size = [0] * (n + 1)
count_group_of_size[1] = n
smaller_index = 1
maxi = 1
res = []
for a, b in xss:
root_a = find(parents, a - 1)
root_b = find(parents, b - 1)
if root_a != root_b:
union(parents, depths, root_a, root_b)
count_group_of_size[group_sizes[root_a]] -= 1
count_group_of_size[group_sizes[root_b]] -= 1
new_size = group_sizes[root_a] + group_sizes[root_b]
group_sizes[root_a] = new_size
group_sizes[root_b] = new_size
count_group_of_size[new_size] += 1
maxi = max(maxi, new_size)
while count_group_of_size[smaller_index] == 0: smaller_index += 1
res.append(str(maxi - smaller_index))
return '\n'.join(res)
if __name__ == '__main__':
n, q = map(int, raw_input().split())
xss = [map(int, raw_input().split()) for _ in range(q)]
print solve(n, xss)
|
Shivani is interning at HackerEarth. One day she has to distribute some chocolates to her colleagues. She is biased towards her friends and may have distributed the chocolates unequally. One of the program managers gets to know this and orders Shivani to make sure everyone gets equal number of chocolates.
But to make things difficult for the intern, she is ordered to equalize the number of chocolates for every colleague in the following manner,
For every operation, she can choose one of her colleagues and can do one of the three things.
(i) She can give one chocolate to every colleague other than chosen one.
(ii) She can give two chocolates to every colleague other than chosen one.
(iii) She can give five chocolates to every colleague other than chosen one.
Calculate minimum number of such operations needed to ensure that every colleague has the same number of chocolates.
Input Format
First line contains an integer T denoting the number of testcases. T testcases follow.
Each testcase has 2 lines. First line of each testcase contains an integer N denoting the number of co-interns. Second line contains N space separated integers denoting the current number of chocolates each colleague has.
Output Format
T lines, each containing the minimum number of operations needed to make sure all colleagues have the same number of chocolates.
Constraints
1 ≤ T ≤ 100
1 ≤ N ≤ 10000
Number of initial chocolates each colleague has < 1000
SAMPLE INPUT
1
4
2 2 3 7
SAMPLE OUTPUT
2
Explanation
1st case: Shivani increases all elements by 1 except 3rd one
2 2 3 7 -> 3 3 3 8
2nd case: Shivani increases all element by 5 except last one
3 3 3 8 -> 8 8 8 8
|
T = int(raw_input().strip())
inc_list= [1,2,5]
for t in range(T):
N = int(raw_input().strip())
nums = [int(i) for i in raw_input().strip().split()]
nums.sort()
step = 0
addition = 0
for i in range(1,len(nums)):
diff = nums[i]-nums[0]
while diff:
if diff>=5:
add_step = diff/5
sub = add_step*5
elif diff>=2:
add_step = diff/2
sub = add_step*2
else:
add_step = 1
sub = 1
diff -= sub
step += add_step
print step
|
Golu loves prime numbers . He wants to do something new with prime numbers. So Molu gives him a number and asks him to minmum number of prime numbers required such that their sum is equal to given number. This task is very diffcult for Golu so he asks you for your help.
Now your task is that you are given a number and you have to find minimum number of prime numbers required such that their sum is equal to given number.
INPUT First line contains number of test cases T . Each test case contains a single integer N.
OUTPUT For each test case print in a single line minmum number of primes numbers required.
Constraints
1 ≤ T ≤ 1000000
2 ≤ N ≤ 1000000
SAMPLE INPUT
2
2
4
SAMPLE OUTPUT
1
2
Explanation
for N=2 one prime number (2)
for N=4 two prime numbers (2 + 2)
|
import math
def check(n):
return all( n%i for i in range(2, int(math.sqrt(n) ) + 1 ))
for i in range(input()):
val = input()
print "1" if check(val) else "2" if check(val-2) or val % 2 == 0 else "3"
"""
import math
primes = []
def primeSieve(sieveSize):
sieve = [True] * sieveSize
sieve[0] = False
sieve[1] = False
for i in range(2, int(math.sqrt(sieveSize)) + 1):
pointer = i * 2
while pointer < sieveSize:
sieve[pointer] = False
pointer += i
for i in range(sieveSize):
if sieve[i] == True:
primes.append(i)
primeSieve(1000000)
for i in range(input()):
val = input()
if val == 1 :
print "1"
else :
if val >2 and val%2 == 0:
print "2"
else:
if val in primes:
print "1"
elif (val-2) in primes:
print "2"
else:
print "3"
"""
|
Kuldeep's girlfriend Christie recently got her PhD in Maths. So to celebrate, they both decided to play games with mathematical sequences for their date nights.
The game they are playing today is "Jackpot Palindrome", the objective of the game is to find out length of the largest palindrome which only contains the digit "4" from a given string.
The reference string for today is the lucky string. Lucky string is the concatenation of all lucky numbers in ascending order.
Lucky numbers are those numbers which contain only "4" and/or "5". For example 4, 5, 44, 54,55,444 are lucky numbers while 457, 987 ,154 are not.
So the fist few digits of the lucky string are "4544455455444445454455..." .
Since the lucky string is infinite, Christie gives Kuldeep an integer N and Kuldeep only needs to consider the lucky string upto length N.
Everytime Kuldeep answers correctly, he gets a kiss from Christie, obviously he'd want to maximize the number of kisses he gets, so your task is to help Kuldeep answer correctly everytime.
Input:
First line contains no of test cases T.
Next T lines contains a single integer N.
Output:
A single integer which is length of the largest palindrome substring containing only digit "4" in lucky string of length N.
Constraints:
1 ≤ T ≤ 100000
1 ≤ N ≤ 10^15
SAMPLE INPUT
4
1
2
3
4
SAMPLE OUTPUT
1
1
1
2
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
T = int(raw_input())
t = 0
while(t<T):
t = t+1
N = int(raw_input())
n = N
length = 1
while( (n - 2*length + 1) >= 0):
n = n - (2**length)*length
length = length + 1
length = length - 1
m = 2*length - 1
if(m > n):
print '%d' %m
else:
print '%d' %n
|
Navi is a famous shopkeeper in his locality. He gives discounts to his regular customers. Some new rules have been made due to which he is in trouble. According to the new rules, any shopkeeper can sale his items to only one customer in a day. But every customer has some issues like the total money they have or the total weight they can handle at a time or number of items they are interested in. Navi’s friend has decided to help Navi and he promised him that he will purchase items from his shop daily and try to maximize his sale in terms of total price with satisfying the count of items and weight of the items . He will give his requirements as Wmax (maximum weight he can carry) and C (maximum count of the items he can carry). Now Navi is interested in knowing the total price of the items he can sell.
Input
First line of input will contain D (total number of days). Then for each day first line will contain N (Number of items) . Next each N lines will contains two integers P (price of ith item on that day) and W(weight of ith item on that day) separated by a space. Last line for the input of the particular day will contain Wmax and C separated by a space.
Output
For each day output “For Day #day_number:” then in next line print the maximum total price. If his friend is not able to purchase any of the item then print -1.
Constraints
1 < = D < = 10
1 < = N < = 16
1 < = C < = 20
1 < = Pi , Wi , Wmax < = 10^9
SAMPLE INPUT
1
3
10 20
20 30
30 40
50 2
SAMPLE OUTPUT
For Day #1:
30
Explanation
He will buy first and second item.
|
import math
def solve(indx, sums, prev, curr):
global noOfItem, cnts, wtMax, price, weight
if indx == noOfItem or curr == cnts or sums == wtMax:
return prev
ans1 = solve(indx + 1, sums, prev, curr)
ans2 = 0
if (sums + weight[indx]) <= wtMax:
ans2 = solve(indx + 1, sums + weight[indx], prev + price[indx], curr + 1)
return max(ans1, ans2)
noOfDays = input()
for d in range(noOfDays):
noOfItem = input()
price = []
weight = []
for i in range(noOfItem):
a, b = map(int, raw_input().split())
price.append(a)
weight.append(b)
wtMax, cnts = map(int, raw_input().split())
ans = solve(0, 0, 0, 0)
if ans > 0:
answ = ans
else:
answ = - 1
print "For Day #{}:".format(d + 1)
print answ
|
Heading ##There are two integers A and B. You are required to compute the bitwise AND amongst all natural numbers lying between A and B, both inclusive.
Input Format
First line of the input contains T, the number of testcases to follow.
Each testcase in a newline contains A and B separated by a single space.
Constraints
1≤T≤200
0≤A≤B<232
Output Format
Output one line per test case with the required bitwise AND.
SAMPLE INPUT
3
12 15
2 3
8 13
SAMPLE OUTPUT
12
2
8
Explanation
1st Test Case : 12 & 13 & 14 & 15 = 12
2nd Test Case : 2 & 3 = 2
3rd Test Case : 8 & 9 & 10 & 11 & 12 & 13 = 8
|
tc=input()
while tc:
a,b=map(int,raw_input().split())
if a<b:
print a
else:
print b
tc=tc-1
|
Richard is a travel freak. He is now out to travel to a distant place with his friends, so he took his car and went out with a certain amount of fuel. Thus he must stop at a fuel station before his fuel gets over. There are several fuel station with 1 km gap providing fixed amount of fuel.
At each fuel station his tank is first emptied and then refueled by the amount of fuel that the current fuel station provides.
Help him reach his destination as fast as possible making minimum no of stops as there is a party planned at his destination.
INPUT
First Line contains no of test cases T.
For Each Test case,
First line contains an integer D, (distance to his destination + 1).
Next line contains D space-separated integers (N) which is the amount of fuel a fuel station at that kilometer provides. The first digit in this line shows the amount of Fuel he started with.
Output
T lines of Integers showing the minimum no of stops he can make to reach the destination for each test case.
Constraints
T ≤ 10000
1 ≤ D ≤ 100000
1 ≤ N ≤ 1000
Note:
He can go 1km with 1 Litre of Petrol.
SAMPLE INPUT
2
5
2 15 5 6 2
11
1 3 5 8 9 2 6 7 6 8 9
SAMPLE OUTPUT
1
2
Explanation
First Test case contains 5 Integers.
Initially he has 2 litres of fuel, so he can go up to 2Kms. Thus he makes a stop at 1st Km. There he gets 15 Liters of fuel by which he can reach the end of his destination So only one stop needed.
For the second test case, which contain 11 integers.
He Starts with 1 Litre of Fuel, Stops at 1st Km refueling 3 Litres of fuel. Then he stops at the 4th Km filling 9 litres by which he can reach his destination. Thus two stops needed.
Note: For updated Problem Statement
1
5
4 1 9 1 4
for this input output must be
0
since he hast 4 litres of fuel and can reach to the destination by itself.
|
def distance(dis,alist):
i=0
next=0
mx =0
t=0
while i<dis-1 and next<dis-1:
mx=max(mx,i+int(alist[i]))
if i==next:
if mx == next:
return -1
next = mx
t+=1
i+=1
return t
test=int(raw_input())
while test>0:
dis=int(raw_input())
str=raw_input()
alist=str.split(' ')
result=distance(dis,alist)
print(result-1)
test-=1
|
Gudi, a fun loving girl from the city of Dun, travels to Azkahar - a strange land beyond the mountains. She arrives at the gates of Castle Grey, owned by Puchi,the lord of Azkahar to claim the treasure that it guards. However, destiny has other plans for her as she has to move through floors, crossing obstacles on her way to reach the treasure.
The gates of the castle are closed. An integer N is engraved on the gates. A writing on the wall says
Tap the gates as many times as there are unordered pairs of distinct integers from 1 to N whose bit-wise XOR does not exceed N.
Help her find the number of the times she has to tap.
Input:
First line contains an integer T, T testcases follow.
Each testcase consists of an integer N.
Output:
Print the answer to each testcase in a newline.
Constraints:
1 ≤ T ≤ 100
2 ≤ N ≤ 2000
SAMPLE INPUT
3
4
6
8
SAMPLE OUTPUT
3
12
21
Explanation
For N=4, pairs are (1,2) , (1,3) and (2,3)
|
from operator import xor
tests = int(raw_input())
for test in range(tests):
number = int(raw_input())
count = 0
for i in range(1, number):
for j in range(i+1, number+1):
if xor(i, j) <= number:
count +=1
print count
|
Xenny had N numbers and he loved equal triplets (An equal triplet is group of 3 numbers that are equal).
He defined a K-equal-triplet as a triplet in which all 3 integers were equal to K.
Given an integer K, he wanted to find out the probability of getting a K-equal triplet, from the N numbers.
Xenny is bad at understanding floating point numbers. Help him to find the probability in terms of a fraction, reduced to its lowest terms.
Input
First line contains a single integer - T, the total number of testcases.
T testcases follow.
Each testcase consists of 2 lines:
First line contains 2 space-separated integers - N and K, which represent the total number of integers Xenny had, and the value K whose K-equal-triplet was required.
Output
For each testcase, print the probability of finding a K-equal-triplet in terms of the lowest fraction.
For example, if the answer is 4/8, you must print 1/2, which is the lowest reduced fraction of 4/8.
Constraints
1 ≤ T ≤ 50
1 ≤ N ≤ 10^6
1 ≤ Numbers ≤ 10^9
1 ≤ K ≤ 10^9
Note:
1) 2 testcase files are large (about 20 MB) in size. Please use fast I/O in your code.
2) Candidates need to attempt only one of the given problems
SAMPLE INPUT
1
5 4
1 4 4 4 1
SAMPLE OUTPUT
1/10
Explanation
K = 4
There is exactly one triplet (4, 4, 4) that can be selected from the given numbers.
Hence, the probability of selecting a 4-equal-triplet is 1/10.
|
def gcd(a,b):
if a == 0:
return b
if b == 0:
return a;
return gcd(b%a, a)
test = int(raw_input())
for i in range(test):
n,k = map(long, raw_input().split())
arr = map(long, raw_input().split())
cnt = 0
for j in range(0, n):
x = arr[j]
if x==k:
cnt = cnt+1
ans1 = n*(n-1)*(n-2)
ans2 = cnt*(cnt-1)*(cnt-2)
ans = gcd(ans1,ans2)
print str(ans2/ans)+'/'+str(ans1/ans)
|
We have a rooted binary tree with N vertices, where the vertices are numbered 1 to N. Vertex 1 is the root, and the parent of Vertex i (i \geq 2) is Vertex \left[ \frac{i}{2} \right].
Each vertex has one item in it. The item in Vertex i has a value of V_i and a weight of W_i. Now, process the following query Q times:
* Given are a vertex v of the tree and a positive integer L. Let us choose some (possibly none) of the items in v and the ancestors of v so that their total weight is at most L. Find the maximum possible total value of the chosen items.
Here, Vertex u is said to be an ancestor of Vertex v when u is an indirect parent of v, that is, there exists a sequence of vertices w_1,w_2,\ldots,w_k (k\geq 2) where w_1=v, w_k=u, and w_{i+1} is the parent of w_i for each i.
Constraints
* All values in input are integers.
* 1 \leq N < 2^{18}
* 1 \leq Q \leq 10^5
* 1 \leq V_i \leq 10^5
* 1 \leq W_i \leq 10^5
* For the values v and L given in each query, 1 \leq v \leq N and 1 \leq L \leq 10^5.
Input
Let v_i and L_i be the values v and L given in the i-th query. Then, Input is given from Standard Input in the following format:
N
V_1 W_1
:
V_N W_N
Q
v_1 L_1
:
v_Q L_Q
Output
For each integer i from 1 through Q, the i-th line should contain the response to the i-th query.
Examples
Input
3
1 2
2 3
3 4
3
1 1
2 5
3 5
Output
0
3
3
Input
15
123 119
129 120
132 112
126 109
118 103
115 109
102 100
130 120
105 105
132 115
104 102
107 107
127 116
121 104
121 115
8
8 234
9 244
10 226
11 227
12 240
13 237
14 206
15 227
Output
256
255
250
247
255
259
223
253
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll f[520][100005],ans[100005];
int n,q,v[300005],w[300005];
typedef pair<int,int> pr;
vector<pr> qr[300005];
ll Query(int x,int va){
if(x<512)return f[x][va];
ll ret=Query(x/2,va);
if(va>=v[x])ret=max(ret,Query(x/2,va-v[x])+w[x]);
return ret;
}
void dp(int x){
if(x>n)return ;
if(x<512){
for(int i=100000;i>=v[x];i--)f[x][i]=max(f[x/2][i],f[x/2][i-v[x]]+w[x]);
for(int i=v[x]-1;i>=0;i--)f[x][i]=f[x/2][i];
for(pr a:qr[x])ans[a.second]=f[x][a.first];
}
else {
for(pr a:qr[x])ans[a.second]=Query(x,a.first);
}
dp(x*2),dp(x*2+1);
}
int main(){
cin>>n;
for(int i=1;i<=n;i++)scanf("%d%d",&w[i],&v[i]);
cin>>q;
for(int i=1,x,y;i<=q;i++)scanf("%d%d",&x,&y),qr[x].push_back(make_pair(y,i));
dp(1);
for(int i=1;i<=q;i++)cout<<ans[i]<<'\n';
}
|
We have A balls with the string S written on each of them and B balls with the string T written on each of them.
From these balls, Takahashi chooses one with the string U written on it and throws it away.
Find the number of balls with the string S and balls with the string T that we have now.
Constraints
* S, T, and U are strings consisting of lowercase English letters.
* The lengths of S and T are each between 1 and 10 (inclusive).
* S \not= T
* S=U or T=U.
* 1 \leq A,B \leq 10
* A and B are integers.
Input
Input is given from Standard Input in the following format:
S T
A B
U
Output
Print the answer, with space in between.
Examples
Input
red blue
3 4
red
Output
2 4
Input
red blue
5 5
blue
Output
5 4
|
S,T=input().split()
a,b=map(int,input().split())
n=input()
if S==n:
print(a-1,b)
else:
print(a,b-1)
|
Takahashi is going to buy N items one by one.
The price of the i-th item he buys is A_i yen (the currency of Japan).
He has M discount tickets, and he can use any number of them when buying an item.
If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.
What is the minimum amount of money required to buy all the items?
Constraints
* All values in input are integers.
* 1 \leq N, M \leq 10^5
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
Output
Print the minimum amount of money required to buy all the items.
Examples
Input
3 3
2 13 8
Output
9
Input
4 4
1 9 3 5
Output
6
Input
1 100000
1000000000
Output
0
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
9500000000
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,m,i;
long long sum = 0;
scanf("%d %d",&n,&m);
priority_queue<int> q;
for(i=0;i<n;i++)
{
int x;
scanf("%d",&x);
q.push(x);
}
while (m--)
{
int x = q.top();
q.pop();
q.push(x / 2);
}
while (!q.empty())
{
sum += q.top();
q.pop();
}
cout << sum;
return 0;
}
|
Snuke has come to a store that sells boxes containing balls. The store sells the following three kinds of boxes:
* Red boxes, each containing R red balls
* Green boxes, each containing G green balls
* Blue boxes, each containing B blue balls
Snuke wants to get a total of exactly N balls by buying r red boxes, g green boxes and b blue boxes. How many triples of non-negative integers (r,g,b) achieve this?
Constraints
* All values in input are integers.
* 1 \leq R,G,B,N \leq 3000
Input
Input is given from Standard Input in the following format:
R G B N
Output
Print the answer.
Examples
Input
1 2 3 4
Output
4
Input
13 1 4 3000
Output
87058
|
R,G,B,N=map(int,input().split())
ans=0
for i in range(1+N//R):
r=R*i
for j in range(1+(N-r)//G):
g=G*j
if (N-r-g)%B==0:
ans+=1
print(ans)
|
You are given an integer sequence of length N: A_1,A_2,...,A_N. Let us perform Q operations in order. The i-th operation is described by two integers X_i and Y_i. In this operation, we will choose one of the following two actions and perform it:
* Swap the values of A_{X_i} and A_{Y_i}
* Do nothing
There are 2^Q ways to perform these operations. Find the sum of the inversion numbers of the final sequences for all of these ways to perform operations, modulo 10^9+7.
Here, the inversion number of a sequence P_1,P_2,...,P_M is the number of pairs of integers (i,j) such that 1\leq i < j\leq M and P_i > P_j.
Constraints
* 1 \leq N \leq 3000
* 0 \leq Q \leq 3000
* 0 \leq A_i \leq 10^9(1\leq i\leq N)
* 1 \leq X_i,Y_i \leq N(1\leq i\leq Q)
* X_i\neq Y_i(1\leq i\leq Q)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N Q
A_1
:
A_N
X_1 Y_1
:
X_Q Y_Q
Output
Print the sum of the inversion numbers of the final sequences, modulo 10^9+7.
Examples
Input
3 2
1
2
3
1 2
1 3
Output
6
Input
5 3
3
2
3
1
4
1 5
2 3
4 2
Output
36
Input
9 5
3
1
4
1
5
9
2
6
5
3 5
8 9
7 9
3 2
3 8
Output
425
|
#include<cstdio>
const int mod=1000000007;
const int inv2=(mod+1)/2;
int n,m,a[5010],x,y,i,j;
long long p[5010][5010],t;
int main()
{
scanf("%d%d",&n,&m);
for(i=1;i<=n;++i)scanf("%d",a+i);
for(i=1;i<=n;++i)for(j=1;j<=n;++j)p[i][j]=a[i]>a[j];
for (int k=0;k<m;k++) {
scanf("%d%d",&x,&y);
p[x][y]=p[y][x]=(p[x][y]+p[y][x])*inv2%mod;
for(i=1;i<=n;++i)if(i!=x&&i!=y) p[i][x]=p[i][y]=(p[i][x]+p[i][y])*inv2%mod,
p[x][i]=p[y][i]=(p[x][i]+p[y][i])*inv2%mod;
}
for(i=1;i<=n;++i)for(j=n;j>i;--j)t=(t+p[i][j])%mod;
for (i=0;i<m;++i) t=t*2%mod;
printf("%lld\n",t);
}
|
Takahashi and Aoki love calculating things, so they will play with numbers now.
First, they came up with one positive integer each. Takahashi came up with X, and Aoki came up with Y. Then, they will enjoy themselves by repeating the following operation K times:
* Compute the bitwise AND of the number currently kept by Takahashi and the number currently kept by Aoki. Let Z be the result.
* Then, add Z to both of the numbers kept by Takahashi and Aoki.
However, it turns out that even for the two math maniacs this is just too much work. Could you find the number that would be kept by Takahashi and the one that would be kept by Aoki eventually?
Note that input and output are done in binary. Especially, X and Y are given as strings S and T of length N and M consisting of `0` and `1`, respectively, whose initial characters are guaranteed to be `1`.
Constraints
* 1 ≤ K ≤ 10^6
* 1 ≤ N,M ≤ 10^6
* The initial characters of S and T are `1`.
Input
Input is given from Standard Input in the following format:
N M K
S
T
Output
In the first line, print the number that would be kept by Takahashi eventually; in the second line, print the number that would be kept by Aoki eventually. Those numbers should be represented in binary and printed as strings consisting of `0` and `1` that begin with `1`.
Examples
Input
2 3 3
11
101
Output
10000
10010
Input
5 8 3
10101
10101001
Output
100000
10110100
Input
10 10 10
1100110011
1011001101
Output
10000100000010001000
10000100000000100010
|
using namespace std;
#include <cstdio>
#include <cstring>
#include <algorithm>
#define N 1000010
int n,m,k;
char str[N];
int s[N],t[N];
struct Node{
Node *pre,*suc;
int s,n;
} *fir,*lst;
Node *ins(Node *p,int s,int n=1){
Node *nw=new Node;
*nw={p,p->suc,s,n};
if (p->suc)
p->suc->pre=nw;
else
lst=nw;
p->suc=nw;
return nw;
}
Node *check(Node *p){
if (p->n==0){
p->pre->suc=p->suc;
if (p->suc)
p->suc->pre=p->pre;
else
lst=p->pre;
return p->pre;
}
if (p->pre && p->s==p->pre->s){
p->pre->n+=p->n;
p->pre->suc=p->suc;
if (p->suc)
p->suc->pre=p->pre;
else
lst=p->pre;
return p->pre;
}
return p;
}
int ans[N*2],cnt;
int main(){
scanf("%d%d%d",&n,&m,&k);
scanf("%s",str);
for (int i=0;i<n;++i)
s[i]=str[n-1-i]-'0';
scanf("%s",str);
for (int i=0;i<m;++i)
t[i]=str[m-1-i]-'0';
n=max(n,m);
fir=lst=new Node;
*lst=(Node){NULL,NULL,0,1000000000};
for (int i=n-1;i>=0;--i)
if (s[i]==1 && t[i]==1){
int z=k;
Node *p=lst;
while (z){
while (1){
Node *q=check(p);
if (q==p) break;
p=q;
}
if (p->n==0){
p->pre->suc=p->suc;
if (p->suc)
p->suc->pre=p->pre;
else
lst=p->pre;
p=p->pre;
continue;
}
if (p->s==0){
if (p->n<=z){
z-=p->n;
p=p->pre;
if (z==0)
ins(p,3,1);
}
else{
p->n-=z;
Node *q=ins(p,0,z);
ins(p,3,1);
break;
}
}
else{
while (1){
Node *q=check(p->pre);
if (q==p->pre) break;
p->pre=q;
}
if (p->s==1){
if (p->pre->s==0){
p->s=0,p->n--;
Node *q=ins(p,2,1),*r=ins(q,0,1);
p->pre->n--;
check(p->pre);
ins(p->pre,1,1);
check(p);
break;
}
else{
p->s=0,p->n--;
Node *q=ins(p,2,1),*r=ins(q,0,1);
p->pre->n--;
p=p->pre;
z--;
check(p->suc);
if (z==0)
ins(p,3,1);
p=check(p);
}
}
else if (p->s==2){
if (p->pre->s==0){
p->s=0,p->n--;
Node *q=ins(p,1,1),*r=ins(q,0,1);
p->pre->n--;
check(p->pre);
ins(p->pre,2,1);
check(p);
break;
}
else{
p->s=0,p->n--;
Node *q=ins(p,1,1),*r=ins(q,0,1);
p->pre->n--;
p=p->pre;
z--;
check(p->suc);
if (z==0)
ins(p,3,1);
p=check(p);
}
}
// else
// printf("fuck\n");
}
}
}
else{
int f=s[i]|t[i]<<1;
if (f==lst->s)
lst->n++;
else
lst=ins(lst,f,1);
}
for (Node *p=lst;p!=fir;p=p->pre)
for (int i=0;i<p->n;++i)
ans[cnt++]=p->s;
bool bz=0;
for (int i=cnt-1;i>=0;--i){
bz|=ans[i]&1;
if (bz)
putchar('0'+(ans[i]&1));
}
// if (bz==0)
// putchar('0');
putchar('\n');
bz=0;
for (int i=cnt-1;i>=0;--i){
bz|=ans[i]>>1;
if (bz)
putchar('0'+(ans[i]>>1));
}
// if (bz==0)
// putchar('0');
return 0;
}
|
Takahashi has N balls. Initially, an integer A_i is written on the i-th ball.
He would like to rewrite the integer on some balls so that there are at most K different integers written on the N balls.
Find the minimum number of balls that Takahashi needs to rewrite the integers on them.
Constraints
* 1 \leq K \leq N \leq 200000
* 1 \leq A_i \leq N
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1 A_2 ... A_N
Output
Print the minimum number of balls that Takahashi needs to rewrite the integers on them.
Examples
Input
5 2
1 1 2 2 5
Output
1
Input
4 4
1 1 2 2
Output
0
Input
10 3
5 1 3 2 4 1 1 2 3 4
Output
3
|
from collections import Counter
n, k = map(int, input().split())
xs = map(int, input().split())
ctr = Counter(xs)
cnts = sorted(ctr.values())
ans = n - sum(cnts[-k:])
print(ans)
|
Snuke is giving cookies to his three goats.
He has two cookie tins. One contains A cookies, and the other contains B cookies. He can thus give A cookies, B cookies or A+B cookies to his goats (he cannot open the tins).
Your task is to determine whether Snuke can give cookies to his three goats so that each of them can have the same number of cookies.
Constraints
* 1 \leq A,B \leq 100
* Both A and B are integers.
Input
Input is given from Standard Input in the following format:
A B
Output
If it is possible to give cookies so that each of the three goats can have the same number of cookies, print `Possible`; otherwise, print `Impossible`.
Examples
Input
4 5
Output
Possible
Input
1 1
Output
Impossible
|
from sys import stdin
a,b = map(int,stdin.readline().split())
ans = 'Impossible'
c = a+b
x = [a,b,c]
def ch(n):
if n==0:
return 0
if n%3:
return 0
return 1
for i in x:
if ch(i):
ans = 'Possible'
print ans
|
Smeke has decided to participate in AtCoder Beginner Contest (ABC) if his current rating is less than 1200, and participate in AtCoder Regular Contest (ARC) otherwise.
You are given Smeke's current rating, x. Print `ABC` if Smeke will participate in ABC, and print `ARC` otherwise.
Constraints
* 1 ≦ x ≦ 3{,}000
* x is an integer.
Input
The input is given from Standard Input in the following format:
x
Output
Print the answer.
Examples
Input
1000
Output
ABC
Input
2000
Output
ARC
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
String message = "";
if (a < 1200) {
message = "ABC";
} else {
message = "ARC";
}
System.out.println(message);
}
}
|
Kyoto University decided to build a straight wall on the west side of the university to protect against gorillas that attack the university from the west every night. Since it is difficult to protect the university at some points along the wall where gorillas attack violently, reinforcement materials are also built at those points. Although the number of the materials is limited, the state-of-the-art technology can make a prediction about the points where gorillas will attack next and the number of gorillas that will attack at each point. The materials are moved along the wall everyday according to the prediction. You, a smart student majoring in computer science, are called to find the way to move the materials more efficiently.
Theare are N points where reinforcement materials can be build along the straight wall. They are numbered 1 through N. Because of the protection against the last attack of gorillas, A_i materials are build at point i (1 \leq i \leq N). For the next attack, the materials need to be rearranged such that at least B_i materials are built at point i (1 \leq i \leq N). It costs |i - j| to move 1 material from point i to point j. Find the minimum total cost required to satisfy the condition by moving materials. You do not need to consider the attack after the next.
Constraints
* 1 \leq N \leq 10^5
* A_i \geq 1
* B_i \geq 1
* A_1 + A_2 + ... + A_N \leq 10^{12}
* B_1 + B_2 + ... + B_N \leq A_1 + A_2 + ... + A_N
* There is at least one way to satisfy the condition.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
B_1 B_2 ... B_N
Output
Print the minimum total cost required to satisfy the condition.
Partial Scores
30 points will be awarded for passing the test set satisfying the following:
* N \leq 100
* A_1 + A_2 + ... + A_N \leq 400
Another 30 points will be awarded for passing the test set satisfying the following:
* N \leq 10^3
Another 140 points will be awarded for passing the test set without addtional constraints and you can get 200 points in total.
Examples
Input
2
1 5
3 1
Output
2
Input
5
1 2 3 4 5
3 3 1 1 1
Output
6
Input
27
46 3 4 2 10 2 5 2 6 7 20 13 9 49 3 8 4 3 19 9 3 5 4 13 9 5 7
10 2 5 6 2 6 3 2 2 5 3 11 13 2 2 7 7 3 9 5 13 4 17 2 2 2 4
Output
48
Input
18
3878348 423911 8031742 1035156 24256 10344593 19379 3867285 4481365 1475384 1959412 1383457 164869 4633165 6674637 9732852 10459147 2810788
1236501 770807 4003004 131688 1965412 266841 3980782 565060 816313 192940 541896 250801 217586 3806049 1220252 1161079 31168 2008961
Output
6302172
Input
2
1 99999999999
1234567891 1
Output
1234567890
|
#include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x,to) for(x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
//-------------------------------------------------------
template<class V,int NV> class SegTree_3 {
public:
vector<pair<V,int> > val;
vector<pair<V,int> > ma;
static V const def=1LL<<50;
SegTree_3(){
int i;
val.resize(NV*2); ma.resize(NV*2);
FOR(i,NV) val[i+NV]=ma[i+NV]=make_pair(0,i);
FOR(i,NV) val[i]=make_pair(0,0);
for(i=NV-1;i>=1;i--) ma[i]=min(ma[2*i],ma[2*i+1]);
};
pair<V,int> getval(int x,int y,int l=0,int r=NV,int k=1) {
if(r<=x || y<=l) return make_pair(def,0);
if(x<=l && r<=y) return ma[k];
auto a=min(getval(x,y,l,(l+r)/2,k*2),getval(x,y,(l+r)/2,r,k*2+1));
a.first += val[k].first;
return a;
}
void update(int x,int y, V v,int l=0,int r=NV,int k=1) {
if(l>=r) return;
if(x<=l && r<=y) {
val[k].first+=v;
ma[k].first+=v;
}
else if(l < y && x < r) {
update(x,y,v,l,(l+r)/2,k*2);
update(x,y,v,(l+r)/2,r,k*2+1);
ma[k]=min(ma[k*2],ma[k*2+1]);
ma[k].first += val[k].first;
}
}
};
int N;
ll A[101010];
ll B[101010];
ll SA[101010];
ll SB[101010];
SegTree_3<ll,1<<19> D,F;
void solve() {
int i,j,k,l,r,x,y; string s;
cin>>N;
FOR(i,N) {
cin>>A[i];
SA[i+1]=SA[i]+A[i];
}
ll ret=0;
FOR(i,N) {
cin>>B[i];
SB[i+1]=SB[i]+B[i];
if(SA[i+1]>SB[i+1]) {
F.update(i,i+1,SA[i+1]-SB[i+1]);
D.update(0,i+1,-1);
}
else {
F.update(i,i+1,1LL<<50);
D.update(0,i+1,1);
}
ret += abs(SB[i+1]-SA[i+1]);
}
ll flow=SA[N]-SB[N];
while(flow) {
while(1) {
auto f=F.getval(0,N);
if(f.first>0) break;
D.update(0,f.second+1,2);
F.update(f.second,f.second+1,1LL<<50);
}
//FOR(i,N) _P("%lld/%lld ",D.getval(i,i+1).first,F.getval(i,i+1).first);
auto p = D.getval(0,N);
if(p.first>=1LL<<40 || p.first==0) break;
ll d = min(flow,F.getval(p.second,N).first);
//_P(" : %lld:%d %lld\n",p.first,p.second,d);
ret += p.first*d;
flow-=d;
F.update(p.second,N,-d);
}
cout<<ret<<endl;
}
int main(int argc,char** argv){
string s;int i;
if(argc==1) ios::sync_with_stdio(false), cin.tie(0);
FOR(i,argc-1) s+=argv[i+1],s+='\n';
FOR(i,s.size()) ungetc(s[s.size()-1-i],stdin);
solve(); return 0;
}
|
Consider a sequence of n numbers using integers from 0 to 9 k1, k2, ..., kn. Read the positive integers n and s,
k1 + 2 x k2 + 3 x k3 + ... + n x kn = s
Create a program that outputs how many rows of n numbers such as. However, the same number does not appear more than once in one "n sequence of numbers".
Input
The input consists of multiple datasets. For each dataset, n (1 ≤ n ≤ 10) and s (0 ≤ s ≤ 10,000) are given on one line, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, print the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 10
3 1
Output
8
0
|
#include <iostream>
#include <cstring>
using namespace std;
#define LIMIT 330
int cnt[11][LIMIT+1];
bool used[11];
void make(int k,int N,int sum){
if(sum > LIMIT) return;
if(N == 0){
cnt[k][sum]++;
return;
}
for(int i = 0 ; i <= 9 ; i++){
if(!used[i]){
used[i] = true;
make(k + 1 , N - 1 ,sum + (k+1)*i);
used[i] = false;
}
}
}
void init(){
for(int i = 0 ; i <= 10 ; i++){
memset(used,false,sizeof(used));
make(0,i,0);
}
}
int main(){
int n,s;
init();
while(cin >> n >> s){
if(s <= LIMIT){
cout << cnt[n][s] << endl;
}else{
cout << 0 << endl;
}
}
return 0;
}
|
Taro Aizu's company has a boss who hates being indivisible. When Taro goes out to eat with his boss, he pays by splitting the bill, but when the payment amount is not divisible by the number of participants, his boss always pays for it.
One day, Taro became the secretary of the dinner party. Mr. Taro, who has little money, wondered if he could invite his boss to get a treat. I have to place an order with a restaurant, but I don't know how many people will participate yet, so it seems that I want to place an order so that any number of people can participate. At the same time as Mr. Taro, you who are also planning to attend the dinner party decided to cooperate with Mr. Taro to calculate the amount that is less than the budget amount and is not divisible by any number of people.
Create a program that inputs the type of dish, the price of each dish, and the budget amount, and outputs the total amount (excluding 1 and the total amount) that is not divisible by any number that is less than or equal to the budget amount. You can order multiple dishes of each type, but you do not have to order all types of dishes. However, if there is no such total amount, output NA.
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:
n x
v1
v2
::
vn
On the first line, the type of dish n (1 ≤ n ≤ 30) and the budget amount x (1 ≤ x ≤ 1000000) are given, separated by blanks. The next n lines are given the integer vi (1 ≤ vi ≤ 1000000), which represents the amount of the i-type dish.
The number of datasets does not exceed 100.
Output
For each input dataset, print the total amount or NA closest to the budget amount on one line.
Example
Input
4 15000
305
260
129
500
3 400
10
20
30
3 200909
5
9
12
0 0
Output
14983
NA
200909
|
#include <iostream>
#include <vector>
#include <string>
#include <cstring>
#include <algorithm>
#include <set>
using namespace std;
#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define rep(i, n) FOR(i, 0, n)
const int N = 1000001;
bool isP[N], dp[N];
int main(){
FOR(i, 2, N) isP[i] = 1;
FOR(i, 2, N){
if(isP[i]) for(int j = i*2; j < N; j += i) isP[j] = false;
}
int n, x;
while(cin >> n >> x, n|x){
memset(dp, 0, sizeof(dp));
int ans = 0;
dp[0] = 1;
rep(i, n){
int val;
cin >> val;
rep(j, x+1-val){
if(dp[j]){
dp[j+val] = 1;
if(isP[j+val]) ans = max(ans, j+val);
}
}
}
if(ans) cout << ans << endl;
else cout << "NA" << endl;
}
return 0;
}
|
A plurality of trampolines are arranged in a line at 10 m intervals. Each trampoline has its own maximum horizontal distance within which the jumper can jump safely. Starting from the left-most trampoline, the jumper jumps to another trampoline within the allowed jumping range. The jumper wants to repeat jumping until he/she reaches the right-most trampoline, and then tries to return to the left-most trampoline only through jumping. Can the jumper complete the roundtrip without a single stepping-down from a trampoline?
Write a program to report if the jumper can complete the journey using the list of maximum horizontal reaches of these trampolines. Assume that the trampolines are points without spatial extent.
Input
The input is given in the following format.
N
d_1
d_2
:
d_N
The first line provides the number of trampolines N (2 ≤ N ≤ 3 × 105). Each of the subsequent N lines gives the maximum allowable jumping distance in integer meters for the i-th trampoline d_i (1 ≤ d_i ≤ 106).
Output
Output "yes" if the jumper can complete the roundtrip, or "no" if he/she cannot.
Examples
Input
4
20
5
10
1
Output
no
Input
3
10
5
10
Output
no
Input
4
20
30
1
20
Output
yes
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
#define pb push_back
#define rep(i, a, n) for(int i = (a); i < (n); i++)
#define dep(i, a, n) for(int i = (a); i >= (n); i--)
#define mod (ll)(1e9+7)
#define int ll
__attribute__((constructor))
void initial() {
cin.tie(0);
ios::sync_with_stdio(false);
}
int n;
int t[300001];
signed main() {
cin >> n;
rep(i, 0, n) cin >> t[i];
int mx = 0;
rep(i, 0, n) {
if(i * 10 > mx) {
cout << "no" << endl;
return 0;
}
mx = max(mx, i * 10 + t[i]);
}
mx = 0;
int cu = 0;
dep(i, n - 1, 0) {
if(cu * 10 > mx) {
cout << "no" << endl;
return 0;
}
mx = max(mx, cu * 10 + t[i]);
cu++;
}
cout << "yes" << endl;
}
|
JOI is a baby playing with a rope. The rope has length $N$, and it is placed as a straight line from left to right. The rope consists of $N$ cords. The cords are connected as a straight line. Each cord has length 1 and thickness 1. In total, $M$ colors are used for the rope. The color of the $i$-th cord from left is $C_i$ ($1 \leq C_i \leq M$).
JOI is making the rope shorter. JOI repeats the following procedure until the length of the rope becomes 2.
* Let $L$ be the length of the rope. Choose an integer $j$ ($1 \leq j < L$). Shorten the rope by combining cords so that the point of length $j$ from left on the rope becomes the leftmost point. More precisely, do the following:
* If $j \leq L/2$, for each $i$ ($1 \leq i \leq j$), combine the $i$-th cord from left with the ($2j - i + 1$)-th cord from left. By this procedure, the rightmost point of the rope becomes the rightmost point. The length of the rope becomes $L - j$.
* If $j > L/2$, for each $i$ ($2j - L + 1 \leq i \leq j$), combine the $i$-th cord from left with the ($2j - i + 1$)-th cord from left. By this procedure, the leftmost point of the rope becomes the rightmost point. The length of the rope becomes $j$.
* If a cord is combined with another cord, the colors of the two cords must be the same. We can change the color of a cord before it is combined with another cord. The cost to change the color of a cord is equal to the thickness of it. After adjusting the colors of two cords, they are combined into a single cord; its thickness is equal to the sum of thicknesses of the two cords.
JOI wants to minimize the total cost of procedures to shorten the rope until it becomes length 2. For each color, JOI wants to calculate the minimum total cost of procedures to shorten the rope so that the final rope of length 2 contains a cord with that color.
Your task is to solve this problem instead of JOI.
Task
Given the colors of the cords in the initial rope, write a program which calculates, for each color, the minimum total cost of procedures to shorten the rope so that the final rope of length 2 contains a cord with that color.
Input
Read the following data from the standard input.
* The first line of input contains two space separated integers $N$, $M$. This means the rope consists of $N$ cords, and $M$ colors are used for the cords.
* The second line contains $N$ space separated integers $C_1, C_2, ... ,C_N$. This means the color of the $i$-th cord from left is $C_i$ ($1 \leq C_i \leq M$).
Output
Write $M$ lines to the standard output. The $c$-th line ($1 \leq c \leq M$) contains the minimum total cost of procedures to shorten the rope so that the final rope of length 2 contains a cord with color $c$.
Constraints
All input data satisfy the following conditions.
* $ 2 \leq N \leq 1 000 000． $
* $ 1 \leq M \leq N．$
* $ 1 \leq C_i \leq M (1 \leq i \leq N)．$
* For each $c$ with $1 \leq c \leq M$, there exists an integer $i$ with $C_i = c$.
Sample Input and Output
Sample Input 1
5 3
1 2 3 3 2
Sample Output 1
2
1
1
By the following procedures, we can shorten the rope so that the final rope of length 2 contains a cord with color 1. The total cost is 2.
* Change the color of the second cord from left to 1. Shorten the rope so that the point of length 1 from left on the rope becomes the leftmost point. The colors of cords become 1, 3, 3, 2. The thicknesses of cords become 2, 1, 1, 1.
* Change the color of the 4-th cord from left to 1. Shorten the rope so that the point of length 2 from left on the rope becomes the leftmost point. The colors of cords become 3, 1. The thicknesses of cords become 2, 3.
By the following procedures, we can shorten the rope so that the final rope of length 2 contains a cord with color 2, 3. The total cost is 1.
* Shorten the rope so that the point of length 3 from left on the rope becomes the leftmost point. The colors of cords become 3, 2, 1. The thicknesses of cords become 2, 2, 1.
* Change the color of the third cord from left to 2. Shorten the rope so that the point of length 2 from left on the rope becomes the leftmost point. The colors of cords become 2, 3. The thicknesses of cords become 3, 2.
Sample Input 2
7 3
1 2 2 1 3 3 3
Sample Output 2
2
2
2
By the following procedures, we can shorten the rope so that the final rope of length 2 contains a cord with color 1. The total cost is 2.
* Shorten the rope so that the point of length 2 from left on the rope becomes the leftmost point.
* Change the color of the leftmost cord to 1. Shorten the rope so that the point of length 1 from left on the rope becomes the leftmost point. Note that the cost to change the color is 2 because the thickness of the cord is 2.
* Shorten the rope so that the point of length 3 from left on the rope becomes the leftmost point.
* Shorten the rope so that the point of length 1 from left on the rope becomes the leftmost point.
Sample Input 3
10 3
2 2 1 1 3 3 2 1 1 2
Sample Output 3
3
3
4
Before shortening the rope, we may change the colors of several cords.
Creatie Commonse License
The 16th Japanese Olympiad in Informatics (JOI 2016/2017) Final Round
Example
Input
5 3
1 2 3 3 2
Output
2
1
1
|
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <functional>
#include <cassert>
typedef long long ll;
using namespace std;
#define debug(x) cerr << #x << " = " << x << endl;
#define mod 1000000007 //1e9+7(prime number)
#define INF 1000000000 //1e9
#define LLINF 2000000000000000000LL //2e18
#define SIZE 1000100
/* RangeMinimumQuery(0-index) */
struct RMQ{
typedef int Type;
int segn2;
Type inf;
vector<Type> data;
RMQ(int n){
inf = INF; //init value
for(segn2=1;segn2<n;segn2*=2);
data.assign(segn2*2,inf);
}
//get minimum value [a,b]
Type query(int a,int b,int l=0,int r=-1,int k=0){
if(r==-1) r+=segn2;
if(a<=l && r<=b) return data[k];
if(r<a || b<l) return inf;
return min(query(a,b,l,(l+r)/2,k*2+1),query(a,b,(l+r)/2+1,r,k*2+2));
}
//set kth number x
void set(int k,Type x){
k+=segn2-1;
data[k]=x;
while(k>0){
k=(k-1)/2;
data[k]=min(data[k*2+1],data[k*2+2]);
}
return;
}
};
int n,m;
int c[SIZE];
int ans[SIZE];
vector<int> vec[SIZE];
int rest[SIZE];
RMQ rmq(SIZE);
void calc(int mode){
c[n] = -1;
for(int i=0;i<m;i++){
rest[i] = n - vec[i].size();
rmq.set(i, rest[i]);
}
for(int i=0;i<m;i++){
int minus_sum = 0;
for(int j=0;j<(int)vec[i].size();j++){
int a = (vec[i][j]-mode)/2*2+mode; //c[a] == i
int b = a; //c[b] != i
if((mode == 0 && n%2 == 1 && vec[i][j]==n-1) ||
(mode == 1 && (vec[i][j]==0 || (n%2==0 && vec[i][j]==n-1)))){
minus_sum++;
continue;
}
if(c[a] == i) b++;
else a++;
if(c[a] == c[b]){
if(a == vec[i][j]) minus_sum+=2;
continue;
}
minus_sum++;
rest[c[b]]++;
rmq.set(c[b], rest[c[b]]);
/*
debug(b);
debug(c[b]);
debug(mode);
debug(vec[i][j]);
*/
}
int this_ans = min(rmq.query(-INF,i-1),rmq.query(i+1,m)) - minus_sum;
ans[i] = min(ans[i], this_ans);
//cerr << mode << " " << i << " : " << this_ans << " (" << minus_sum << ")" << endl;
for(int j=0;j<(int)vec[i].size();j++){
int a = (vec[i][j]-mode)/2*2+mode; //c[a] == i
int b = a; //c[b] != i
if((mode == 0 && n%2 == 1 && vec[i][j]==n-1) ||
(mode == 1 && (vec[i][j]==0 || (n%2==0 && vec[i][j]==n-1)))){
continue;
}
if(c[a] == i) b++;
else a++;
if(c[a] == c[b]){
continue;
}
rest[c[b]]--;
rmq.set(c[b], rest[c[b]]);
}
}
}
int main(){
scanf("%d%d",&n,&m);
if(m == 1){
puts("0");
return 0;
}
for(int i=0;i<m;i++){
ans[i] = INF;
}
for(int i=0;i<n;i++){
scanf("%d",c+i);
c[i]--;
}
for(int i=0;i<n;i++){
vec[c[i]].push_back(i);
}
// |1 2|3 4|5 6|7 ...
calc(0);
calc(1);
for(int i=0;i<m;i++){
printf("%d\n",ans[i]);
}
return 0;
}
|
The Ohgas are a prestigious family based on Hachioji. The head of the family, Mr. Nemochi Ohga, a famous wealthy man, wishes to increase his fortune by depositing his money to an operation company. You are asked to help Mr. Ohga maximize his profit by operating the given money during a specified period.
From a given list of possible operations, you choose an operation to deposit the given fund to. You commit on the single operation throughout the period and deposit all the fund to it. Each operation specifies an annual interest rate, whether the interest is simple or compound, and an annual operation charge. An annual operation charge is a constant not depending on the balance of the fund. The amount of interest is calculated at the end of every year, by multiplying the balance of the fund under operation by the annual interest rate, and then rounding off its fractional part. For compound interest, it is added to the balance of the fund under operation, and thus becomes a subject of interest for the following years. For simple interest, on the other hand, it is saved somewhere else and does not enter the balance of the fund under operation (i.e. it is not a subject of interest in the following years). An operation charge is then subtracted from the balance of the fund under operation. You may assume here that you can always pay the operation charge (i.e. the balance of the fund under operation is never less than the operation charge). The amount of money you obtain after the specified years of operation is called ``the final amount of fund.'' For simple interest, it is the sum of the balance of the fund under operation at the end of the final year, plus the amount of interest accumulated throughout the period. For compound interest, it is simply the balance of the fund under operation at the end of the final year.
Operation companies use C, C++, Java, etc., to perform their calculations, so they pay a special attention to their interest rates. That is, in these companies, an interest rate is always an integral multiple of 0.0001220703125 and between 0.0001220703125 and 0.125 (inclusive). 0.0001220703125 is a decimal representation of 1/8192. Thus, interest rates' being its multiples means that they can be represented with no errors under the double-precision binary representation of floating-point numbers.
For example, if you operate 1000000 JPY for five years with an annual, compound interest rate of 0.03125 (3.125 %) and an annual operation charge of 3000 JPY, the balance changes as follows.
The balance of the fund under operation (at the beginning of year) | Interest| The balance of the fund under operation (at the end of year)
---|---|---
A| B = A × 0.03125 (and rounding off fractions) | A + B - 3000
1000000| 31250| 1028250
1028250| 32132| 1057382
1057382| 33043| 1087425
1087425| 33982| 1118407
1118407| 34950| 1150357
After the five years of operation, the final amount of fund is 1150357 JPY.
If the interest is simple with all other parameters being equal, it looks like:
The balance of the fund under operation (at the beginning of year) | Interest | The balance of the fund under operation (at the end of year) | Cumulative interest
---|---|---|---
A| B = A × 0.03125 (and rounding off fractions)| A - 3000|
1000000| 31250| 997000| 31250
997000| 31156| 994000| 62406
994000| 31062| 991000| 93468
991000| 30968| 988000| 124436
988000| 30875| 985000| 155311
In this case the final amount of fund is the total of the fund under operation, 985000 JPY, and the cumulative interests, 155311 JPY, which is 1140311 JPY.
Input
The input consists of datasets. The entire input looks like:
> the number of datasets (=m)
> 1st dataset
> 2nd dataset
> ...
> m-th dataset
>
The number of datasets, m, is no more than 100. Each dataset is formatted as follows.
> the initial amount of the fund for operation
> the number of years of operation
> the number of available operations (=n)
> operation 1
> operation 2
> ...
> operation n
>
The initial amount of the fund for operation, the number of years of operation, and the number of available operations are all positive integers. The first is no more than 100000000, the second no more than 10, and the third no more than 100.
Each ``operation'' is formatted as follows.
> simple-or-compound annual-interest-rate annual-operation-charge
where simple-or-compound is a single character of either '0' or '1', with '0' indicating simple interest and '1' compound. annual-interest-rate is represented by a decimal fraction and is an integral multiple of 1/8192. annual-operation-charge is an integer not exceeding 100000.
Output
For each dataset, print a line having a decimal integer indicating the final amount of fund for the best operation. The best operation is the one that yields the maximum final amount among the available operations. Each line should not have any character other than this number.
You may assume the final balance never exceeds 1000000000. You may also assume that at least one operation has the final amount of the fund no less than the initial amount of the fund.
Example
Input
4
1000000
5
2
0 0.03125 3000
1 0.03125 3000
6620000
7
2
0 0.0732421875 42307
1 0.0740966796875 40942
39677000
4
4
0 0.0709228515625 30754
1 0.00634765625 26165
0 0.03662109375 79468
0 0.0679931640625 10932
10585000
6
4
1 0.0054931640625 59759
1 0.12353515625 56464
0 0.0496826171875 98193
0 0.0887451171875 78966
Output
1150357
10559683
50796918
20829397
|
#include <cstdio>
#include <cstdlib>
int main(){
int m;
scanf( "%d", &m );
for( int i = 0; i < m; i++ ) {
int ini_fund;
int y, n;
int max_fund = 0;
scanf( "%d%d%d", &ini_fund, &y, &n );
for( int j = 0; j < n; j++ ) {
int type;
int a, b, cost;
int sum = 0;
double alpha;
scanf( "%d%lf%d", &type, &alpha, &cost );
a = ini_fund;
for( int k = 0; k < y; k++ ){
b = ( int )( a * alpha );
if( type ) {
a = a + b - cost;
}else{
sum += b;
a -= cost;
}
}
if( !type ){ a += sum; }
max_fund = a > max_fund ? a : max_fund;
}
printf( "%d\n", max_fund );
}
return EXIT_SUCCESS;
}
|
Here is a very simple variation of the game backgammon, named “Minimal Backgammon”. The game is played by only one player, using only one of the dice and only one checker (the token used by the player).
The game board is a line of (N + 1) squares labeled as 0 (the start) to N (the goal). At the beginning, the checker is placed on the start (square 0). The aim of the game is to bring the checker to the goal (square N). The checker proceeds as many squares as the roll of the dice. The dice generates six integers from 1 to 6 with equal probability.
The checker should not go beyond the goal. If the roll of the dice would bring the checker beyond the goal, the checker retreats from the goal as many squares as the excess. For example, if the checker is placed at the square (N - 3), the roll "5" brings the checker to the square (N - 2), because the excess beyond the goal is 2. At the next turn, the checker proceeds toward the goal as usual.
Each square, except the start and the goal, may be given one of the following two special instructions.
* Lose one turn (labeled "L" in Figure 2) If the checker stops here, you cannot move the checker in the next turn.
* Go back to the start (labeled "B" in Figure 2)
If the checker stops here, the checker is brought back to the start.
<image>
Figure 2: An example game
Given a game board configuration (the size N, and the placement of the special instructions), you are requested to compute the probability with which the game succeeds within a given number of turns.
Input
The input consists of multiple datasets, each containing integers in the following format.
N T L B
Lose1
...
LoseL
Back1
...
BackB
N is the index of the goal, which satisfies 5 ≤ N ≤ 100. T is the number of turns. You are requested to compute the probability of success within T turns. T satisfies 1 ≤ T ≤ 100. L is the number of squares marked “Lose one turn”, which satisfies 0 ≤ L ≤ N - 1. B is the number of squares marked “Go back to the start”, which satisfies 0 ≤ B ≤ N - 1. They are separated by a space.
Losei's are the indexes of the squares marked “Lose one turn”, which satisfy 1 ≤ Losei ≤ N - 1. All Losei's are distinct, and sorted in ascending order. Backi's are the indexes of the squares marked “Go back to the start”, which satisfy 1 ≤ Backi ≤ N - 1. All Backi's are distinct, and sorted in ascending order. No numbers occur both in Losei's and Backi's.
The end of the input is indicated by a line containing four zeros separated by a space.
Output
For each dataset, you should answer the probability with which the game succeeds within the given number of turns. The output should not contain an error greater than 0.00001.
Example
Input
6 1 0 0
7 1 0 0
7 2 0 0
6 6 1 1
2
5
7 10 0 6
1
2
3
4
5
6
0 0 0 0
Output
0.166667
0.000000
0.166667
0.619642
0.000000
|
#define _CRT_SECURE_NO_WARNINGS
#pragma comment (linker, "/STACK:526000000")
#include "bits/stdc++.h"
using namespace std;
typedef string::const_iterator State;
#define eps 1e-11L
#define MAX_MOD 1000000007LL
#define GYAKU 500000004LL
#define MOD 998244353LL
#define seg_size 262144*2LL
#define pb push_back
#define mp make_pair
typedef long long ll;
#define REP(a,b) for(long long (a) = 0;(a) < (b);++(a))
#define ALL(x) (x).begin(),(x).end()
unsigned long xor128() {
static unsigned long x = 123456789, y = 362436069, z = 521288629, w = time(NULL);
unsigned long t = (x ^ (x << 11));
x = y; y = z; z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
void init() {
iostream::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
#define int ll
void solve() {
while (true) {
int n, t, l, b;
cin >> n >> t >> l >> b;
if (n == 0) return;
int inst[200] = {};
REP(i, l) {
int a;
cin >> a;
inst[a] = 1;
}
REP(i, b) {
int a;
cin >> a;
inst[a] = 2;
}
long double ans[200][200] = {};
ans[0][0] = 1.0;
REP(i, t) {
REP(q, n) {
long double prob = ans[i][q] / (long double)6.0000L;
for (int j = 1; j <= 6; ++j) {
int next = q + j;
if (next > n) {
next = n - (next - n);
}
if (inst[next] == 1) {
ans[i + 2][next] += prob;
}
else if (inst[next] == 2) {
ans[i + 1][0] += prob;
}
else {
ans[i + 1][next] += prob;
}
}
}
ans[i + 1][n] += ans[i][n];
}
cout << ans[t][n] << endl;
}
}
#undef int
int main() {
init();
solve();
}
|
One-Way Conveyors
You are working at a factory manufacturing many different products. Products have to be processed on a number of different machine tools. Machine shops with these machines are connected with conveyor lines to exchange unfinished products. Each unfinished product is transferred from a machine shop to another through one or more of these conveyors.
As the orders of the processes required are not the same for different types of products, the conveyor lines are currently operated in two-way. This may induce inefficiency as conveyors have to be completely emptied before switching their directions. Kaizen (efficiency improvements) may be found here!
Adding more conveyors is too costly. If all the required transfers are possible with currently installed conveyors operating in fixed directions, no additional costs are required. All the required transfers, from which machine shop to which, are listed at hand. You want to know whether all the required transfers can be enabled with all the conveyors operated in one-way, and if yes, directions of the conveyor lines enabling it.
Input
The input consists of a single test case of the following format.
$n$ $m$
$x_1$ $y_1$
.
.
.
$x_m$ $y_m$
$k$
$a_1$ $b_1$
.
.
.
$a_k$ $b_k$
The first line contains two integers $n$ ($2 \leq n \leq 10 000$) and $m$ ($1 \leq m \leq 100 000$), the number of machine shops and the number of conveyors, respectively. Machine shops are numbered $1$ through $n$. Each of the following $m$ lines contains two integers $x_i$ and $y_i$ ($1 \leq x_i < y_i \leq n$), meaning that the $i$-th conveyor connects machine shops $x_i$ and $y_i$. At most one conveyor is installed between any two machine shops. It is guaranteed that any two machine shops are connected through one or more conveyors. The next line contains an integer $k$ ($1 \leq k \leq 100 000$), which indicates the number of required transfers from a machine shop to another. Each of the following $k$ lines contains two integers $a_i$ and $b_i$ ($1 \leq a_i \leq n$, $1 \leq b_i \leq n$, $a_i \ne b_i$), meaning that transfer from the machine shop $a_i$ to the machine shop $b_i$ is required. Either $a_i \ne a_j$ or $b_i \ne b_j$ holds for $i \ne j$.
Output
Output “No” if it is impossible to enable all the required transfers when all the conveyors are operated in one-way. Otherwise, output “Yes” in a line first, followed by $m$ lines each of which describes the directions of the conveyors. All the required transfers should be possible with the conveyor lines operated in these directions. Each direction should be described as a pair of the machine shop numbers separated by a space, with the start shop number on the left and the end shop number on the right. The order of these $m$ lines do not matter as far as all the conveyors are specified without duplicates or omissions. If there are multiple feasible direction assignments, whichever is fine.
Sample Input 1
3 2
1 2
2 3
3
1 2
1 3
2 3
Sample Output 1
Yes
1 2
2 3
Sample Input 2
3 2
1 2
2 3
3
1 2
1 3
3 2
Sample Output 2
No
Sample Input 3
4 4
1 2
1 3
1 4
2 3
7
1 2
1 3
1 4
2 1
2 3
3 1
3 2
Sample Output 3
Yes
1 2
2 3
3 1
1 4
Example
Input
3 2
1 2
2 3
3
1 2
1 3
2 3
Output
Yes
1 2
2 3
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using PII = pair<ll, ll>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
template<typename T> void chmin(T &a, const T &b) { a = min(a, b); }
template<typename T> void chmax(T &a, const T &b) { a = max(a, b); }
struct FastIO {FastIO() { cin.tie(0); ios::sync_with_stdio(0); }}fastiofastio;
#ifdef DEBUG_
#include "../program_contest_library/memo/dump.hpp"
#else
#define dump(...)
#endif
const ll INF = 1LL<<60;
struct LCA {
const int n = 0;
const int log2_n = 0;
vector<vector<int>> g;
vector<vector<int>> par; // par[2^i上][頂点v]
vector<int> dep;
void dfs(int v, int p, int d) {
par[0][v] = p;
dep[v] = d;
for(auto to: g[v]) {
if(to == p) continue;
dfs(to, v, d+1);
}
}
LCA() {}
LCA(int n) : n(n), log2_n(log2(n)+1), g(n),
par(log2_n, vector<int>(n)), dep(n) {}
void add_edge(int u, int v) {
g[u].push_back(v);
g[v].push_back(u);
}
void build(ll root=0) {
dfs(root, -1, 0);
for(int i=0; i+1 < log2_n; ++i) {
for(int j = 0; j < n; ++j) {
if(par[i][j] < 0) par[i+1][j] = -1;
else par[i+1][j] = par[i][par[i][j]];
}
}
}
int get(int u, int v) {
if(dep[u] > dep[v]) swap(u, v);
REP(i, log2_n) {
if((dep[v] - dep[u]) >> i & 1) {
v = par[i][v];
}
}
if(u == v) return u;
for(int i=log2_n-1; i>=0; --i) {
if(par[i][u] != par[i][v]) {
u = par[i][u];
v = par[i][v];
}
}
return par[0][u];
}
};
class twoEdgeComponent {
private:
void dfs(ll v, ll p, ll &k) {
used[v] = true;
ord[v] = k++;
low[v] = ord[v];
for(auto to: g[v]) {
if(!used[to]) {
dfs(to, v, k);
chmin(low[v], low[to]);
if(ord[v] < low[to]) bridge.emplace_back(v, to);
} else if(to != p) {
chmin(low[v], ord[to]);
}
}
}
void dfs2(ll v, ll p, ll &k) {
if(~p && ord[p] >= low[v]) cmp[v] = cmp[p];
else cmp[v] = k++;
for(auto to: g[v]) if(cmp[to] == -1) dfs2(to, v, k);
}
public:
vector<bool> used;
vector<vector<ll>> g;
vector<ll> ord, low, cmp;
vector<PII> bridge;
twoEdgeComponent() {}
twoEdgeComponent(ll n) : used(n), g(n), ord(n), low(n), cmp(n, -1) {}
void add_edge(ll u, ll v) {
g[u].push_back(v);
g[v].push_back(u);
}
using P = pair<ll,PII>;
vector<vector<P>> build() {
ll k = 0;
REP(i, g.size()) if(!used[i]) dfs(i, -1, k);
k = 0;
REP(i, g.size()) if(cmp[i]==-1) dfs2(i, -1, k);
// ret[i] = {(iの行き先, (つぶす前のi, つぶす前のiの行き先))}
vector<vector<P>> ret(k);
for(auto e: bridge) {
ll x = cmp[e.first], y = cmp[e.second];
ret[x].push_back({y, {e.first, e.second}});
ret[y].push_back({x, {e.second, e.first}});
}
return ret;
}
};
int main(void) {
ll n, m;
cin >> n >> m;
vector<vector<ll>> g(n);
twoEdgeComponent graph(n);
REP(i, m) {
ll u, v;
cin >> u >> v;
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
graph.add_edge(u, v);
}
auto tree = graph.build();
auto ord = graph.ord;
auto low = graph.low;
auto cmp = graph.cmp;
dump(cmp);
vector<PII> ans;
// 二重辺連結成分の全頂点対を行き来できるように
{
vector<bool> visit(n);
function<void(ll,ll)> dfs = [&](ll v, ll p) {
visit[v] = true;
for(auto to: g[v]) {
if(!visit[to]) {
if(ord[v] >= low[to]) ans.emplace_back(v, to);
dfs(to, v);
} else if(ord[v] > ord[to] && to!=p) {
ans.emplace_back(v, to);
}
}
};
REP(i, n) if(!visit[i]) dfs(i, -1);
}
dump(tree);
LCA lca(tree.size());
REP(i, tree.size()) {
for(auto j: tree[i]) {
if(i < j.first) lca.add_edge(i, j.first);
}
}
lca.build();
vector<ll> up(tree.size()), down(tree.size());
ll q;
cin >> q;
while(q--) {
ll u, v;
cin >> u >> v;
u--, v--;
u = cmp[u], v = cmp[v];
if(u == v) continue;
ll l = lca.get(u, v);
dump(u, v, l);
up[u]++;
up[l]--;
down[v]++;
down[l]--;
}
dump(up);
dump(down);
function<void(ll,ll)> dfs = [&](ll v, ll p) {
for(auto to: tree[v]) {
if(to.first == p) continue;
dfs(to.first, v);
down[v] += down[to.first];
up[v] += up[to.first];
if(down[to.first] > 0 && up[to.first] > 0) {
cout << "No" << endl;
exit(0);
} else if(down[to.first] > 0) {
ans.push_back(to.second);
} else {
ans.push_back({to.second.second, to.second.first});
}
}
};
dfs(0, -1);
cout << "Yes" << endl;
for(auto p: ans) cout << p.first+1 << " " << p.second+1 << endl;
return 0;
}
|
<!--
Problem C
-->
Balance Scale
You, an experimental chemist, have a balance scale and a kit of weights for measuring weights of powder chemicals.
For work efficiency, a single use of the balance scale should be enough for measurement of each amount. You can use any number of weights at a time, placing them either on the balance plate opposite to the chemical or on the same plate with the chemical. For example, if you have two weights of 2 and 9 units, you can measure out not only 2 and 9 units of the chemical, but also 11 units by placing both on the plate opposite to the chemical (Fig. C-1 left), and 7 units by placing one of them on the plate with the chemical (Fig. C-1 right). These are the only amounts that can be measured out efficiently.
<image> Fig. C-1 Measuring 11 and 7 units of chemical
You have at hand a list of amounts of chemicals to measure today. The weight kit already at hand, however, may not be enough to efficiently measure all the amounts in the measurement list. If not, you can purchase one single new weight to supplement the kit, but, as heavier weights are more expensive, you'd like to do with the lightest possible.
Note that, although weights of arbitrary positive masses are in the market, none with negative masses can be found.
Input
The input consists of at most 100 datasets, each in the following format.
> n m
> a1 a2 ... an
> w1 w2 ... wm
>
The first line of a dataset has n and m, the number of amounts in the measurement list and the number of weights in the weight kit at hand, respectively. They are integers separated by a space satisfying 1 ≤ n ≤ 100 and 1 ≤ m ≤ 10.
The next line has the n amounts in the measurement list, a1 through an, separated by spaces. Each of ai is an integer satisfying 1 ≤ ai ≤ 109, and ai ≠ aj holds for i ≠ j.
The third and final line of a dataset has the list of the masses of the m weights at hand, w1 through wm, separated by spaces. Each of wj is an integer, satisfying 1 ≤ wj ≤ 108. Two or more weights may have the same mass.
The end of the input is indicated by a line containing two zeros.
Output
For each dataset, output a single line containing an integer specified as follows.
* If all the amounts in the measurement list can be measured out without any additional weights, `0`.
* If adding one more weight will make all the amounts in the measurement list measurable, the mass of the lightest among such weights. The weight added may be heavier than 108 units.
* If adding one more weight is never enough to measure out all the amounts in the measurement list, `-1`.
Sample Input
4 2
9 2 7 11
2 9
6 2
7 3 6 12 16 9
2 9
5 2
7 3 6 12 17
2 9
7 5
15 21 33 48 51 75 111
36 54 57 93 113
0 0
Output for the Sample Input
0
5
-1
5
Example
Input
4 2
9 2 7 11
2 9
6 2
7 3 6 12 16 9
2 9
5 2
7 3 6 12 17
2 9
7 5
15 21 33 48 51 75 111
36 54 57 93 113
0 0
Output
0
5
-1
5
|
def main():
n,m = map(int,input().split())
if n*m == 0: return False
a = list(map(int, input().split()))
w = list(map(int,input().split()))
d = {0:1}
for i in w:
new_d = dict(d)
for j in d.keys():
new_d[j+i] = 1
new_d[abs(j-i)] = 1
new_d[i] = 1
d = dict(new_d)
nokori = []
for i in a:
if i in d.keys():
pass
else:
nokori += [i]
# print(nokori)
nokorimono = len(nokori)
if nokorimono == 0:
print(0)
return True
ans_d = {}
for i in nokori:
new_d = {}
for j in d.keys():
new_d[abs(i-j)] = 1
new_d[i+j] = 1
for j in new_d.keys():
if j in ans_d:
ans_d[j] = ans_d[j] + 1
else:
ans_d[j] = 1
ans = 10**12
for i in ans_d.keys():
if ans_d[i] == nokorimono:
ans = min(ans, i)
if ans == 10**12:
ans = -1
print(ans)
return True
while main():
pass
|
There has been marketing warfare among beverage vendors, and they have been working hard for in- crease of their sales. The Kola-Coqua Company is one of the most successful vendors among those: their impressive advertisements toward the world has brought the overwhelming market share of their representative product called Koque.
This time, Kola-Coqua is focusing on vending machines. They think cusomters will be more pleasant as the machines respond more quickly, so they have improved many parts of the machines.
In particular, they have developed a new device of change return. The new device can give one or more kinds of coins at a time (in a single operation), although it can give only one coin for each kind at once. For example, suppose there are 500-yen, 100-yen, 50-yen and 10-yen coins, change of 6540 yen can be made by four operations of giving 500-yen and 10-yen coins and nine operations of giving 500-yen coins. In conclusion, 6540 yen can be returned by thirteen operations. It is supposed that the new device allows customers to make their purchase more quickly and so helps Kola-Coqua’s market share grow up.
However, the project leader says “No, it’s not optimal yet.” His suggesion is as follows: the real opti- mization is to minimize the number of operations. For example, change of 6540 yen should be made with ten of 500-yen coins, ten of 100-yen coins, ten of 50-yen coins, and four of 10-yen coins. This way, 6540 yen can be returned only with ten operations. This allows full speed-up in giving back change, even though it sometimes results in a huge amount of coins.
Given which kinds of coins are available and how much change should be given back, you are to write a program that calculates the minimum number of operations according to the above suggestion. You may assume that there are enough amount of coins inside the vending machines.
Input
The input consists of multiple data sets. Each dataset is described by two lines. The first line contains N (N ≤ 10) and M (M ≤ 100000) indicating the number of kinds of coins and the amount of change to be made, respectively. The second line contains N integers representing the value of each kind of coin.
The input is terminated by a dataset of N = M = 0. This dataset must not be processed.
Output
For each dataset, output in a line the minimum number of operations needed to give back exactly the specified amount of change.
Example
Input
6 330
1 5 10 50 100 500
7 127
1 2 4 8 16 32 64
2 10000
1000 2000
0 0
Output
2
1
4
|
#include<iostream>
using namespace std;
#define N 100001
#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n) REP(i,0,n)
int table[10][N];
int dp(int n,int m,int *coin,int lim){
rep(i,m+1){
if ( i%coin[0]==0)table[0][i]=i/coin[0];
else table[0][i]=lim+1;
}
REP(i,1,n){
rep(j,coin[i]){
if ( table[i-1][j]>lim){
table[i][j]=lim+1;
}else table[i][j]=0;
}
REP(j,coin[i],m+1){
if ( table[i-1][j]>lim){
if ( table[i][j-coin[i]]>lim)table[i][j]=lim+1;
else table[i][j]=table[i][j-coin[i]]+1;
}
else table[i][j]=0;
}
}
return table[n-1][m]<=lim?true:false;
}
int solve(int n,int m,int *coin){
int l=1,r=m,ret=m,mid;
while(l<=r){
mid =(l+r)/2;
if ( dp(n,m,coin,mid)==false)l=mid+1;
else {
ret=mid;
r=mid-1;
}
}
return ret;
}
int main(){
int n,m;
while(cin>>n>>m&&n){
int coin[n];
rep(i,n)cin>>coin[i];
cout << solve(n,m,coin) << endl;
}
}
|
Miki is a high school student. She has a part time job, so she cannot take enough sleep on weekdays. She wants to take good sleep on holidays, but she doesn't know the best length of sleeping time for her. She is now trying to figure that out with the following algorithm:
1. Begin with the numbers K, R and L.
2. She tries to sleep for H=(R+L)/2 hours.
3. If she feels the time is longer than or equal to the optimal length, then update L with H. Otherwise, update R with H.
4. After repeating step 2 and 3 for K nights, she decides her optimal sleeping time to be T' = (R+L)/2.
If her feeling is always correct, the steps described above should give her a very accurate optimal sleeping time. But unfortunately, she makes mistake in step 3 with the probability P.
Assume you know the optimal sleeping time T for Miki. You have to calculate the probability PP that the absolute difference of T' and T is smaller or equal to E. It is guaranteed that the answer remains unaffected by the change of E in 10^{-10}.
Input
The input follows the format shown below
K R L
P
E
T
Where the integers 0 \leq K \leq 30, 0 \leq R \leq L \leq 12 are the parameters for the algorithm described above. The decimal numbers on the following three lines of the input gives the parameters for the estimation. You can assume 0 \leq P \leq 1, 0 \leq E \leq 12, 0 \leq T \leq 12.
Output
Output PP in one line. The output should not contain an error greater than 10^{-5}.
Examples
Input
3 0 2
0.10000000000
0.50000000000
1.00000000000
Output
0.900000
Input
3 0 2
0.10000000000
0.37499999977
1.00000000000
Output
0.810000
Input
3 0 2
0.10000000000
0.00000100000
0.37500000000
Output
0.729000
Input
3 0 2
0.20000000000
0.00000100000
0.37500000000
Output
0.512000
|
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
#include <map>
#include <queue>
#include <set>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <bitset>
#include <climits>
#define REP(i,n) for (int i=0;i<(n);i++)
#define FOR(i,a,b) for (int i=(a);i<(b);i++)
#define RREP(i,n) for (int i=(n)-1;i>=0;i--)
#define RFOR(i,a,b) for (int i=(a)-1;i>=(b);i--)
#define ll long long
#define ull unsigned long long
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
const int INF = 1e9;
const int MOD = 1e9 + 7;
using namespace std;
int k;
double r,l,t,e,miss_p,suc_p;
double ans = 0.0;
void solve(int tk,double tr,double tl,double tp){
double h = (tr+tl)/2;
double n_suc_p = tp*suc_p;
double n_miss_p = tp*miss_p;
tk--;
if(tk == -1){
if((tr+tl)/2 >= t-e && (tr+tl)/2 <= t+e)ans+=tp;
}else if(t+e<tr&&t+e<tl||t-e>tr&&t-e>tl)return;
else if(h < t){
solve(tk,h,tl,n_suc_p);
solve(tk,tr,h,n_miss_p);
}else{
solve(tk,h,tl,n_miss_p);
solve(tk,tr,h,n_suc_p);
}
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cin>>k>>r>>l>>miss_p>>e>>t;
suc_p = 1.0 - miss_p;
double p = 1.0;
solve(k,r,l,p);
cout.precision(10);
cout << fixed << ans << endl;
return 0;
}
|
Mr. Knight is a chief architect of the project to build a new art museum. One day, he was struggling to determine the design of the building. He believed that a brilliant art museum must have an artistic building, so he started to search for a good motif of his building. The art museum has one big theme: "nature and human beings." To reflect the theme, he decided to adopt a combination of a cylinder and a prism, which symbolize nature and human beings respectively (between these figures and the theme, there is a profound relationship that only he knows).
Shortly after his decision, he remembered that he has to tell an estimate of the cost required to build to the financial manager. He unwillingly calculated it, and he returned home after he finished his report. However, you, an able secretary of Mr. Knight, have found that one field is missing in his report: the length of the fence required to surround the building. Fortunately you are also a good programmer, so you have decided to write a program that calculates the length of the fence.
To be specific, the form of his building is union of a cylinder and a prism. You may consider the twodimensional projection of the form, i.e. the shape of the building is considered to be union of a circle C and a polygon P. The fence surrounds the outside of the building. The shape of the building may have a hole in it, and the fence is not needed inside the building. An example is shown in the figure below.
<image>
Input
The input contains one test case.
A test case has the following format:
R
N x1 y1 x2 y2 ... xn yn
R is an integer that indicates the radius of C (1 ≤ R ≤ 1000), whose center is located at the origin. N is the number of vertices of P, and (xi, yi) is the coordinate of the i-th vertex of P. N, xi and yi are all integers satisfying the following conditions: 3 ≤ N ≤ 100,|xi| ≤ 1000 and |yi| ≤ 1000.
You may assume that C and P have one or more intersections.
Output
Print the length of the fence required to surround the building. The output value should be in a decimal fraction may not contain an absolute error more than 10-4.
It is guaranteed that the answer does not change by more than 10-6 when R is changed by up to 10-9.
Example
Input
2
8 -1 2 1 2 1 -3 2 -3 2 3 -2 3 -2 -3 -1 -3
Output
22.6303
|
#include <iostream>
#include <iomanip>
#include <complex>
#include <vector>
#include <algorithm>
#include <cmath>
#include <array>
using namespace std;
const double EPS = 1e-8;
const double INF = 1e12;
const double PI = acos(-1);
#define EQ(n,m) (abs((n)-(m)) < EPS)
#define X real()
#define Y imag()
typedef complex<double> P;
typedef vector<P> VP;
struct L : array<P, 2>{
L(const P& a, const P& b){ at(0)=a; at(1)=b; }
L(){}
};
struct C{
P p;
double r;
C(const P& p, const double& r) : p(p), r(r) {}
C(){}
};
namespace std{
bool operator < (const P& a, const P& b){
return !EQ(a.X,b.X) ? a.X<b.X : a.Y+EPS<b.Y;
}
bool operator == (const P& a, const P& b){
return abs(a-b) < EPS;
}
}
double dot(P a, P b){
return (conj(a)*b).X;
}
double cross(P a, P b){
return (conj(a)*b).Y;
}
int ccw(P a, P b, P c){
b -= a;
c -= a;
if(cross(b,c) > EPS) return +1; //ccw
if(cross(b,c) < -EPS) return -1; //cw
if(dot(b,c) < -EPS) return +2; //c-a-b
if(abs(c)-abs(b) > EPS) return -2; //a-b-c
return 0; //a-c-b
}
P unit(const P &p){
return p/abs(p);
}
P rotate(const P &p, double rad){
return p *P(cos(rad), sin(rad));
}
bool intersectSP(const L& s, const P &p){
return abs(cross(s[0]-p, s[1]-p))<EPS && dot(s[0]-p, s[1]-p)<EPS;
}
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]);
}
double distanceLP(const L &l, const P &p) {
return abs(cross(l[1]-l[0], p-l[0])) /abs(l[1]-l[0]);
}
VP crosspointCL(const C &c, const L &l){
VP ret;
P mid = projection(l, c.p);
double d = distanceLP(l, c.p);
if(EQ(d, c.r)){
ret.push_back(mid);
}else if(d < c.r){
double len = sqrt(c.r*c.r -d*d);
ret.push_back(mid +len*unit(l[1]-l[0]));
ret.push_back(mid -len*unit(l[1]-l[0]));
}
return ret;
}
VP crosspointCS(const C &c, const L &s){
VP ret;
VP cp = crosspointCL(c,s);
for(int i=0; i<(int)cp.size(); i++){
if(intersectSP(s, cp[i])){
ret.push_back(cp[i]);
}
}
return ret;
}
double getarea(const VP &poly){
double ret = 0;
for (int i=0; i<(int)poly.size(); i++){
ret += cross(poly[i], poly[(i+1)%poly.size()]);
}
return ret*0.5;
}
int in_poly(const P &p, const VP &poly){
int n = poly.size();
int ret = -1;
for(int i=0; i<n; i++){
P a = poly[i]-p;
P b = poly[(i+1)%n]-p;
if(a.Y > b.Y) swap(a,b);
if(intersectSP(L(a,b), P(0,0))) return 0;
if(a.Y<=0 && b.Y>0 && cross(a,b)<0) ret = -ret;
}
return ret;
}
bool epseq(const double &a, const double &b){
return abs(a-b) < EPS;
}
int main(){
double r;
int n;
cin >> r >> n;
VP p(n);
for(int i=0; i<n; i++){
double x,y;
cin >> x >> y;
p[i] = P(x, y);
}
C c(P(0, 0), r);
if(getarea(p) < 0){
reverse(p.begin(), p.end());
}
vector<VP> cp(n);
vector<double> angle;
angle.push_back(-PI);
for(int i=0; i<n; i++){
cp[i].push_back(p[i]);
cp[i].push_back(p[(i+1)%n]);
VP ret = crosspointCS(c, L(p[i], p[(i+1)%n]));
for(P p: ret){
cp[i].push_back(p);
angle.push_back(arg(p));
}
sort(cp[i].begin(), cp[i].end());
cp[i].erase(unique(cp[i].begin(), cp[i].end()), cp[i].end());
if(cp[i][0] != p[i]){
reverse(cp[i].begin(), cp[i].end());
}
}
sort(angle.begin(), angle.end());
angle.erase(unique(angle.begin(), angle.end(), epseq), angle.end());
if(epseq(angle.back(), PI)){
angle.pop_back();
}
int idx, sidx;
bool poly;
P pmin = *min_element(p.begin(), p.end());
if(P(-r, 0) == pmin || P(-r, 0) < pmin){
idx = 0;
poly = false;
pmin = P(-r, 0);
}else{
idx = min_element(p.begin(), p.end()) -p.begin();
sidx = 0;
poly = true;
}
P curr = pmin;
double ans = 0;
do{
if(poly){
//次の辺に切り替わる
if(sidx == (int)cp[idx].size()-1){
idx = (idx +1)%n;
sidx = 0;
continue;
}
P mid = (cp[idx][sidx] +cp[idx][sidx+1]) /2.0;
//円に切り替わる
if(abs(mid) < r){
double a = arg(cp[idx][sidx]);
if(epseq(PI, a)){
a = -PI;
}
for(int i=0; i<(int)angle.size(); i++){
if(epseq(angle[i], a)){
idx = i;
break;
}
}
poly = false;
continue;
}
ans += abs(cp[idx][sidx+1] -cp[idx][sidx]);
sidx++;
curr = cp[idx][sidx];
}else{
int m = angle.size();
double ai1 = (idx == m-1)? PI: angle[idx+1];
P mid = rotate(P(r, 0), (angle[idx] +ai1)/2);
//多角形に切り替わる
if(in_poly(mid, p) > 0){
for(int i=0; i<n; i++){
for(int j=0; j<(int)cp[i].size(); j++){
if(cp[i][j] == curr){
idx = i;
sidx = j;
i = n;
break;
}
}
}
poly = true;
continue;
}
ans += r *(ai1 -angle[idx]);
idx = (idx+1)%m;
curr = rotate(P(r, 0), angle[idx]);
}
}while(!(curr == pmin));
cout << fixed << setprecision(10);
cout << ans << endl;
return 0;
}
|
Ayimok is a wizard.
His daily task is to arrange magical tiles in a line, and then cast a magic spell.
Magical tiles and their arrangement follow the rules below:
* Each magical tile has the shape of a trapezoid with a height of 1.
* Some magical tiles may overlap with other magical tiles.
* Magical tiles are arranged on the 2D coordinate system.
* Magical tiles' upper edge lay on a horizontal line, where its y coordinate is 1.
* Magical tiles' lower edge lay on a horizontal line, where its y coordinate is 0.
He has to remove these magical tiles away after he finishes casting a magic spell. One day, he found that removing a number of magical tiles is so tiresome, so he decided to simplify its process.
Now, he has learned "Magnetization Spell" to remove magical tiles efficiently. The spell removes a set of magical tiles at once. Any pair of two magical tiles in the set must overlap with each other.
For example, in Fig. 1, he can cast Magnetization Spell on all of three magical tiles to remove them away at once, since they all overlap with each other. (Note that the heights of magical tiles are intentionally changed for easier understandings.)
<image>
Fig. 1: Set of magical tiles which can be removed at once
However, in Fig. 2, he can not cast Magnetization Spell on all of three magical tiles at once, since tile 1 and tile 3 are not overlapped.
<image>
Fig. 2: Set of magical tiles which can NOT be removed at once
He wants to remove all the magical tiles with the minimum number of Magnetization Spells, because casting the spell requires magic power exhaustively.
Let's consider Fig. 3 case. He can remove all of magical tiles by casting Magnetization Spell three times; first spell for tile 1 and 2, second spell for tile 3 and 4, and third spell for tile 5 and 6.
<image>
Fig. 3: One way to remove all magical tiles (NOT the minimum number of spells casted)
Actually, he can remove all of the magical tiles with casting Magnetization Spell just twice; first spell for tile 1, 2 and 3, second spell for tile 4, 5 and 6. And it is the minimum number of required spells for removing all magical tiles.
<image>
Fig. 4: The optimal way to remove all magical tiles(the minimum number of spells casted)
Given a set of magical tiles, your task is to create a program which outputs the minimum number of casting Magnetization Spell to remove all of these magical tiles away.
There might be a magical tile which does not overlap with other tiles, however, he still needs to cast Magnetization Spell to remove it.
Input
Input follows the following format:
N
xLower_{11} xLower_{12} xUpper_{11} xUpper_{12}
xLower_{21} xLower_{22} xUpper_{21} xUpper_{22}
xLower_{31} xLower_{32} xUpper_{31} xUpper_{32}
:
:
xLower_{N1} xLower_{N2} xUpper_{N1} xUpper_{N2}
The first line contains an integer N, which means the number of magical tiles.
Then, N lines which contain the information of magical tiles follow.
The (i+1)-th line includes four integers xLower_{i1}, xLower_{i2}, xUpper_{i1}, and xUpper_{i2}, which means i-th magical tile's corner points are located at (xLower_{i1}, 0), (xLower_{i2}, 0), (xUpper_{i1}, 1), (xUpper_{i2}, 1).
You can assume that no two magical tiles will share their corner points. That is, all xLower_{ij} are distinct, and all xUpper_{ij} are also distinct. The input follows the following constraints:
* 1 \leq N \leq 10^5
* 1 \leq xLower_{i1} < xLower_{i2} \leq 10^9
* 1 \leq xUpper_{i1} < xUpper_{i2} \leq 10^9
* All xLower_{ij} are distinct.
* All xUpper_{ij} are distinct.
Output
Your program must output the required minimum number of casting Magnetization Spell to remove all the magical tiles.
Sample Input 1
3
26 29 9 12
6 10 15 16
8 17 18 19
Output for the Sample Input 1
1
Sample Input 2
3
2 10 1 11
5 18 9 16
12 19 15 20
Output for the Sample Input 2
2
Sample Input 3
6
2 8 1 14
6 16 3 10
3 20 11 13
17 28 18 21
22 29 25 31
23 24 33 34
Output for the Sample Input 3
2
Example
Input
3
26 29 9 12
6 10 15 16
8 17 18 19
Output
1
|
#include<stdio.h>
#include<algorithm>
using namespace std;
int l1[110000];
int r1[110000];
int l2[110000];
int r2[110000];
int segtree[524288];
int dp[110000];
int query(int a,int b,int c,int d,int e){
if(d<a||b<c)return 0;
if(c<=a&&b<=d)return segtree[e];
return max(query(a,(a+b)/2,c,d,e*2),query((a+b)/2+1,b,c,d,e*2+1));
}
void update(int a,int b){
a+=262144;
while(a){
segtree[a]=max(segtree[a],b);
a/=2;
}
}
pair<int,pair<int,int> >ev[210000];
int z[210000];
int main(){
int a;
scanf("%d",&a);
for(int i=0;i<a;i++){
scanf("%d%d%d%d",l1+i,r1+i,l2+i,r2+i);
z[i*2]=r2[i];
z[i*2+1]=l2[i];
ev[i*2]=make_pair(l1[i],make_pair(i,0));
ev[i*2+1]=make_pair(r1[i],make_pair(i,1));
}
std::sort(z,z+a*2);
std::sort(ev,ev+a*2);
for(int i=0;i<a*2;i++){
int at=ev[i].second.first;
if(ev[i].second.second==0){
int pos=lower_bound(z,z+a*2,l2[at])-z;
dp[at]=query(0,262143,0,pos,1)+1;
}else{
int pos=lower_bound(z,z+a*2,r2[at])-z;
update(pos,dp[at]);
}
}
int ret=0;
for(int i=0;i<a;i++)ret=max(ret,dp[i]);
printf("%d\n",ret);
}
|
B: Periodic Sequence-
problem
Dr. Period, a professor at H University, is studying a property called the cycle that is supposed to be hidden in all things. As a generally known basic cycle, a cycle hidden in a sequence may be considered. That is, if the sequence S = S_1, S_2, ..., S_N of length N satisfies the following properties, it has a period t (t \ ≤ N).
For 1 \ ≤ i \ ≤ N − t, S_i = S_ {i + t}.
Now, Dr. Period is paying attention to a sequence that can be described more simply using a period. For example, if a sequence of length N has a period t (\ ≤ N) and you can write N = kt using an integer k, then that sequence is a sequence of length t S_1, ..., S_t is k. It can be described that the pieces are continuous. When Dr. Period could describe a sequence as an example, he decided to say that the sequence was a k-part.
Dr. Period is interested in the k-part with the largest k. So, as an assistant, you are tasked with writing a program that takes a sequence as input and outputs the largest k when it is a k-part. Create a program that exactly meets Dr. Period's demands.
Input format
N
S_1 ... S_N
The first row is given the integer N, which represents the length of the sequence. In the second row, the integer S_i (1 \ ≤ i \ ≤ N) representing each element of the sequence of length N is given, separated by blanks. Also, the inputs satisfy 1 \ ≤ N \ ≤ 200,000 and 1 \ ≤ S_i \ ≤ 100,000 (1 \ ≤ i \ ≤ N).
Output format
For a given sequence, output the maximum value of k when it is k-part in one row.
Input example 1
6
1 2 3 1 2 3
Output example 1
2
Input example 2
12
1 2 1 2 1 2 1 2 1 2 1 2
Output example 2
6
Input example 3
6
1 2 3 4 5 6
Output example 3
1
Example
Input
6
1 2 3 1 2 3
Output
2
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N, S[200000];
scanf("%d", &N);
for(int i = 0; i < N; i++) {
scanf("%d", &S[i]);
}
for(int i = 1; i <= N; i++) {
if(N % i == 0) {
bool match = true;
for(int j = i; j < N; j += i) {
for(int k = 0; k < i; k++) match &= S[k] == S[j + k];
}
if(match) {
printf("%d\n", N / i);
return (0);
}
}
}
}
|
You are given an integer $N$ and a string consisting of '+' and digits. You are asked to transform the string into a valid formula whose calculation result is smaller than or equal to $N$ by modifying some characters. Here, you replace one character with another character any number of times, and the converted string should still consist of '+' and digits. Note that leading zeros and unary positive are prohibited.
For instance, '0123+456' is assumed as invalid because leading zero is prohibited. Similarly, '+1+2' and '2++3' are also invalid as they each contain a unary expression. On the other hand, '12345', '0+1+2' and '1234+0+0' are all valid.
Your task is to find the minimum number of the replaced characters. If there is no way to make a valid formula smaller than or equal to $N$, output $-1$ instead of the number of the replaced characters.
Input
The input consists of a single test case in the following format.
$N$
$S$
The first line contains an integer $N$, which is the upper limit of the formula ($1 \leq N \leq 10^9$). The second line contains a string $S$, which consists of '+' and digits and whose length is between $1$ and $1,000$, inclusive. Note that it is not guaranteed that initially $S$ is a valid formula.
Output
Output the minimized number of the replaced characters. If there is no way to replace, output $-1$ instead.
Examples
Input
100
+123
Output
2
Input
10
+123
Output
4
Input
1
+123
Output
-1
Input
10
++1+
Output
2
Input
2000
1234++7890
Output
2
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll inf = 2e9;
int main() {
int n; cin >> n;
string s; cin >> s;
const int m = s.size();
vector<vector<vector<ll>>> val(m, vector<vector<ll>>(10, vector<ll>(11, inf)));
for(int i = 0; i < m; ++i) {
for(int len = 0; len < 10; ++len) {
if(i - len < 0) continue;
auto t = s.substr(i - len, len + 1);
int need = 0;
for(int j = 0; j <= len; ++j) {
if(j == 0) {
if((len != 0 && t[j] == '0') || !isdigit(t[j])) {
need += 1;
t[j] = len == 0 ? '0' : '1';
}
} else {
if(!isdigit(t[j])) {
need += 1;
t[j] = '0';
}
}
}
auto check =
[&] (int p) {
return ((p == 0 && t[p] == (len == 0 ? '0' : '1')) || (p != 0 && t[p] == '0'));
};
int idx = 0;
val[i][len][need] = stol(t);
while(idx < (int)t.size()) {
while(idx < (int)t.size() && check(idx)) idx++;
if(idx < (int)t.size()) {
need += 1;
t[idx] = (len != 0 && idx == 0) ? '1' : '0';
val[i][len][need] = stol(t);
}
idx++;
}
}
}
//cout << val[9][9][10] << endl;
// 0: => //, 1: => +
vector<vector<vector<ll>>> dp(m + 1, vector<vector<ll>>(m + 1, vector<ll>(2, inf)));
dp[0][0][1] = 0;
for(int i = 0; i < m; ++i) {
for(int cnt = 0; cnt <= m; ++cnt) {
for(int pre = 0; pre <= 9; ++pre) {
for(int x = 0; x <= pre + 1; ++x) {
if(i - pre < 0 || cnt + x > m) continue;
dp[i + 1][cnt + x][0] = min(dp[i + 1][cnt + x][0], dp[i - pre][cnt][1] + val[i][pre][x]);
}
}
const int add = (s[i] != '+');
if(cnt + add <= m) {
dp[i + 1][cnt + add][1] = min(dp[i + 1][cnt + add][1], dp[i][cnt][0]);
}
}
}
ll ans = -1;
for(int i = 0; i <= m; ++i) {
if(dp[m][i][0] <= n) {
ans = i;
break;
}
}
cout << ans << endl;
}
|
Problem
Kotatsu turtle is a turtle with a kotatsu shell.
As soon as Kotatsu was pokita (getting up), he was trapped in a stage divided into grid-like sections. There is only one exit on this stage. The parcel is either a road, a fence or a bomb, and the kotatsu can move up, down, left and right to enter the parcel of the road or bomb. It cannot be moved diagonally. In addition, the fence section cannot be passed. The road section extends infinitely outside the stage, but it cannot be passed because there is a crocodile, the natural enemy of the turtle.
Kotatsu wants to go home (sleep) quickly, so I decided to head to the exit of this stage.
The kotatsu turtle, which can freely manipulate the infrared rays of the kotatsu, has the ability to turn eight sections around it into a road at the same time. However, if the 8 sections and one of the sections where you are located are bomb sections, the kotatsu will burn up when you explode, and you will not even be able to use the famous SNS "Kametta", so you will activate the ability. I can't do that.
<image>
An example is illustrated. The section where the illustration is not placed and the section where the kotatsu is placed are the sections of the road. The eight compartments around the kotatsu are the orange compartments. In the figure on the left, the 8 compartments around the kotatsu and the compartment where you are are not included in the bomb compartment, so you can activate the ability. However, in the figure on the right, the ability cannot be activated because the bomb compartment is included in either the surrounding 8 compartments or the compartment where you are.
The cost to move is $ A $ for each parcel move, and the cost to activate the ability is $ B $ each time. Please note that it is not the cost per wall turned into a road. The starting point and the exit of the stage are roads. Output the minimum sum of the cost of moving from the starting point to the exit of the stage and the cost of activating the ability. However, if you cannot reach the exit of the stage, output "INF" instead.
Constraints
The input satisfies the following conditions.
* $ 1 \ le H, W, A, B \ le 1000 $
* $ 3 \ le H + W $
* $ c_ {i, j} \ in $ {'s','g','.','#','*'}
*'s' and'g' appear once each
Input
The input is given in the following format.
$ H $ $ W $ $ A $ $ B $
$ c_ {1,1} \ cdots c_ {1, W} $
$ \ vdots $
$ c_ {H, 1} \ cdots c_ {H, W} $
The input consists of $ H + 1 $ lines.
On the $ 1 $ line, there are an integer $ H $ that represents the vertical length, an integer $ W $ that represents the left and right length, an integer $ A $ that represents the cost to move, and an integer $ B $ that represents the cost to activate the ability. Each is given with a blank delimiter.
The $ H $ line from the $ 2 $ line is given the state $ c_ {i, j} $ in each section of the stage where the kotatsu is confined.
$ c_ {i, j} $ consists of one of's','g','.','#','*', Each, and the partition $ (i, j) $ is in the following state. Represents that.
's': Indicates that the section is the starting point.
'g': Indicates that the parcel is the exit of the stage.
'.': Indicates that the section is a road.
'#': Indicates that the section is a fence.
'*': Indicates that the parcel is a bomb.
Output
Output the minimum sum of the cost of moving from the starting point to the exit of the stage and the cost of activating the ability. However, if you cannot reach the exit of the stage, output "INF" instead.
Examples
Input
4 4 1 1
g#..
#...
.*..
...s
Output
7
Input
4 4 1 1
g#..
...
.*..
...s
Output
7
Input
4 4 1 1
g#..
*..
....
...s
Output
INF
Input
2 4 1 1
g
s###
Output
6
Input
3 3 1 10
g..
.
s..
Output
6
Input
3 3 10 1
g..
.
s..
Output
21
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef pair<int,P> P1;
typedef pair<P,P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define mod 1000000007
#define fi first
#define sc second
#define rep(i,x) for(int i=0;i<x;i++)
#define repn(i,x) for(int i=1;i<=x;i++)
#define SORT(x) sort(x.begin(),x.end())
#define ERASE(x) x.erase(unique(x.begin(),x.end()),x.end())
#define POSL(x,v) (lower_bound(x.begin(),x.end(),v)-x.begin())
#define POSU(x,v) (upper_bound(x.begin(),x.end(),v)-x.begin())
int n,m,a,b;
ll ans[1005][1005];
string f[1005];
priority_queue<pair<ll,P>,vector<pair<ll,P> >,greater<pair<ll,P> > > que;
int main(){
cin>>n>>m>>a>>b;
rep(i,n) cin>>f[i];
int sx,sy,gx,gy;
rep(i,n)rep(j,m){
ans[i][j] = 1e18;
if(f[i][j] == 's'){
sx = i; sy = j;
}
if(f[i][j] == 'g'){
gx = i; gy = j;
}
}
ans[sx][sy] = 0;
que.push(mp(0,mp(sx,sy)));
while(!que.empty()){
P1 p = que.top(); que.pop();
if(p.fi != ans[p.sc.fi][p.sc.sc]) continue;
int dx[8]={0,0,1,-1,1,1,-1,-1};
int dy[8]={1,-1,0,0,1,-1,1,-1};
rep(k,4){
int nx = p.sc.fi+dx[k], ny = p.sc.sc+dy[k];
if(0<=nx&&nx<n &&0<=ny && ny<m && f[nx][ny] != '#'){
if(ans[nx][ny] > p.fi+1LL*a){
ans[nx][ny] = p.fi+1LL*a;
que.push(mp(ans[nx][ny],mp(nx,ny)));
}
}
}
bool bad = 0;
if(f[p.sc.fi][p.sc.sc] == '*') bad = 1;
rep(k,8){
int nx = p.sc.fi+dx[k], ny = p.sc.sc+dy[k];
if(0<=nx&&nx<n &&0<=ny && ny<m && f[nx][ny] == '*'){
bad = 1;
}
}
if(!bad){
rep(k,8){
int nx = p.sc.fi+dx[k], ny = p.sc.sc+dy[k];
int w = abs(dx[k])+abs(dy[k]);
if(0<=nx&&nx<n &&0<=ny && ny<m){
if(ans[nx][ny] > p.fi+1LL*b+1LL*w*a){
ans[nx][ny] = p.fi+1LL*b+1LL*w*a;
que.push(mp(ans[nx][ny],mp(nx,ny)));
}
}
}
}
}
if(ans[gx][gy] < 1e17) cout << ans[gx][gy] << endl;
else cout << "INF" << endl;
}
|
For given two segments s1 and s2, print "1" if they are intersect, "0" otherwise.
s1 is formed by end points p0 and p1, and s2 is formed by end points p2 and p3.
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xpi, ypi ≤ 10000
* p0 ≠ p1 and p2 ≠ p3.
Input
The entire input looks like:
q (the number of queries)
1st query
2nd query
...
qth query
Each query consists of integer coordinates of end points of s1 and s2 in the following format:
xp0 yp0 xp1 yp1 xp2 yp2 xp3 yp3
Output
For each query, print "1" or "0".
Example
Input
3
0 0 3 0 1 1 2 -1
0 0 3 0 3 1 3 -1
0 0 3 0 3 -2 5 0
Output
1
1
0
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
3
0 0 3 0 1 1 2 -1
0 0 3 0 3 1 3 -1
0 0 3 0 3 -2 5 0
output:
1
1
0
"""
import sys
EPS = 1e-9
def cross(a, b):
return a.real * b.imag - a.imag * b.real
def dot(a, b):
return a.real * b.real + a.imag * b.imag
def check_ccw(p0, p1, p2):
a, b = p1 - p0, p2 - p0
if cross(a, b) > EPS:
flag = 1
elif cross(a, b) < -1 * EPS:
flag = -1
elif dot(a, b) < -1 * EPS:
flag = 2
elif abs(a) < abs(b):
flag = -2
else:
flag = 0
return flag
def check_intersection(p0, p1, p2, p3):
intersected = (check_ccw(p0, p1, p2) * check_ccw(p0, p1, p3) <= 0) and \
(check_ccw(p2, p3, p0) * check_ccw(p2, p3, p1) <= 0)
return intersected
def solve(_lines):
for line in _lines:
line = tuple(map(int, line))
p0, p1, p2, p3 = (x + y * 1j for x, y in zip(line[::2], line[1::2]))
intersected = check_intersection(p0, p1, p2, p3)
if intersected:
print('1')
else:
print('0')
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
l_num = int(_input[0])
lines = map(lambda x: x.split(), _input[1:])
solve(lines)
|
For a given sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$, perform the following operations.
* count($b, e, k$): print the number of the specific values $k$ in $a_b, a_{b+1}, ..., a_{e-1}$.
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i, k_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b < e \leq n$
Input
The input is given in the following format.
$n$
$a_0 \; a_1, ..., \; a_{n-1}$
$q$
$b_1 \; e_1 \; k_1$
$b_2 \; e_2 \; k_2$
:
$b_q \; e_q \; k_q$
The number of elements $n$ and each element $a_i$ are given in the first line and the second line respectively. In the third line, the number of queries $q$ is given and the following $q$ lines, $q$ integers $b_i \; b_e \; k_i$ are given as queries.
Output
For each query, print the number of specified values.
Example
Input
9
1 4 1 4 2 1 3 5 6
3
0 9 1
1 6 1
3 7 5
Output
3
2
0
|
#include<bits/stdc++.h>
using namespace std;
signed main(){
int n;
cin>>n;
vector<int> a(n);
for(auto& ai:a)cin>>ai;
int q;
cin>>q;
while(q--){
int l,r,k;
cin>>l>>r>>k;
cout<< count(a.begin()+l,a.begin()+r,k) <<endl;
}
}
|
Given this sequence
..
1^(1!)+2^(2!)+3^(3!)+4^(4!)+
..N^(N!).
Your job is to write a program such that given N any time, you have to find out the unit place digit of the sum of the above sequence.
Input
Enter the number N to calculate the unit place digit of the sum of the above sequence 1 < N < 1000. The end of file is denoted by #.
Output
You have to give the unit place digit of sum of above sequence till N.
Example
Sample Input
71
#
Sample Output
8
|
def factorial(k):
if k > 4: k = 4 # specific code
P = 1
for i in xrange(1,k+1):
P *= i
return P
def process(N):
S = 0
for i in xrange(1, N + 1):
S += ((i % 10) ** factorial(i)) % 10
return S
def main():
while True:
N = raw_input()
if N == '#': break
print process(int(N)) % 10
main()
|
Reversed number is a number written in arabic numerals but the order of digits is reversed.
The first digit becomes last and vice versa. For example, if the number is 1245,it will become
5421 .Note that all the leading zeros are omitted. That means if the number ends with a zero,
the zero is lost by reversing (e.g. 1200 gives 21). Also note that the reversed number never has
any trailing zeros. Your task is to add two reversed numbers and output their reversed sum. Of
course, the result is not unique because any particular number is a reversed form of several
numbers (e.g. 21 could be 12, 120 or 1200 before reversing). Thus we must assume that no zeros
were lost by reversing (e.g. assume that the original number was 12).
Input
The input consists of N cases (equal to about 10000). The first line of the input contains
only positive integer N. Then follow the cases. Each case consists of exactly one line with
two positive integers separated by space. These are the reversed numbers you are to add.
Output
For each case, print exactly one line containing only one integer - the reversed sum of
two reversed numbers. Omit any leading zeros in the output.
Example
Input:
1
24 1
Output:
34
|
import sys
t=input()
while(t>0):
sumu=0
n, m = map(int, sys.stdin.readline().split(' '))
n=str(n)[::-1]
n=int(n)
m=str(m)[::-1]
m=int(m)
sumu=n+m
sumu=str(sumu)[::-1]
sumu=int(sumu)
print sumu
t=t-1
|
In a company an emplopyee is paid as under:
If his basic salary is less than Rs. 1500, then HRA = 10% of base salary and DA = 90% of basic salary. If his salary is either equal to or above Rs. 1500, then HRA = Rs. 500 and DA = 98% of basic salary. If the Employee's salary is input, write a program to find his gross salary.
NOTE: Gross Salary = Basic Salary+HRA+DA
Input
The first line contains an integer T, total number of testcases. Then follow T lines, each line contains an integer salary.
Output
Output the gross salary of the employee.
Constraints
1 ≤ T ≤ 1000
1 ≤ salary ≤ 100000
Example
Input
3
1203
10042
1312
Output
2406
20383.2
2624
|
#!/usr/bin/python
for i in range(input()):
basic=input()
if basic<1500:
gross=(basic+basic*0.1+basic*0.9)
else:
gross=(basic+500+basic*0.98)
print "%g" %gross
|
The Little Elephant from the Zoo of Lviv likes listening to music.
There are N songs, numbered from 1 to N, in his MP3-player. The song i is described by a pair of integers Bi and Li - the band (represented as integer) that performed that song and the length of that song in seconds. The Little Elephant is going to listen all the songs exactly once in some order.
The sweetness of the song is equal to the product of the length of that song and the number of different bands listened before (including the current playing song).
Help the Little Elephant to find the order that maximizes the total sweetness of all N songs. Print that sweetness.
Input
The first line of the input contains single integer T, denoting the number of test cases. Then T test cases follow. The first line of each test case contains single integer N, denoting the number of the songs. The next N lines describe the songs in the MP3-player. The i-th line contains two space-sparated integers Bi and Li.
Output
For each test, output the maximum total sweetness.
Constraints
1 ≤ T ≤ 5
1 ≤ N ≤ 100000 (10^5)
1 ≤ Bi, Li ≤ 1000000000 (10^9)
Example
Input:
2
3
1 2
2 2
3 2
3
2 3
1 2
2 4
Output:
12
16
Explanation
In the first sample: if he listens the songs in given order, thenB11: the sweetness = 2 * 1 = 2B22: the sweetness = 2 * 2 = 4B33: the sweetness = 2 * 3 = 6So the total sweetness is 12. In this case, you can check the total sweetness does not depend on the order of the songs.
In the second sample: if he listens the songs in given order, thenB11: the sweetness = 3 * 1 = 3B22: the sweetness = 2 * 2 = 4B33: the sweetness = 4 * 2 = 8So the total sweetness is 15. However, he listens the song 2 firstly, thenB22: the sweetness = 2 * 1 = 2B11: the sweetness = 3 * 2 = 6B33: the sweetness = 4 * 2 = 8So the total sweetness is 16, and it is the maximum total sweetness.
|
import operator
t = input()
for i in range(t):
table = {}
remaining_table = []
swtns1 = 0
swtns2 = 0
swtns = 0
count = 1
n = input()
for j in range(n):
b,l = map(int, raw_input().split())
if b in table:
if l < table[b]:
remaining_table.append(table[b])
table[b] = l
else:
remaining_table.append(l)
else:
table[b] = l
for j in sorted(table.iteritems(), key = operator.itemgetter(1)):
swtns1 = swtns1 + j[1]*count
count = count + 1
count = count - 1
for j in remaining_table:
swtns2 = swtns2 + j*count
swtns = swtns1 + swtns2
print swtns
|
Polo, the Penguin, likes the XOR operation. Please read NOTE if you are not familiar with XOR operation.
XOR-sum of a list of numbers is the result of XOR-ing all of them. XOR-sum of (A[1] XOR A[2] XOR ... XOR A[N]) is defined as A[1] XOR (A[2] XOR (A[3] XOR ( ... XOR A[N]))).
He has an array A consisting of N integers. Index in the array are numbered from 1 to N, inclusive. Let us denote by F(L, R), the XOR-sum of all integers in the array A whose indices lie from L to R, inclusive, i.e. F(L, R) = A[L] XOR A[L+1] XOR ... XOR A[R]. Your task is to find the total sum of XOR-sums F(L, R) over all L and R such that 1 ≤ L ≤ R ≤ N.
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 size of A. The second line contains N space-separated integers A[1], A[2], ..., A[N].
Output
For each test case, output a single line containing the total sum to the corresponding test case.
Constraints
1 ≤ T ≤ 100,000
1 ≤ N ≤ 100,000
0 ≤ A[i] ≤ 1,000,000,000 (10^9)
The total sum of all N over all test cases will not exceed 100,000.
Example
Input:
1
2
1 2
Output:
6
Explanation
Example case 1. F(1, 1) = A[1] = 1, F(2, 2) = A[2] = 2 and F(1, 2) = A[1] XOR A[2] = 1 XOR 2 = 3. Hence the answer is 1 + 2 + 3 = 6.
NOTE
XOR operation is a bitwise "Exclusive OR" operation performed on two integers in binary representation. First, the shorter number is prepended with leading zeroes until the numbers have equal size in binary. Then the resulting number (also in binary) contains 0 in all positions where the corresponding bits coincide, and 1 on the rest of the positions.
For example, 3 XOR 5 = 0112 XOR 1012 = 1102 = 6.
|
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import random
def count_bits(n):
res = 0
while n:
res += 1
n >>= 1
return res
t = int(raw_input())
for _ in range(t):
n = int(raw_input())
lst = map(int, raw_input().split())
#lst = [random.randint(0, (1 << 16) - 1) for i in range(10**5)]
n_bits = count_bits(max(lst))
counts = [(0, 0, 0) for _ in range(n_bits)]
for num in lst:
for i, (c0, c1, count) in enumerate(counts):
bit = (num & (1 << i)) >> i
if bit == 1:
c0, c1 = c1, c0
c1 += 1
else:
c0 += 1
count += c1
counts[i] = c0, c1, count
result = 0
for i, (c0, c1, count) in enumerate(counts):
result += count << i
print result
'''
count = 0
c0, c1 = 0, 0
for i, bit in enumerate(lst):
#print c0, c1, "bit", bit, "->",
if bit == 1:
c0, c1 = c1, c0
c1 += 1
else:
c0 += 1
count += c1
#print c0, c1, "count", count
print count
'''
|
Let's consider a triangle of numbers in which a number appears in the first line, two numbers appear in the second line, three in the third line, etc. Develop a program which will compute the largest of the sums of numbers that appear on the paths starting from the top towards the base, so that:
on each path the next number is located on the row below, more precisely either directly below or below and one place to the right;
the number of rows is strictly positive, but less than 100
all numbers are positive integers between O and 99.
Input
In the first line integer n - the number of test cases (equal to about 1000).
Then n test cases follow. Each test case starts with the number of lines which is followed by their content.
Output
For each test case write the determined value in a separate line.
Example
Input:
2
3
1
2 1
1 2 3
4
1
1 2
4 1 2
2 3 1 1
Output:
5
9
Warning: large Input/Output data, be careful with certain languages
|
t=input()
for i in range(t):
n=input()
prev_row=[]
first_element=input()
prev_row.append(first_element)
for j in range(1,n):
row=[int(k) for k in raw_input().split()]
for l in range(1,len(row)-1):
row[l]+=max(prev_row[l],prev_row[l-1])
row[len(row)-1]+= prev_row[len(row)-2]
row[0]+=prev_row[0]
prev_row=row
print max(prev_row)
|
Alice and Bob decided to play one ultimate game. They have n piles, the i-th pile initially contain v_i chips. Alice selects a positive integer a from interval [1, m], and Bob selects a number b the same way.
Then the game starts. In her turn, Alice can select any pile containing at least a chips, and remove exactly a chips from it. Similarly, in his turn, Bob can choose any pile with at least b chips, and remove exactly b chips from it. If a player cannot make a move, he or she loses.
If both players play optimally, the outcome ultimately depends on the choice of a and b, and on the starting player. Consider a fixed pair (a,b). There are four types of games:
* Alice wins, regardless of who starts.
* Bob wins, regardless of who starts.
* If Alice starts, she wins. If Bob starts, he wins. We say that the first player wins.
* If Alice starts, Bob wins. If Bob starts, Alice wins. We say that the second player wins.
Among all choices of a and b (i.e. for each pair (a, b) such that 1≤ a, b≤ m), determine how many games are won by Alice (regardless of who starts), how many are won by Bob (regardless of who starts), how many are won by the first player, and how many are won by the second player.
Input
The first line contains two integers n and m (1 ≤ n ≤ 100, 1 ≤ m ≤ 10^5) — the number of piles, and the upper bound on the number of chips allowed to be taken in one turn, respectively.
The second line contains n integers v_1, v_2, ..., v_n (1 ≤ v_i ≤ 10^{18}) — the starting number of chips in each pile.
Output
Print a single line containing four integers w_a, w_b, w_f, w_s — the number of games won by Alice, Bob, the first player, the second player, respectively.
Examples
Input
2 2
4 5
Output
1 1 1 1
Input
2 20
4 5
Output
82 82 6 230
Note
In the first sample, there are a total of four choices for the tuple (a,b).
* a = b = 1: It does not matter from which pile the chips are removed — there are 9 turns to be made, and the first player also makes the last, and hence he wins.
* a = b = 2: The second player may win by always selecting the same pile as the first before there are 0 and 1 chips in the piles. Since it is impossible to remove 2 chips from any of them, the first player loses.
* a = 1 and b = 2:
* Suppose Alice starts. She can win by removing a single chip from the pile with 5 chips and then copying Bob's decision. After the next four turns, the game ends with 1 chip in each pile and Bob unable to make a move.
* Suppose Bob starts. If he removes two chips from second pile, Alice counters by removing a chip from the first pile. From then on, she can always copy Bob's decision and win. If Bob removes two chips from the first pile in his first turn, Alice can also remove one. As the first pile only has one chip left, Bob is forced to remove two chips from the second pile, leaving 3. Regardless of what Alice does, she wins.
Hence, Alice wins no matter who starts.
* a = 2 and b = 1: This is symmetric with the previous case — hence Bob always wins.
In the second sample, a lot of games, e.g. a = 7 and b = 6, end without anybody being able to remove single chip — which counts as a win for the second player. The games won for the first player are (1, 1), (1, 4), (2, 3), (3, 2), (4, 1), and (5, 5).
|
#include <bits/stdc++.h>
using namespace std;
long long arr[100005], ans[2];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%lld", arr + i);
}
for (int sum = 1; sum <= m << 1; sum++) {
vector<int> vec = {0};
for (int i = 0; i < n; i++) {
vec.push_back(arr[i] % sum);
}
vec.push_back(sum - 1);
sort(vec.begin(), vec.end());
for (int i = n + 1, t = 0; i; i--, t ^= 1) {
int x = max(vec[i - 1], vec[n - t] / 2) + 1, y = min(vec[i], m);
int a = max(x, sum - y), b = min(y, sum - x);
if (a <= b) ans[t] += b - a + 1;
}
}
long long x = ((long long)m * m - ans[0] - ans[1]) / 2;
printf("%lld %lld %lld %lld\n", x, x, ans[1], ans[0]);
return 0;
}
|
One of Arkady's friends works at a huge radio telescope. A few decades ago the telescope has sent a signal s towards a faraway galaxy. Recently they've received a response t which they believe to be a response from aliens! The scientists now want to check if the signal t is similar to s.
The original signal s was a sequence of zeros and ones (everyone knows that binary code is the universe-wide language). The returned signal t, however, does not look as easy as s, but the scientists don't give up! They represented t as a sequence of English letters and say that t is similar to s if you can replace all zeros in s with some string r_0 and all ones in s with some other string r_1 and obtain t. The strings r_0 and r_1 must be different and non-empty.
Please help Arkady's friend and find the number of possible replacements for zeros and ones (the number of pairs of strings r_0 and r_1) that transform s to t.
Input
The first line contains a string s (2 ≤ |s| ≤ 10^5) consisting of zeros and ones — the original signal.
The second line contains a string t (1 ≤ |t| ≤ 10^6) consisting of lowercase English letters only — the received signal.
It is guaranteed, that the string s contains at least one '0' and at least one '1'.
Output
Print a single integer — the number of pairs of strings r_0 and r_1 that transform s to t.
In case there are no such pairs, print 0.
Examples
Input
01
aaaaaa
Output
4
Input
001
kokokokotlin
Output
2
Note
In the first example, the possible pairs (r_0, r_1) are as follows:
* "a", "aaaaa"
* "aa", "aaaa"
* "aaaa", "aa"
* "aaaaa", "a"
The pair "aaa", "aaa" is not allowed, since r_0 and r_1 must be different.
In the second example, the following pairs are possible:
* "ko", "kokotlin"
* "koko", "tlin"
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long base = 73;
const int maxn = 1e6 + 10;
long long p[maxn];
int main() {
string s, t;
cin >> s >> t;
int cnt[2] = {0, 0};
int pr[2][s.length() + 1];
pr[0][0] = pr[1][0] = 0;
vector<int> v[2];
for (int i = 0; i < s.length(); i++) {
pr[0][i + 1] = pr[0][i];
pr[1][i + 1] = pr[1][i];
cnt[s[i] - '0']++;
pr[s[i] - '0'][i + 1]++;
v[s[i] - '0'].push_back(i + 1);
}
int len = t.length();
long long hash[len + 1];
hash[0] = 0;
p[0] = 1;
for (int i = 1; i < maxn; i++) {
p[i] = (p[i - 1] * base) % mod;
}
for (int i = 1; i <= len; i++) {
hash[i] =
(((hash[i - 1] + p[i - 1] * (t[i - 1] - 'a' + 1) % mod) % mod) + mod) %
mod;
}
int ans = 0;
for (int i = 1; i <= len / cnt[s[0] - '0']; i++) {
int ln[2];
ln[s[0] - '0'] = i;
ln[1 - (s[0] - '0')] =
(len - cnt[s[0] - '0'] * ln[s[0] - '0']) / cnt[1 - (s[0] - '0')];
if (ln[1] * cnt[1] + ln[0] * cnt[0] != len or ln[0] == 0 or ln[1] == 0)
continue;
long long hsh[2];
hsh[s[0] - '0'] = ((p[len + 1 - i] * hash[i] % mod) + mod) % mod;
int pos = v[1 - (s[0] - '0')][0] - 1;
int l = pos * i + 1;
int r = l + ln[1 - (s[0] - '0')] - 1;
hsh[1 - (s[0] - '0')] =
((p[len + 1 - r] * (hash[r] - hash[l - 1]) % mod) + mod) % mod;
if (hsh[0] == hsh[1]) continue;
bool ok = true;
for (int j = 0; j < 2; j++) {
for (int x : v[j]) {
int l = pr[0][x - 1] * ln[0] + pr[1][x - 1] * ln[1] + 1;
int r = l + ln[j] - 1;
ok &= hsh[j] ==
((p[len + 1 - r] * (hash[r] - hash[l - 1]) % mod) + mod) % mod;
}
}
ans += ok;
}
cout << ans << endl;
return 0;
}
|
The German University in Cairo (GUC) dorm houses are numbered from 1 to n. Underground water pipes connect these houses together. Each pipe has certain direction (water can flow only in this direction and not vice versa), and diameter (which characterizes the maximal amount of water it can handle).
For each house, there is at most one pipe going into it and at most one pipe going out of it. With the new semester starting, GUC student and dorm resident, Lulu, wants to install tanks and taps at the dorms. For every house with an outgoing water pipe and without an incoming water pipe, Lulu should install a water tank at that house. For every house with an incoming water pipe and without an outgoing water pipe, Lulu should install a water tap at that house. Each tank house will convey water to all houses that have a sequence of pipes from the tank to it. Accordingly, each tap house will receive water originating from some tank house.
In order to avoid pipes from bursting one week later (like what happened last semester), Lulu also has to consider the diameter of the pipes. The amount of water each tank conveys should not exceed the diameter of the pipes connecting a tank to its corresponding tap. Lulu wants to find the maximal amount of water that can be safely conveyed from each tank to its corresponding tap.
Input
The first line contains two space-separated integers n and p (1 ≤ n ≤ 1000, 0 ≤ p ≤ n) — the number of houses and the number of pipes correspondingly.
Then p lines follow — the description of p pipes. The i-th line contains three integers ai bi di, indicating a pipe of diameter di going from house ai to house bi (1 ≤ ai, bi ≤ n, ai ≠ bi, 1 ≤ di ≤ 106).
It is guaranteed that for each house there is at most one pipe going into it and at most one pipe going out of it.
Output
Print integer t in the first line — the number of tank-tap pairs of houses.
For the next t lines, print 3 integers per line, separated by spaces: tanki, tapi, and diameteri, where tanki ≠ tapi (1 ≤ i ≤ t). Here tanki and tapi are indexes of tank and tap houses respectively, and diameteri is the maximum amount of water that can be conveyed. All the t lines should be ordered (increasingly) by tanki.
Examples
Input
3 2
1 2 10
2 3 20
Output
1
1 3 10
Input
3 3
1 2 20
2 3 10
3 1 5
Output
0
Input
4 2
1 2 60
3 4 50
Output
2
1 2 60
3 4 50
|
import java.io.*;
import java.lang.*;
import java.util.*;
public class ProgC {
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;
}
}
int outgoing[];
int incoming[];
int diameter[];
ArrayList<Integer>f;
ArrayList<Integer>s;
ArrayList<Integer>th;
HashSet<Integer>visited = new HashSet<>();
public static void main(String[] args) {
ProgC cr = new ProgC();cr.run();
}
private void run() {
FastReader fr = new FastReader();
int n = fr.nextInt();
int p = fr.nextInt();
outgoing = new int[n+1];f = new ArrayList<>();
s = new ArrayList<>();th = new ArrayList<>();
incoming = new int[n+1];
diameter = new int[n+1];
for(int i=0;i<=n;i++)
diameter[i] = Integer.MAX_VALUE;
while(p-->0)
{
int a =fr.nextInt();int b = fr.nextInt();int d = fr.nextInt();
outgoing[a] = b;incoming[b] = a;diameter[a] =d;
}
int cnt = 0;
for(int i=1;i<=n;i++)
{
if(!visited.contains(i) && incoming[i]==0 && outgoing[i]!=0)
{
visited.add(i);
cnt++;
f.add(i);
dfs(outgoing[i],diameter[i]);
}
}
System.out.println(cnt);
for(int i=0;i<f.size();i++)
System.out.println(f.get(i)+" "+s.get(i)+" "+th.get(i));
}
private void dfs(int i, int j) {
visited.add(i);
if(outgoing[i]==0)
{
s.add(i);
th.add(j);
return;
}
dfs(outgoing[i],Math.min(j, diameter[i]));
}
}
|
Mitya and Vasya are playing an interesting game. They have a rooted tree with n vertices, and the vertices are indexed from 1 to n. The root has index 1. Every other vertex i ≥ 2 has its parent p_i, and vertex i is called a child of vertex p_i.
There are some cookies in every vertex of the tree: there are x_i cookies in vertex i. It takes exactly t_i time for Mitya to eat one cookie in vertex i. There is also a chip, which is initially located in the root of the tree, and it takes l_i time to move the chip along the edge connecting vertex i with its parent.
Mitya and Vasya take turns playing, Mitya goes first.
* Mitya moves the chip from the vertex, where the chip is located, to one of its children.
* Vasya can remove an edge from the vertex, where the chip is located, to one of its children. Vasya can also decide to skip his turn.
<image>
Mitya can stop the game at any his turn. Once he stops the game, he moves the chip up to the root, eating some cookies along his way. Mitya can decide how many cookies he would like to eat in every vertex on his way. The total time spent on descend, ascend and eating cookies should not exceed T. Please note that in the end of the game the chip is always located in the root of the tree: Mitya can not leave the chip in any other vertex, even if he has already eaten enough cookies — he must move the chip back to the root (and every move from vertex v to its parent takes l_v time).
Find out what is the maximum number of cookies Mitya can eat, regardless of Vasya's actions.
Input
The first line contains two integers n and T — the number of vertices in the tree and the time he has to accomplish his task (2≤ n ≤ 10^5; 1≤ T≤10^{18}).
The second line contains n integers x_1, x_2, ..., x_n — number of cookies located in the corresponding vertex (1≤ x_i≤10^6). The third line contains n integers t_1, t_2, ..., t_n — how much time it takes Mitya to eat one cookie in vertex i (1≤ t_i≤10^6).
Each of the following n - 1 lines describe the tree. For every i from 2 to n, the corresponding line contains two integers p_i and l_i, where p_i denotes the parent of vertex i and l_i denotes the time it takes Mitya to move the chip along the edge from vertex i to its parent (1≤ p_i < i, 0≤ l_i ≤ 10^9).
Output
Output a single integer — maximum number of cookies Mitya can eat.
Examples
Input
5 26
1 5 1 7 7
1 3 2 2 2
1 1
1 1
2 0
2 0
Output
11
Input
3 179
2 2 1
6 6 6
1 3
2 3
Output
4
Note
In the first example test case, Mitya can start by moving the chip to vertex 2. In this case no matter how Vasya plays, Mitya is able to eat at least 11 cookies. Below you can find the detailed description of the moves:
1. Mitya moves chip to vertex 2.
2. Vasya removes edge to vertex 4.
3. Mitya moves chip to vertex 5.
4. Since vertex 5 has no children, Vasya does not remove any edges.
5. Mitya stops the game and moves the chip towards the root, eating cookies along the way (7 in vertex 5, 3 in vertex 2, 1 in vertex 1).
Mitya spend 1+0 time to go down, 0+1 to go up, 7⋅ 2 to eat 7 cookies in vertex 5, 3⋅ 3 to eat 3 cookies in vertex 2, 1⋅ 1 to eat 1 cookie in vertex 1. Total time is 1+0+0+1+7⋅ 2+3⋅ 3+1⋅ 1=26.
|
#include <bits/stdc++.h>
using namespace std;
int cc[100002];
pair<int, int> in[100002];
vector<pair<int, int> > adj[100002];
int pos = 1;
int l[100002], r[100002], label[100002];
long long d[100002];
void dfs(int node, int par, long long depth = 0) {
l[node] = pos;
d[node] = depth;
int ch, w;
for (pair<int, int> edge : adj[node]) {
if (edge.first == par) {
continue;
}
dfs(edge.first, node, depth + edge.second);
}
label[pos] = node;
r[node] = pos++;
}
long long pen[100002];
void update(int ind, long long add) {
while (ind < 100002) {
pen[ind] += add;
ind += ind & (-ind);
}
}
long long query(int ind) {
long long ret = 0;
while (ind > 0) {
ret = ret + pen[ind];
ind = ind & (ind - 1);
}
return ret;
}
pair<long long, int> seg[100002 * 4];
long long lazy[100002 * 4];
const long long inf = -4e18;
void init(int pos, int l, int r) {
lazy[pos] = 0;
if (l == r) {
seg[pos] = {d[label[l]], l};
return;
}
int mid = (l + r) / 2;
init(pos * 2, l, mid);
init(pos * 2 + 1, mid + 1, r);
seg[pos] = max(seg[pos * 2], seg[pos * 2 + 1]);
}
void push(int pos, int l, int r) {
if (lazy[pos] != 0) {
seg[pos].first += lazy[pos];
if (l != r) {
lazy[pos * 2] += lazy[pos];
lazy[pos * 2 + 1] += lazy[pos];
}
lazy[pos] = 0;
}
}
void update(int pos, int l, int r, int ql, int qr, long long val) {
push(pos, l, r);
if (r < ql || qr < l) {
return;
}
if (ql <= l && r <= qr) {
lazy[pos] = val;
push(pos, l, r);
return;
}
int mid = (l + r) / 2;
update(pos * 2, l, mid, ql, qr, val);
update(pos * 2 + 1, mid + 1, r, ql, qr, val);
seg[pos] = max(seg[pos * 2], seg[pos * 2 + 1]);
}
pair<long long, int> query(int pos, int l, int r, int ql, int qr) {
push(pos, l, r);
if (r < ql || qr < l) {
return {inf, 0};
}
if (ql <= l && r <= qr) {
return seg[pos];
}
int mid = (l + r) / 2;
return max(query(pos * 2, l, mid, ql, qr),
query(pos * 2 + 1, mid + 1, r, ql, qr));
}
long long w[100002];
long long dfs2(int node, int par) {
priority_queue<long long> pq;
for (pair<int, int> edge : adj[node]) {
if (edge.first == par) {
continue;
}
pq.push(dfs2(edge.first, node));
}
long long ret = w[node];
if (node != 1) {
if (pq.size() > 0) pq.pop();
}
if (pq.size() > 0) {
ret = max(ret, pq.top());
}
return ret;
}
void solve() {
int n;
long long T;
scanf("%d %lld ", &n, &T);
long long rb = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d ", &cc[i]);
rb += cc[i];
}
for (int i = 1; i <= n; ++i) {
scanf("%d ", &in[i].first);
in[i].second = i;
}
sort(in + 1, in + n + 1);
for (int i = 2; i <= n; ++i) {
int p, l;
scanf("%d %d ", &p, &l);
l *= 2;
adj[p].push_back({i, l});
}
dfs(1, 0);
init(1, 1, n);
for (int i = 1; i <= n; ++i) {
int node, co, p, x, y;
node = in[i].second;
co = cc[node];
p = r[node];
x = l[node], y = p;
long long val = (long long)co * in[i].first;
while (true) {
pair<long long, int> q = query(1, 1, n, x, y);
if (q.first + val >= T) {
long long remCC = min((T - q.first) / in[i].first, (long long)co);
w[label[q.second]] = query(q.second) + remCC;
update(1, 1, n, q.second, q.second, inf);
} else {
break;
}
}
update(1, 1, n, x, y, val);
update(x, co);
update(y + 1, -co);
}
while (true) {
pair<long long, int> q = query(1, 1, n, 1, n);
if (q.first < 0) {
break;
}
w[label[q.second]] = query(q.second);
update(1, 1, n, q.second, q.second, inf);
}
printf("%lld\n", dfs2(1, 0));
}
int main() {
solve();
return 0;
}
|
Little Petya loves playing with rectangles. Mom bought Petya a rectangle divided into cells n × m in size (containing n rows, m columns). Petya marked two different cells of the rectangle and now he is solving the following task:
Let's define a simple path between those two cells as a sequence of distinct cells a1, a2, ..., ak, where a1 and ak are the two marked cells. Besides, ai and ai + 1 are side-neighboring cells of the path (1 ≤ i < k). Let's denote the path length as number k (the sequence length).
Petya's task is to find the longest simple path's length and to print the path. Help him.
Input
The first line contains space-separated integers n and m (4 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the rectangle, correspondingly. The second line contains space-separated integers x1 and y1 — the coordinates of the first marked cell. The third line contains space-separated integers x2 y2 — the coordinates of the second marked cell (1 < x1, x2 < n, 1 < y1, y2 < m, x1 ≠ x2, y1 ≠ y2).
The coordinates of a marked cell are a pair of integers x y, where x represents the row's number and y represents the column's number. The rows are numbered from top to bottom with consecutive integers from 1 to n. The columns are numbered from the left to the right by consecutive integers from 1 to m.
It is guaranteed that the marked cells are not positioned in one row or column.
Output
In the first line print the length of the found path — k. In the next lines print k pairs of integers, one per line — coordinates of the cells that constitute the found path in the order, in which they follow in the path (the path must go from cell (x1, y1) to cell (x2, y2)). If there are several solutions, print any of them.
Examples
Input
4 4
2 2
3 3
Output
15
2 2
1 2
1 1
2 1
3 1
4 1
4 2
4 3
4 4
3 4
2 4
1 4
1 3
2 3
3 3
Note
The statement test is described in the picture:
<image>
|
#include <bits/stdc++.h>
using namespace std;
bool good(int h, int w, int first, int second) {
if (first < 0 || second < 0) return false;
if (h > w) {
swap(h, w);
swap(first, second);
}
if (h == 1) return second >= w - 2;
return first != 0 || second != 0;
}
void f(int h, int w, int first, int second, int dy, int dx, int sy, int sx,
vector<pair<int, int> > &res) {
if (first == 0 && second == 0) {
res.emplace_back(dy, dx);
} else if (good(h - 1, w, first - 1, w - 1 - second)) {
for (int i = (0); i < (w); i++) res.emplace_back(dy, dx + sx * i);
f(h - 1, w, first - 1, w - 1 - second, dy + sy, dx + sx * (w - 1), sy, -sx,
res);
} else if (good(h, w - 1, h - 1 - first, second - 1)) {
for (int i = (0); i < (h); i++) res.emplace_back(dy + sy * i, dx);
f(h, w - 1, h - 1 - first, second - 1, dy + sy * (h - 1), dx + sx, -sy, sx,
res);
}
}
void append(vector<pair<int, int> > &a, vector<pair<int, int> > &b) {
a.insert(a.end(), b.begin(), b.end());
}
int main() {
int h, w, x1, y1, x2, y2;
scanf("%d %d", &h, &w);
scanf("%d %d %d %d", &y1, &x1, &y2, &x2);
y1--;
x1--;
y2--;
x2--;
bool sxy = false, fx = false, fy = false;
if (x1 == x2 || (y1 != y2 && h % 2 == 1)) {
sxy = true;
swap(h, w);
swap(x1, y1);
swap(x2, y2);
}
if (x1 > x2) {
fx = true;
x1 = w - 1 - x1;
x2 = w - 1 - x2;
}
if (y1 == h - 2) {
fy = true;
y1 = h - 1 - y1;
y2 = h - 1 - y2;
}
vector<pair<int, int> > res;
if (y1 == y2 && h % 2 == 1 && w % 2 == 0 && x1 % 2 != x2 % 2) {
if (x1 % 2 == 1) {
vector<pair<int, int> > lt, b, rt;
f(y1 + 1, x1 + 1, 0, x1, y1, x1, -1, -1, lt);
f(h - y1 - 1, w, 0, w - 1, y1 + 1, 0, 1, 1, b);
f(y1 + 1, w - x1 - 1, 0, w - x2 - 1, y1, w - 1, -1, -1, rt);
res = lt;
append(res, b);
append(res, rt);
} else {
vector<pair<int, int> > lt, lm, trb, b, tri;
f(y1 + 1, x1 + 1, y1, 0, y1, x1, -1, -1, lt);
if (x2 - x1 > 1)
f(y1 + 1, x2 - x1 - 1, 0, x2 - x1 - 2, 0, x1 + 1, 1, 1, lm);
for (int second = (x2); second < (w); second++)
trb.emplace_back(0, second);
for (int first = (1); first < (y2 + 1); first++)
trb.emplace_back(first, w - 1);
f(h - y1 - 1, w, 0, 1, y2 + 1, w - 1, 1, -1, b);
f(y2, w - x2 - 1, 0, w - x2 - 2, y2, w - 2, -1, -1, tri);
res = lt;
append(res, lm);
append(res, trb);
append(res, b);
append(res, tri);
}
} else {
vector<pair<int, int> > lt, rt, lb, rb;
f(h, x1 + 1, y1, 0, 0, x1, 1, -1, lt);
reverse(lt.begin(), lt.end());
f(h, w - x1 - 1, y2, x2 - x1 - 1, 0, x1 + 1, 1, 1, rt);
append(lt, rt);
f(h, x1 + 1, h - 1 - y1, 0, h - 1, x1, -1, -1, lb);
reverse(lb.begin(), lb.end());
f(h, w - x1 - 1, h - 1 - y2, x2 - x1 - 1, h - 1, x1 + 1, -1, 1, rb);
append(lb, rb);
if (int(lt.size()) < int(lb.size()))
res = lb;
else
res = lt;
}
if (fy) {
for (auto &p : res) p.first = h - 1 - p.first;
y1 = h - 1 - y1;
y2 = h - 1 - y2;
}
if (fx) {
for (auto &p : res) p.second = w - 1 - p.second;
x1 = w - 1 - x1;
x2 = w - 1 - x2;
}
if (sxy) {
swap(h, w);
swap(x1, y1);
swap(x2, y2);
for (auto &p : res) swap(p.second, p.first);
}
printf("%d\n", int(res.size()));
for (auto p : res) printf("%d %d\n", p.first + 1, p.second + 1);
}
|
Inaka has a disc, the circumference of which is n units. The circumference is equally divided by n points numbered clockwise from 1 to n, such that points i and i + 1 (1 ≤ i < n) are adjacent, and so are points n and 1.
There are m straight segments on the disc, the endpoints of which are all among the aforementioned n points.
Inaka wants to know if her image is rotationally symmetrical, i.e. if there is an integer k (1 ≤ k < n), such that if all segments are rotated clockwise around the center of the circle by k units, the new image will be the same as the original one.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 100 000, 1 ≤ m ≤ 200 000) — the number of points and the number of segments, respectively.
The i-th of the following m lines contains two space-separated integers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) that describe a segment connecting points a_i and b_i.
It is guaranteed that no segments coincide.
Output
Output one line — "Yes" if the image is rotationally symmetrical, and "No" otherwise (both excluding quotation marks).
You can output each letter in any case (upper or lower).
Examples
Input
12 6
1 3
3 7
5 7
7 11
9 11
11 3
Output
Yes
Input
9 6
4 5
5 6
7 8
8 9
1 2
2 3
Output
Yes
Input
10 3
1 2
3 2
7 2
Output
No
Input
10 2
1 6
2 7
Output
Yes
Note
The first two examples are illustrated below. Both images become the same as their respective original ones after a clockwise rotation of 120 degrees around the center.
<image>
|
from math import gcd
def primes():
yield 2; yield 3; yield 5; yield 7;
bps = (p for p in primes()) # separate supply of "base" primes (b.p.)
p = next(bps) and next(bps) # discard 2, then get 3
q = p * p # 9 - square of next base prime to keep track of,
sieve = {} # in the sieve dict
n = 9 # n is the next candidate number
while True:
if n not in sieve: # n is not a multiple of any of base primes,
if n < q: # below next base prime's square, so
yield n # n is prime
else:
p2 = p + p # n == p * p: for prime p, add p * p + 2 * p
sieve[q + p2] = p2 # to the dict, with 2 * p as the increment step
p = next(bps); q = p * p # pull next base prime, and get its square
else:
s = sieve.pop(n); nxt = n + s # n's a multiple of some b.p., find next multiple
while nxt in sieve: nxt += s # ensure each entry is unique
sieve[nxt] = s # nxt is next non-marked multiple of this prime
n += 2 # work on odds only
import itertools
def get_prime_divisors(limit):
return list(itertools.filterfalse(lambda p: limit % p, itertools.takewhile(lambda p: p <= limit, primes())))
n, m = map(int, input().split())
data = {}
for _ in range(m):
a, b = map(int, input().split())
a, b = min(a, b)-1, max(a, b)-1
x, y = b-a, n-b+a
if x <= y:
if x in data:
data[x].add(a)
else:
data[x] = set([a])
if y <= x:
if y in data:
data[y].add(b)
else:
data[y] = set([b])
t = n
for s in data.values():
t = gcd(t, len(s))
if t == 1:
print("No")
else:
tests = get_prime_divisors(t)
for k in tests:
d = n//k
for s in data.values():
if any(map(lambda v: (v+d)%n not in s, s)):
break
else:
print("Yes")
break
else:
print("No")
|
Toad Pimple has an array of integers a_1, a_2, …, a_n.
We say that y is reachable from x if x<y and there exists an integer array p such that x = p_1 < p_2 < … < p_k=y, and a_{p_i} \& a_{p_{i+1}} > 0 for all integers i such that 1 ≤ i < k.
Here \& denotes the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND).
You are given q pairs of indices, check reachability for each of them.
Input
The first line contains two integers n and q (2 ≤ n ≤ 300 000, 1 ≤ q ≤ 300 000) — the number of integers in the array and the number of queries you need to answer.
The second line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 300 000) — the given array.
The next q lines contain two integers each. The i-th of them contains two space-separated integers x_i and y_i (1 ≤ x_i < y_i ≤ n). You need to check if y_i is reachable from x_i.
Output
Output q lines. In the i-th of them print "Shi" if y_i is reachable from x_i, otherwise, print "Fou".
Example
Input
5 3
1 3 0 2 1
1 3
2 4
1 4
Output
Fou
Shi
Shi
Note
In the first example, a_3 = 0. You can't reach it, because AND with it is always zero. a_2 \& a_4 > 0, so 4 is reachable from 2, and to go from 1 to 4 you can use p = [1, 2, 4].
|
#include <bits/stdc++.h>
const long long mod1 = (long long)1e9 + 7;
const long long mod2 = (long long)1e9 + 9;
const long long BASE = 15879;
const long long inf = (long long)1e18;
const long double e = 2.718281828459;
const long double pi = 3.141592653;
const long double EPS = 1e-9;
using namespace std;
template <class T>
istream &operator>>(istream &in, vector<T> &arr) {
for (T &cnt : arr) {
in >> cnt;
}
return in;
};
void solve() {
long long n, q;
cin >> n >> q;
vector<long long> arr(n);
cin >> arr;
long long B = 20;
vector<vector<long long>> dp(n, vector<long long>(B, inf));
vector<long long> nxt(B, -1);
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < B; j++) {
if (nxt[j] != -1 and (arr[i] & (1 << j)) != 0) {
for (int k = 0; k < B; k++) {
dp[i][k] = min(dp[nxt[j]][k], dp[i][k]);
if (arr[nxt[j]] & (1 << k)) {
dp[i][k] = min(dp[i][k], nxt[j]);
}
}
}
if (arr[i] & (1 << j)) {
nxt[j] = i;
}
}
}
while (q--) {
long long x, y;
cin >> x >> y;
x--;
y--;
bool ans = false;
for (int i = 0; i < B; i++) {
if (arr[y] & (1 << i)) {
ans |= dp[x][i] <= y;
}
}
if (ans) {
cout << "Shi\n";
} else {
cout << "Fou\n";
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(30);
long long seed = time(0);
srand(seed);
solve();
return 0;
}
|
Vus the Cossack has a simple graph with n vertices and m edges. Let d_i be a degree of the i-th vertex. Recall that a degree of the i-th vertex is the number of conected edges to the i-th vertex.
He needs to remain not more than ⌈ (n+m)/(2) ⌉ edges. Let f_i be the degree of the i-th vertex after removing. He needs to delete them in such way so that ⌈ (d_i)/(2) ⌉ ≤ f_i for each i. In other words, the degree of each vertex should not be reduced more than twice.
Help Vus to remain the needed edges!
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^6, 0 ≤ m ≤ 10^6) — the number of vertices and edges respectively.
Each of the next m lines contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n) — vertices between which there is an edge.
It is guaranteed that the graph does not have loops and multiple edges.
It is possible to show that the answer always exists.
Output
In the first line, print one integer k (0 ≤ k ≤ ⌈ (n+m)/(2) ⌉) — the number of edges which you need to remain.
In each of the next k lines, print two integers u_i and v_i (1 ≤ u_i, v_i ≤ n) — the vertices, the edge between which, you need to remain. You can not print the same edge more than once.
Examples
Input
6 6
1 2
2 3
3 4
4 5
5 3
6 5
Output
5
2 1
3 2
5 3
5 4
6 5
Input
10 20
4 3
6 5
4 5
10 8
4 8
5 8
10 4
9 5
5 1
3 8
1 2
4 7
1 4
10 7
1 7
6 1
9 6
3 9
7 9
6 2
Output
12
2 1
4 1
5 4
6 5
7 1
7 4
8 3
8 5
9 3
9 6
10 4
10 7
|
import sys
range = xrange
input = raw_input
inp = [int(x) for x in sys.stdin.read().split()]; ii = 0
n = inp[ii]; ii += 1
m = inp[ii]; ii += 1
U = []
coupl = [[] for _ in range(n)]
for _ in range(m):
u = inp[ii] - 1; ii += 1
v = inp[ii] - 1; ii += 1
U.append(u)
U.append(v)
coupl[u].append(2*_)
coupl[v].append(2*_ + 1)
rem = [0]*m
counter = [len(c) - 1 for c in coupl]
remcounter = [0]*n
keep = []
for node in range(n):
par = 0
if (len(coupl[node]) - remcounter[node]) & 1:
while (len(coupl[node]) - remcounter[node]) & 1:
while rem[coupl[node][counter[node]] >> 1]: counter[node] -= 1
eind = coupl[node][counter[node]]
par ^= 1
if par:
keep.append(eind)
rem[eind >> 1] = 1
remcounter[node] += 1
node = U[eind ^ 1]
remcounter[node] += 1
if not par:
keep.append(eind)
for root in range(n):
node = root
par = 0
while len(coupl[root]) != remcounter[root]:
while rem[coupl[node][counter[node]] >> 1]: counter[node] -= 1
eind = coupl[node][counter[node]]
par ^= 1
if par:
keep.append(eind)
rem[eind >> 1] = 1
remcounter[node] += 1
node = U[eind ^ 1]
remcounter[node] += 1
print len(keep)
print '\n'.join('%d %d' % (U[eind] + 1, U[eind ^ 1] + 1) for eind in keep)
|
You are given integers n, k. Let's consider the alphabet consisting of k different elements.
Let beauty f(s) of the string s be the number of indexes i, 1≤ i<|s|, for which prefix of s of length i equals to suffix of s of length i. For example, beauty of the string abacaba equals 2, as for i = 1, 3 prefix and suffix of length i are equal.
Consider all words of length n in the given alphabet. Find the expected value of f(s)^2 of a uniformly chosen at random word. We can show that it can be expressed as P/Q, where P and Q are coprime and Q isn't divided by 10^9 + 7. Output P⋅ Q^{-1} mod 10^9 + 7.
Input
The first and the only line contains two integers n, k (1≤ n ≤ 10^5, 1≤ k≤ 10^9) — the length of a string and the size of alphabet respectively.
Output
Output a single integer — P× Q^{-1} mod 10^9 + 7.
Examples
Input
2 3
Output
333333336
Input
1 5
Output
0
Input
100 1
Output
9801
Input
10 10
Output
412377396
Note
In the first example, there are 9 words of length 2 in alphabet of size 3 — aa, ab, ac, ba, bb, bc, ca, cb, cc. 3 of them have beauty 1 and 6 of them have beauty 0, so the average value is 1/3.
In the third example, there is only one such word, and it has beauty 99, so the average value is 99^2.
|
#include <bits/stdc++.h>
using namespace std;
long long cc[400005], ans;
int u[400005], c, D[400005], n, i, j, cnt, x, y, d, is[400005], p[400005];
inline long long cal(int mx, int f1, int f2) {
long long res = 0;
for (int i = 2; i <= mx + mx; ++i)
res += cc[max(f2, i * f1 - n)] * min(i - 1, mx + mx + 1 - i);
return res % 1000000007;
}
long long ksm(long long x, long long y) {
long long ret = 1;
for (; y; y >>= 1, x = x * x % 1000000007)
if (y & 1) ret = ret * x % 1000000007;
return ret;
}
int main() {
cin >> n >> c;
for (i = cc[0] = 1; i <= n + n; ++i) cc[i] = cc[i - 1] * c % 1000000007;
for (i = 2, u[1] = D[1] = 1; i <= n; ++i) {
if (!is[i]) p[++cnt] = i, D[i] = 2, u[i] = -1;
for (j = 1; j <= cnt && (d = i * p[j]) < 400005; ++j) {
is[d] = 1;
if (i % p[j] == 0) {
x = i / p[j];
y = 3;
while (x % p[j] == 0) x /= p[j], ++y;
D[d] = D[x] * y;
break;
}
D[d] = D[i] << 1;
u[d] = -u[i];
}
}
int h = n - 1;
for (i = 1; i <= h; ++i)
for (x = h / i, j = 1; j <= x; ++j) ans += u[j] * cal(x / j, i * j, i);
cout << (ans % 1000000007 + 1000000007) * ksm(cc[n], 1000000007 - 2) %
1000000007;
}
|
You are given two strings of equal length s and t consisting of lowercase Latin letters. You may perform any number (possibly, zero) operations on these strings.
During each operation you choose two adjacent characters in any string and assign the value of the first character to the value of the second or vice versa.
For example, if s is "acbc" you can get the following strings in one operation:
* "aabc" (if you perform s_2 = s_1);
* "ccbc" (if you perform s_1 = s_2);
* "accc" (if you perform s_3 = s_2 or s_3 = s_4);
* "abbc" (if you perform s_2 = s_3);
* "acbb" (if you perform s_4 = s_3);
Note that you can also apply this operation to the string t.
Please determine whether it is possible to transform s into t, applying the operation above any number of times.
Note that you have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 100) — the number of queries. Each query is represented by two consecutive lines.
The first line of each query contains the string s (1 ≤ |s| ≤ 100) consisting of lowercase Latin letters.
The second line of each query contains the string t (1 ≤ |t| ≤ 100, |t| = |s|) consisting of lowercase Latin letters.
Output
For each query, print "YES" if it is possible to make s equal to t, and "NO" otherwise.
You may print every letter in any case you want (so, for example, the strings "yEs", "yes", "Yes", and "YES" will all be recognized as positive answer).
Example
Input
3
xabb
aabx
technocup
technocup
a
z
Output
YES
YES
NO
Note
In the first query, you can perform two operations s_1 = s_2 (after it s turns into "aabb") and t_4 = t_3 (after it t turns into "aabb").
In the second query, the strings are equal initially, so the answer is "YES".
In the third query, you can not make strings s and t equal. Therefore, the answer is "NO".
|
for _ in range(int(input())):
s=input()
s1=input()
s=set(s)
s1=set(s1)
if s1&s:
print('YES')
else:
print('NO')
|
There are n seats in the train's car and there is exactly one passenger occupying every seat. The seats are numbered from 1 to n from left to right. The trip is long, so each passenger will become hungry at some moment of time and will go to take boiled water for his noodles. The person at seat i (1 ≤ i ≤ n) will decide to go for boiled water at minute t_i.
Tank with a boiled water is located to the left of the 1-st seat. In case too many passengers will go for boiled water simultaneously, they will form a queue, since there can be only one passenger using the tank at each particular moment of time. Each passenger uses the tank for exactly p minutes. We assume that the time it takes passengers to go from their seat to the tank is negligibly small.
Nobody likes to stand in a queue. So when the passenger occupying the i-th seat wants to go for a boiled water, he will first take a look on all seats from 1 to i - 1. In case at least one of those seats is empty, he assumes that those people are standing in a queue right now, so he would be better seating for the time being. However, at the very first moment he observes that all seats with numbers smaller than i are busy, he will go to the tank.
There is an unspoken rule, that in case at some moment several people can go to the tank, than only the leftmost of them (that is, seating on the seat with smallest number) will go to the tank, while all others will wait for the next moment.
Your goal is to find for each passenger, when he will receive the boiled water for his noodles.
Input
The first line contains integers n and p (1 ≤ n ≤ 100 000, 1 ≤ p ≤ 10^9) — the number of people and the amount of time one person uses the tank.
The second line contains n integers t_1, t_2, ..., t_n (0 ≤ t_i ≤ 10^9) — the moments when the corresponding passenger will go for the boiled water.
Output
Print n integers, where i-th of them is the time moment the passenger on i-th seat will receive his boiled water.
Example
Input
5 314
0 310 942 628 0
Output
314 628 1256 942 1570
Note
Consider the example.
At the 0-th minute there were two passengers willing to go for a water, passenger 1 and 5, so the first passenger has gone first, and returned at the 314-th minute. At this moment the passenger 2 was already willing to go for the water, so the passenger 2 has gone next, and so on. In the end, 5-th passenger was last to receive the boiled water.
|
import java.io.BufferedInputStream;
import java.io.InputStream;
import java.io.PrintStream;
import java.util.*;
public class TaskE {
private static final String QUICK_ANSWER = "NO";
private final Scanner in;
private final StringBuilder out;
private final int n;
private final int p;
private final int[] t;
public TaskE(Scanner in, StringBuilder out) {
this.in = in;
this.out = out;
n = nextInt();
p = nextInt();
t = nextInts(n);
}
public void solve() throws QuickAnswer {
TreeSet<Integer> inQueue = new TreeSet<>();
TreeSet<Integer> ready = new TreeSet<>();
Deque<Integer> queue = new ArrayDeque<>();
Integer[] order = new Integer[n];
long[] result = new long[n];
for(int i = 0; i < n; ++i){
order[i] = i;
}
Arrays.sort(order, (i1 , i2) -> t[i1] == t[i2] ? i1 - i2 : t[i1] - t[i2]);
long time = 0;
for(int i = 0; i < n; ++i){
int num = order[i];
int tm = t[num];
while(!queue.isEmpty() && time + p < tm) {
int first = queue.pollFirst();
time += p;
result[first] = time;
inQueue.remove(first);
if (!ready.isEmpty() && (inQueue.isEmpty() || inQueue.first() > ready.first())) {
Integer f = ready.pollFirst();
inQueue.add(f);
queue.addLast(f);
}
}
if(queue.isEmpty()) {
time = tm;
}
ready.add(num);
while(!queue.isEmpty() && time + p <= tm) {
int first = queue.pollFirst();
time += p;
result[first] = time;
inQueue.remove(first);
if (!ready.isEmpty() && (inQueue.isEmpty() || inQueue.first() > ready.first())) {
Integer f = ready.pollFirst();
inQueue.add(f);
queue.addLast(f);
}
}
if (!ready.isEmpty() && (inQueue.isEmpty() || inQueue.first() > ready.first())) {
Integer f = ready.pollFirst();
inQueue.add(f);
queue.addLast(f);
}
}
while(!queue.isEmpty()) {
int first = queue.pollFirst();
time += p;
result[first] = time;
inQueue.remove(first);
if (!ready.isEmpty() && (inQueue.isEmpty() || inQueue.first() > ready.first())) {
Integer f = ready.pollFirst();
inQueue.add(f);
queue.addLast(f);
}
}
for(long l : result){
printsp(l);
}
}
// Common functions
void quickAnswer(String answer) throws QuickAnswer {
throw new QuickAnswer(answer);
}
void quickAnswer() throws QuickAnswer {
quickAnswer(QUICK_ANSWER);
}
static class QuickAnswer extends Exception {
private String answer;
public QuickAnswer(String answer) {
this.answer = answer;
}
}
void print(Object... args) {
String prefix = "";
for (Object arg : args) {
out.append(prefix);
out.append(arg);
prefix = " ";
}
}
void println(Object... args) {
print(args);
out.append("\n");
}
void printsp(Object... args) {
print(args);
out.append(" ");
}
int nextInt() {
return in.nextInt();
}
long nextLong() {
return in.nextLong();
}
String nextString() {
String res = in.nextLine();
return res.trim().isEmpty() ? in.nextLine() : res;
}
int[] nextInts(int count) {
int[] res = new int[count];
for (int i = 0; i < count; ++i) {
res[i] = in.nextInt();
}
return res;
}
long[] nextLongs(int count) {
long[] res = new long[count];
for (int i = 0; i < count; ++i) {
res[i] = in.nextInt();
}
return res;
}
public static void main(String[] args) {
doMain(System.in, System.out);
}
static void doMain(InputStream inStream, PrintStream outStream) {
Scanner in = new Scanner(new BufferedInputStream(inStream)).useLocale(Locale.ENGLISH);
StringBuilder totalOut = new StringBuilder();
int count = 1;
//count = in.nextInt();
while (count-- > 0) {
try {
StringBuilder out = new StringBuilder();
new TaskE(in, out).solve();
totalOut.append(out.toString());
} catch (QuickAnswer e) {
totalOut.append(e.answer);
}
if (count > 0) {
totalOut.append("\n");
}
}
outStream.print(totalOut.toString());
}
}
|
Daisy is a senior software engineer at RainyDay, LLC. She has just implemented three new features in their product: the first feature makes their product work, the second one makes their product fast, and the third one makes their product correct. The company encourages at least some testing of new features, so Daisy appointed her intern Demid to write some tests for the new features.
Interestingly enough, these three features pass all the tests on Demid's development server, which has index 1, but might fail the tests on some other servers.
After Demid has completed this task, Daisy appointed you to deploy these three features to all n servers of your company. For every feature f and every server s, Daisy told you whether she wants the feature f to be deployed on the server s. If she wants it to be deployed, it must be done even if the feature f fails the tests on the server s. If she does not want it to be deployed, you may not deploy it there.
Your company has two important instruments for the deployment of new features to servers: Continuous Deployment (CD) and Continuous Testing (CT). CD can be established between several pairs of servers, forming a directed graph. CT can be set up on some set of servers.
If CD is configured from the server s_1 to the server s_2 then every time s_1 receives a new feature f the system starts the following deployment process of f to s_2:
* If the feature f is already deployed on the server s_2, then nothing is done.
* Otherwise, if CT is not set up on the server s_1, then the server s_1 just deploys the feature f to the server s_2 without any testing.
* Otherwise, the server s_1 runs tests for the feature f. If the tests fail on the server s_1, nothing is done. If the tests pass, then the server s_1 deploys the feature f to the server s_2.
You are to configure the CD/CT system, and after that Demid will deploy all three features on his development server. Your CD/CT system must deploy each feature exactly to the set of servers that Daisy wants.
Your company does not have a lot of computing resources, so you can establish CD from one server to another at most 264 times.
Input
The first line contains integer n (2 ≤ n ≤ 256) — the number of servers in your company.
Next n lines contain three integers each. The j-th integer in the i-th line is 1 if Daisy wants the j-th feature to be deployed to the i-th server, or 0 otherwise.
Next n lines contain three integers each. The j-th integer in the i-th line is 1 if tests pass for the j-th feature on the i-th server, or 0 otherwise.
Demid's development server has index 1. It is guaranteed that Daisy wants all three features to be deployed to the server number 1, and all three features pass their tests on the server number 1.
Output
If it is impossible to configure CD/CT system with CD being set up between at most 264 pairs of servers, then output the single line "Impossible".
Otherwise, the first line of the output must contain the line "Possible".
Next line must contain n space-separated integers — the configuration of CT. The i-th integer should be 1 if you set up CT on the i-th server, or 0 otherwise.
Next line must contain the integer m (0 ≤ m ≤ 264) — the number of CD pairs you want to set up.
Each of the next m lines must describe CD configuration, each line with two integers s_i and t_i (1 ≤ s_i, t_i ≤ n; s_i ≠ t_i), establishing automated deployment of new features from the server s_i to the server t_i.
Examples
Input
3
1 1 1
1 0 1
1 1 1
1 1 1
0 0 0
1 0 1
Output
Possible
1 1 1
2
3 2
1 3
Input
2
1 1 1
0 0 1
1 1 1
1 1 0
Output
Impossible
Note
CD/CT system for the first sample test is shown below.
<image>
|
#include <bits/stdc++.h>
using namespace std;
const int M = 264;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> need(n), test(n);
for (int i = 0; i < n; ++i) {
int a, b, c;
cin >> a >> b >> c;
need[i] = a + 2 * b + 4 * c;
}
for (int i = 0; i < n; ++i) {
int a, b, c;
cin >> a >> b >> c;
test[i] = a + 2 * b + 4 * c;
}
vector<pair<int, int>> res;
vector<int> can(8, -1);
vector<bool> done(n, 0);
vector<bool> ct(n, 0);
can[7] = 0;
done[0] = 1;
for (int j = 0; j < 8; ++j) {
for (int i = 0; i < n; ++i) {
if (done[i]) continue;
done[i] = true;
if (need[i] == 0) continue;
if (can[need[i]] != -1) {
res.push_back({can[need[i]], i});
can[need[i] & test[i]] = i;
ct[i] = 1;
} else if (need[i] == 3 && can[1] != -1 && can[2] != -1) {
res.push_back({can[1], i});
res.push_back({can[2], i});
can[need[i]] = i;
} else if (need[i] == 5 && can[1] != -1 && can[4] != -1) {
res.push_back({can[1], i});
res.push_back({can[4], i});
can[need[i]] = i;
} else if (need[i] == 6 && can[2] != -1 && can[4] != -1) {
res.push_back({can[2], i});
res.push_back({can[4], i});
can[need[i]] = i;
} else {
done[i] = false;
}
}
}
bool fail = false;
for (int i = 0; i < n; ++i) {
if (!done[i]) fail = true;
}
if (fail)
cout << "Impossible\n";
else {
cout << "Possible\n";
for (int i = 0; i < n; ++i) cout << ct[i] << ' ';
cout << '\n';
cout << res.size() << '\n';
for (auto pr : res) cout << pr.first + 1 << ' ' << pr.second + 1 << '\n';
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.